ISO date time parsing

Author: bogdandm

TODO.md

@@ -32,10 +32,10 @@
             - [ ] Complex python types annotations
                 - [ ] Decorator to specify field metatype
                 - [ ] Specify metatype in attr/dataclass argument (if dataclasses has such)
-            - [ ] String based types
-                - [ ] ISO date
-                - [ ] ISO time
-                - [ ] ISO datetime
+            - [ ] String based types (Warning: 6 times slow down)
+                - [X] ISO date
+                - [X] ISO time
+                - [X] ISO datetime
     - API Layer
         - [ ] Route object
         - [ ] Register model as route in/out data spec
@@ -68,6 +68,10 @@
     - Generate OpenAPI spec
         - [ ] Meta-model -> OpenAPI model converter
         - [ ] Route -> OpenAPI converter
+    - [ ] String based types
+        - [ ] ISO date
+        - [ ] ISO time
+        - [ ] ISO datetime
 
 - Build, Deploy, CI
     - [ ] setup.py

rest_client_gen/dynamic_typing/__init__.py

@@ -3,6 +3,7 @@
 )
 from .complex import ComplexType, DList, DOptional, DTuple, DUnion, SingleType
 from .models_meta import AbsoluteModelRef, ModelMeta, ModelPtr
+from .string_datetime import IsoDateString, IsoDatetimeString, IsoTimeString, register_datetime_classes
 from .string_serializable import (
     BooleanString, FloatString, IntString, StringSerializable, StringSerializableRegistry, registry
 )

rest_client_gen/dynamic_typing/string_datetime.py

@@ -0,0 +1,116 @@
+import operator
+from datetime import date, datetime, time
+from typing import Optional
+
+import dateutil.parser
+
+from .string_serializable import StringSerializable, StringSerializableRegistry, registry
+
+_dt_args_getter = operator.attrgetter('year', 'month', 'day', 'hour', 'minute', 'second', 'microsecond', 'tzinfo')
+_d_args_getter = operator.attrgetter('year', 'month', 'day')
+_t_args_getter = operator.attrgetter('hour', 'minute', 'second', 'microsecond', 'tzinfo')
+
+
+def _extend_datetime(d, cls: type):
+    if isinstance(d, datetime):
+        args = _dt_args_getter
+    elif isinstance(d, time):
+        args = _t_args_getter
+    else:
+        args = _d_args_getter
+    return cls(*args(d))
+
+
+_check_values_date = (
+    datetime(2018, 1, 2, 0, 4, 5, 678, tzinfo=None),
+    datetime(2018, 1, 2, 9, 4, 5, 678, tzinfo=None)
+)
+
+
+def is_date(s: str) -> Optional[date]:
+    d1 = dateutil.parser.parse(s, default=_check_values_date[0])
+    d2 = dateutil.parser.parse(s, default=_check_values_date[1])
+    return None if d1 == d2 else d1.date()
+
+
+_check_values_time = (
+    datetime(2018, 10, 11, 0, 4, 5, 678, tzinfo=None),
+    datetime(2018, 12, 30, 0, 4, 5, 678, tzinfo=None)
+)
+
+
+def is_time(s: str) -> Optional[time]:
+    d1 = dateutil.parser.parse(s, default=_check_values_time[0])
+    d2 = dateutil.parser.parse(s, default=_check_values_time[1])
+    return None if d1 == d2 else d1.time()
+
+
+class IsoDateString(StringSerializable, date):
+    """
+    Parse date using dateutil.parser.isoparse. Representation format always is ``YYYY-MM-DD``.
+    You can override to_representation method to customize it. Just don't forget to call registry.remove(YourCls)
+    """
+
+    @classmethod
+    def to_internal_value(cls, value: str) -> 'IsoDateString':
+        if not is_date(value):
+            raise ValueError(f"'{value}' is not valid date")
+        dt = dateutil.parser.isoparse(value)
+        return _extend_datetime(dt.date(), cls)
+
+    def to_representation(self):
+        return self.isoformat()
+
+    def replace(self, *args, **kwargs) -> 'IsoDateString':
+        # noinspection PyTypeChecker
+        return date.replace(self, *args, **kwargs)
+
+
+class IsoTimeString(StringSerializable, time):
+    """
+    Parse time using dateutil.parser.parse. Representation format always is ``hh:mm:ss.ms``.
+    You can override to_representation method to customize it.
+    """
+
+    @classmethod
+    def to_internal_value(cls, value: str) -> 'IsoTimeString':
+        t = is_time(value)
+        if not t:
+            raise ValueError(f"'{value}' is not valid time")
+        return _extend_datetime(t, cls)
+
+    def to_representation(self):
+        return self.isoformat()
+
+    def replace(self, *args, **kwargs) -> 'IsoTimeString':
+        # noinspection PyTypeChecker
+        return time.replace(self, *args, **kwargs)
+
+
+class IsoDatetimeString(StringSerializable, datetime):
+    """
+    Parse datetime using dateutil.parser.isoparse.
+    Representation format always is ``YYYY-MM-DDThh:mm:ss.ms`` (datetime.isoformat method).
+    """
+
+    @classmethod
+    def to_internal_value(cls, value: str) -> 'IsoDatetimeString':
+        dt = dateutil.parser.isoparse(value)
+        return _extend_datetime(dt, cls)
+
+    def to_representation(self):
+        return self.isoformat()
+
+    def replace(self, *args, **kwargs) -> 'IsoDatetimeString':
+        # noinspection PyTypeChecker
+        return datetime.replace(self, *args, **kwargs)
+
+
+def register_datetime_classes(registry: StringSerializableRegistry = registry):
+    """
+    Register datetime classes in given registry (using default registry if no arguments is passed).
+    Date parsing is expensive operation so this classes are disabled by default
+    """
+    registry.add(cls=IsoDateString)
+    registry.add(cls=IsoTimeString)
+    registry.add(cls=IsoDatetimeString)

