🐛 Improve handling null and collection parameters.

Author: rafalkrupinski

src/lapidary/runtime/metattype.py

@@ -18,3 +18,7 @@ def make_not_optional(typ: typing.Any) -> typing.Any:
 
 def is_array_like(typ: typing.Any) -> bool:
     return inspect.isclass(typ) and issubclass(typ, Iterable) and not (typ in (str, bytes) or issubclass(typ, Mapping))
+
+
+def unwrap_origin(typ: typing.Any) -> typing.Any:
+    return typing.get_origin(typ) or typ

src/lapidary/runtime/model/param_serialization.py

@@ -10,7 +10,7 @@
 
 import typing_extensions as typing
 
-from ..metattype import make_not_optional
+from ..metattype import make_not_optional, unwrap_origin
 
 # Some basic scalar types that we're sure are passed unchanged by pydantic
 PYTHON_SCALARS = (
@@ -103,29 +103,29 @@ def serialize_scalar(cls, name: str, value: ScalarType) -> Multimap:
 
     @classmethod
     def deserialize(cls, value: typing.Any, target: type) -> ValueType:
-        target = make_not_optional(target)
+        target = unwrap_origin(make_not_optional(target))
         if target in PYTHON_SCALARS:
-            return cls.deserialize_scalar(value)
+            return cls.deserialize_scalar(value, target)
         elif issubclass(target, Mapping):
-            return cls.deserialize_object(value)
+            return cls.deserialize_object(value, target)
         elif issubclass(target, Iterable):
-            return cls.deserialize_array(value)
+            return cls.deserialize_array(value, target)
         else:
             raise SerializationError(type(value), target)
 
     @classmethod
-    @abc.abstractmethod
-    def deserialize_scalar(cls, value: str) -> str:
-        pass
+    def deserialize_scalar(cls, value: str, _) -> ScalarType:
+        # leave handling to pydantic
+        return value
 
     @classmethod
     @abc.abstractmethod
-    def deserialize_object(cls, value: str) -> ValueType:
+    def deserialize_object(cls, value: str, _) -> ValueType:
         pass
 
     @classmethod
     @abc.abstractmethod
-    def deserialize_array(cls, value: str) -> ArrayType:
+    def deserialize_array(cls, value: str, _) -> ArrayType:
         pass
 
 
@@ -140,7 +140,7 @@ def serialize_array(cls, name: str, value: ArrayType) -> Multimap:
 
     @classmethod
     def serialize_scalar(cls, name: str, value: ScalarType) -> Multimap:
-        return [cls._scalar_as_entry(name, value)]
+        return [cls._scalar_as_entry(name, value)] if value else ()
 
     @staticmethod
     def _serialize_scalar(value: ScalarType) -> str:
@@ -151,29 +151,13 @@ def _scalar_as_entry(cls, name: str, value: ScalarType) -> Entry:
         return name, cls._serialize_scalar(value)
 
     @classmethod
-    def deserialize(cls, value: typing.Any, target: type) -> ValueType:
-        target = make_not_optional(target)
-        if target in PYTHON_SCALARS:
-            return cls.deserialize_scalar(value)
-        elif issubclass(target, Mapping):
-            return cls.deserialize_object(value)
-        elif issubclass(target, Iterable):
-            return cls.deserialize_array(value)
-        else:
-            raise SerializationError(type(value), target)
-
-    @classmethod
-    def deserialize_scalar(cls, value: str) -> str:
-        return value
-
-    @classmethod
-    def deserialize_object(cls, value: str) -> ValueType:
+    def deserialize_object(cls, value: str, _) -> ValueType:
         tokens = value.split(',')
-        return dict((k, cls.deserialize_scalar(v)) for k, v in zip(tokens[::2], tokens[1::2]))
+        return dict((k, cls.deserialize_scalar(v, None)) for k, v in zip(tokens[::2], tokens[1::2]))
 
     @classmethod
-    def deserialize_array(cls, value: str) -> ArrayType:
-        return [cls.deserialize_scalar(scalar) for scalar in value.split(',')]
+    def deserialize_array(cls, value: str, _) -> ArrayType:
+        return [cls.deserialize_scalar(scalar, None) for scalar in value.split(',')]
 
 
 class SimpleString(StringSerializationStyle):
@@ -208,11 +192,7 @@ def serialize_object(cls, _name: str, value: ObjectType) -> Multimap:
         return itertools.chain.from_iterable(cls.serialize_scalar(key, item) for key, item in value.items() if item)
 
     @classmethod
-    def deserialize_scalar(cls, value: str) -> str:
-        return value
-
-    @classmethod
-    def deserialize_array(cls, value: str) -> ArrayType:
+    def deserialize_array(cls, value: str, _) -> ArrayType:
         raise NotImplementedError
 
 

src/lapidary/runtime/model/response.py

@@ -66,7 +66,7 @@ def handle_response(self, response: 'httpx.Response') -> typing.Any:
         value = part[self.http_name()]
         if value is None:
             return None
-        return self._deserialize(value)
+        return self._deserialize(value, make_not_optional(self.python_type))
 
     @staticmethod
     @abc.abstractmethod

tests/test_param_serialization.py

@@ -7,6 +7,14 @@ def test_simple_multimap_string():
     assert SimpleMultimap.serialize_scalar('name', 'value') == [('name', 'value')]
 
 
+def test_simple_multimap_scalar_none():
+    assert list(SimpleMultimap.serialize_scalar('name', None)) == []
+
+
+def test_simple_multimap_none():
+    assert list(SimpleMultimap.serialize('name', None)) == []
+
+
 def test_simple_multimap_int():
     assert SimpleMultimap.serialize_scalar('name', 1) == [('name', '1')]
 
@@ -19,6 +27,30 @@ def test_simple_multimap_object():
     assert SimpleMultimap.serialize_object('name', {'key1': 'value', 'key2': 1}) == [('name', 'key1,value,key2,1')]
 
 
+def test_deser_simple_multimap_str():
+    assert SimpleMultimap.deserialize_scalar('value', str) == 'value'
+
+
+def test_deser_simple_multimap_str_generic():
+    assert SimpleMultimap.deserialize('value', str) == 'value'
+
+
+def test_deser_simple_multimap_array():
+    assert SimpleMultimap.deserialize_array('value1,value2', list[str]) == ['value1', 'value2']
+
+
+def test_deser_simple_multimap_array_generic():
+    assert SimpleMultimap.deserialize('value1,value2', list[str]) == ['value1', 'value2']
+
+
+def test_deser_simple_multimap_object():
+    assert SimpleMultimap.deserialize_object('name1,value1,name2,value2', dict[str, str]) == {'name1': 'value1', 'name2': 'value2'}
+
+
+def test_deser_simple_multimap_object_generic():
+    assert SimpleMultimap.deserialize('name1,value1,name2,value2', dict[str, str]) == {'name1': 'value1', 'name2': 'value2'}
+
+
 # simple no-explode, string version