Optional converter

Author: bogdandm

rest_client_gen/models/attr.py

@@ -1,6 +1,5 @@
-import operator
 from inspect import isclass
-from typing import List, Tuple
+from typing import Iterable, List, Tuple
 
 from .base import GenericModelCodeGenerator, template
 from ..dynamic_typing import DList, DOptional, ImportPathList, MetaData, ModelMeta, StringSerializable
@@ -11,13 +10,28 @@
                   "{% if not loop.last %}, {% endif %}" \
                   "{% endfor %}"
 
+DEFAULT_ORDER = (
+    ("default", "converter", "factory"),
+    "*",
+    ("metadata",)
+)
 
-def sort_kwargs(kwargs: dict) -> dict:
-    # TODO: Unify this function
-    meta = kwargs.pop("metadata", {})
-    sorted_dict = dict(sorted(kwargs.items(), key=operator.itemgetter(0)))
-    if meta:
-        sorted_dict["metadata"] = meta
+
+def sort_kwargs(kwargs: dict, ordering: Iterable[Iterable[str]] = DEFAULT_ORDER) -> dict:
+    sorted_dict_1 = {}
+    sorted_dict_2 = {}
+    current = sorted_dict_1
+    for group in ordering:
+        if isinstance(group, str):
+            if group != "*":
+                raise ValueError(f"Unknown kwarg group: {group}")
+            current = sorted_dict_2
+        else:
+            for item in group:
+                if item in kwargs:
+                    value = kwargs.pop(item)
+                    current[item] = value
+    sorted_dict = {**sorted_dict_1, **kwargs, **sorted_dict_2}
     return sorted_dict
 
 
@@ -72,8 +86,12 @@ def field_data(self, name: str, meta: MetaData, optional: bool) -> Tuple[ImportP
                 body_kwargs["factory"] = "list"
             else:
                 body_kwargs["default"] = "None"
-        if isclass(meta) and issubclass(meta, StringSerializable):
+                if isclass(meta.type) and issubclass(meta.type, StringSerializable):
+                    body_kwargs["converter"] = f"optional({meta.type.__name__})"
+                    imports.append(("attr.converter", "optional"))
+        elif isclass(meta) and issubclass(meta, StringSerializable):
             body_kwargs["converter"] = meta.__name__
+
         if not self.no_meta:
             body_kwargs["metadata"] = {METADATA_FIELD_NAME: name}
         data["body"] = self.ATTRIB.render(kwargs=sort_kwargs(body_kwargs))

test/test_code_generation/test_attrs_generation.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from rest_client_gen.dynamic_typing import (DList, DOptional, FloatString, ModelMeta, compile_imports)
+from rest_client_gen.dynamic_typing import (DList, DOptional, FloatString, IntString, ModelMeta, compile_imports)
 from rest_client_gen.models import sort_fields
 from rest_client_gen.models.attr import AttrsModelCodeGenerator, METADATA_FIELD_NAME
 from rest_client_gen.models.base import generate_code
@@ -65,7 +65,7 @@ class Test:
         "model": ("Test", {
             "foo": int,
             "baz": DOptional(DList(DList(str))),
-            # "bar": DOptional(IntString),
+            "bar": DOptional(IntString),
             "qwerty": FloatString,
             "asdfg": DOptional(int)
         }),
@@ -80,11 +80,11 @@ class Test:
                 "type": "Optional[List[List[str]]]",
                 "body": f"attr.ib(factory=list, {field_meta('baz')})"
             },
-            # "bar": {
-            #     "name": "bar",
-            #     "type": "Optional[IntString]",
-            #     "body": f"attr.ib(converter=IntString, default=None, {field_meta('bar')})"
-            # },
+            "bar": {
+                "name": "bar",
+                "type": "Optional[IntString]",
+                "body": f"attr.ib(default=None, converter=optional(IntString), {field_meta('bar')})"
+            },
             "qwerty": {
                 "name": "qwerty",
                 "type": "FloatString",
@@ -98,7 +98,8 @@ class Test:
         },
         "generated": trim(f"""
         import attr
-        from rest_client_gen.dynamic_typing.string_serializable import FloatString
+        from attr.converter import optional
+        from rest_client_gen.dynamic_typing.string_serializable import FloatString, IntString
         from typing import List, Optional
 
 
@@ -107,6 +108,7 @@ class Test:
             foo: int = attr.ib({field_meta('foo')})
             qwerty: FloatString = attr.ib(converter=FloatString, {field_meta('qwerty')})
             baz: Optional[List[List[str]]] = attr.ib(factory=list, {field_meta('baz')})
+            bar: Optional[IntString] = attr.ib(default=None, converter=optional(IntString), {field_meta('bar')})
             asdfg: Optional[int] = attr.ib(default=None, {field_meta('asdfg')})
         """)
     }