rest_client_gen/dynamic_typing/string_serializable.py

@@ -34,7 +34,7 @@ def to_typing_code(cls) -> Tuple[ImportPathList, str]:
         as a metadata instance but contains actual data
         """
         cls_name = cls.__name__
-        return [('rest_client_gen.dynamic_typing.string_serializable', cls_name)], cls_name
+        return [('rest_client_gen.dynamic_typing', cls_name)], cls_name
 
 
 T_StringSerializable = Type[StringSerializable]
@@ -71,6 +71,17 @@ def decorator(cls):
 
         return decorator
 
+    def remove(self, cls: type):
+        """
+        Unregister given class
+
+        :param cls: StringSerializable class
+        """
+        self.types.remove(cls)
+        for base, replace in list(self.replaces):
+            if replace is cls:
+                self.replaces.remove((base, replace))
+
     def resolve(self, *types: T_StringSerializable) -> Collection[T_StringSerializable]:
         """
         Return set of StringSerializable classes which can represent all classes from types argument.

test/test_code_generation/test_attrs_generation.py

@@ -119,7 +119,7 @@ class Test:
         "generated": trim(f"""
         import attr
         from attr.converter import optional
-        from rest_client_gen.dynamic_typing.string_serializable import FloatString, IntString
+        from rest_client_gen.dynamic_typing import FloatString, IntString
         from typing import List, Optional
 
 

test/test_code_generation/test_models_code_generator.py

@@ -118,7 +118,7 @@ class Test:
             }
         },
         "fields": {
-            "imports": "from rest_client_gen.dynamic_typing.string_serializable import IntString\n"
+            "imports": "from rest_client_gen.dynamic_typing import IntString\n"
                        "from typing import List, Optional",
             "fields": [
                 "foo: int",
@@ -127,7 +127,7 @@ class Test:
             ]
         },
         "generated": trim("""
-        from rest_client_gen.dynamic_typing.string_serializable import IntString
+        from rest_client_gen.dynamic_typing import IntString
         from typing import List, Optional
         
         

test/test_code_generation/test_typing.py

@@ -104,12 +104,12 @@ class TestModel:
     ),
     pytest.param(
         FloatString,
-        ('from rest_client_gen.dynamic_typing.string_serializable import FloatString', FloatString),
+        ('from rest_client_gen.dynamic_typing import FloatString', FloatString),
         id="string_serializable"
     ),
     pytest.param(
         DOptional(IntString),
-        ('from rest_client_gen.dynamic_typing.string_serializable import IntString\n'
+        ('from rest_client_gen.dynamic_typing import IntString\n'
          'from typing import Optional', Optional[IntString]),
         id="complex_string_serializable"
     ),

testing_tools/real_apis/f1.py

@@ -5,6 +5,7 @@
 import inflection
 import requests
 
+from rest_client_gen.dynamic_typing import register_datetime_classes
 from rest_client_gen.generator import MetadataGenerator
 from rest_client_gen.models import compose_models
 from rest_client_gen.models.attr import AttrsModelCodeGenerator
@@ -43,6 +44,7 @@ def main():
     dump_response("f1", "driver_standings", driver_standings_data)
     driver_standings_data = ("driver_standings", driver_standings_data)
 
+    register_datetime_classes()
     gen = MetadataGenerator()
     reg = ModelRegistry()
     for name, data in (results_data, drivers_data, driver_standings_data):

testing_tools/real_apis/pathofexile.py

@@ -26,6 +26,7 @@ def main():
 
     print(f"Start model generation (data len = {len(tabs)})")
     start_t = datetime.now()
+    # register_datetime_classes()
     gen = MetadataGenerator()
     reg = ModelRegistry()
     fields = gen.generate(*tabs)