Issue #145

Author: loyada

docs/serialization.rst

@@ -846,3 +846,42 @@ To illustrate the usage, examine the following snippet:
             {"type": "sales", "name": "joe"},
         ]
     }
+
+
+Force a Field To Be Set As A Constant During Deserialization
+============================================================
+(new in 2.13.0)
+Imagine a use-case in which you have an abstract base class "Car", and several cars that inherit from it. One of
+the fields you might want to have is "maker":
+
+.. code-block:: python
+
+    class Car(AbstractStructure):
+        maker: str
+        ...
+
+    class SubaruOutback(Car):
+        ...
+
+    class AcuraMVX(Car):
+        ...
+
+
+When you deserialize SubaruOutback or AcuraMVX, you should set the "maker" explicitly to a predefined value.
+Typedpy supports it, by defining "Constant" in the serialization mapper (similar to Version Mapping). See below:
+
+.. code-block:: python
+
+    class SubaruOutback(Car):
+        ...
+
+        _deserialization_mapper = {"maker": Constant("Subaru")}
+
+
+    class AcuraMVX(Car):
+        ...
+
+        _deserialization_mapper = {"maker": Constant("Acura")}
+
+This means that the field "maker" will ignore the input to the deserializer, and always set to the value defined
+in the mapper.

tests/schema_mapping/expected/generated_example12.py

@@ -0,0 +1,7 @@
+from typedpy import *
+
+
+class Example1(Structure):
+    name = String()
+
+    _required = ['name']

tests/schema_mapping/schemas/example12_schema.json

@@ -0,0 +1,13 @@
+{
+    "definitions": {
+    },
+    "example": {
+        "type": "object",
+        "properties": {
+            "name": {"type": "string"}
+        },
+        "required": ["name"],
+        "additionalProperties": true
+    }
+}
+

tests/schema_mapping/structures/__init__.py

@@ -8,3 +8,4 @@
 from .example8 import Example8
 from .example9 import Example9, Example10
 from .example11 import Example11
+from .example12 import Example12

tests/schema_mapping/structures/example12.py

@@ -0,0 +1,12 @@
+from typedpy import Constant, Structure, mappers
+
+
+class A(Structure):
+    i: int
+
+    _serialization_mapper = mappers.TO_LOWERCASE
+
+
+class Example12(A):
+    a: str
+    _serialization_mapper = {"I": Constant(5), "A": "name"}

tests/schema_mapping/test_json_schema_code_mapping.py

@@ -52,6 +52,7 @@ def wrapped(file_name: str) -> str:
         ("Example9", "example9_schema.json", "generated_example9.py"),
         ("Example10", "example10_schema.json", "generated_example10.py"),
         ("Example11", "example11_schema.json", "generated_example11.py"),
+        ("Example12", "example12_schema.json", "generated_example12.py"),
     ],
 )
 @pytest.mark.skipif(sys.version_info < (3, 9), reason="requires python3.9 or higher")

tests/test_deserialization.py

@@ -8,7 +8,7 @@
 
 from typedpy import (
     Boolean,
-    ImmutableStructure,
+    Constant, ImmutableStructure,
     Structure,
     Array,
     Number,
@@ -1342,3 +1342,32 @@ class Foo(Structure):
 
     foo = Deserializer(Foo).deserialize({"p": [1, 2, 3]})
     assert foo.p.x == 1
+
+
+def test_serialization_constant1():
+    class A(Structure):
+        i: int
+
+        _serialization_mapper = mappers.TO_LOWERCASE
+
+    class B(A):
+        a: str
+        _serialization_mapper = {"I": Constant(5), "A": "number"}
+
+    assert Deserializer(B).deserialize({"number": "xyz"}, keep_undefined=False) == B(a="xyz", i=5)
+    assert Serializer(B(a="xyz", i=5)).serialize() == {'i': 5, 'number': 'xyz'}
+
+
+def test_serialization_constant_in_list():
+    class A(Structure):
+        i: int
+
+        _serialization_mapper = {"i": Constant(10)}
+
+    class B(Structure):
+        arr: Array[A]
+        _serialization_mapper = [mappers.TO_LOWERCASE, {"ARR": "numbers"}]
+
+    assert Deserializer(B).deserialize({"numbers": [{}, {}]}, keep_undefined=False) == B(arr=[A(10), A(10)])
+    assert Serializer(B(arr=[A(10), A(10)])).serialize() == {'numbers': [{'i': 10}, {'i': 10}]}
+    

typedpy/json_schema_mapping.py

@@ -30,7 +30,7 @@
 from .enum import Enum
 
 from .extfields import DateString
-from .mappers import DoNotSerialize, aggregate_serialization_mappers
+from .mappers import Constant, DoNotSerialize, aggregate_serialization_mappers
 from .structures import ADDITIONAL_PROPERTIES, NoneField, Structure
 
 SCHEMA_PATTERN_PROPERTIES = "patternProperties"
@@ -102,7 +102,7 @@ def _validated_mapped_value(mapper, key):
                 "This is unsupported by code-to-schema conversion. "
                 "You will need to manually fix it."
             )
-        elif key_mapper is DoNotSerialize:
+        elif key_mapper is DoNotSerialize or isinstance(key_mapper, Constant):
             return key_mapper
         elif not isinstance(key_mapper, (FunctionCall, str)):
             raise TypeError("mapper must have a FunctionCall or a string")
@@ -160,10 +160,10 @@ def structure_to_schema(structure, definitions_schema, serialization_mapper=None
                 else key
             )
             mapped_value = _validated_mapped_value(mapper, key)
-            if mapped_value is DoNotSerialize:
+            if mapped_value is DoNotSerialize or isinstance(mapped_value, Constant):
                 if mapped_key in required:
                     required.pop(required.index(mapped_key))
-            if mapped_value is not DoNotSerialize:
+            else:
                 if key in required:
                     required[required.index(key)] = mapped_key
                 sub_mapper = mapper.get(f"{key}._mapper", {})

typedpy/serialization.py

@@ -7,7 +7,7 @@
 from .commons import deep_get, raise_errs_if_needed
 from .versioned_mapping import VERSION_MAPPING, Versioned, convert_dict
 from .mappers import (
-    DoNotSerialize,
+    Constant, DoNotSerialize,
     aggregate_deserialization_mappers,
     aggregate_serialization_mappers,
     mappers,
@@ -600,6 +600,8 @@ def _get_arg_list(key_mapper):
     elif isinstance(key_mapper, (str,)):
         val = deep_get(the_dict, key_mapper)
         processed_input = val if val is not None else the_dict.get(key)
+    elif isinstance(key_mapper, Constant):
+        processed_input = key_mapper()
     else:
         raise TypeError(
             f"mapper value must be a key in the input or a FunctionCal. Got {wrap_val(key_mapper)}"
@@ -756,6 +758,8 @@ def _get_mapped_value(mapper, key, items):
             return key_mapper.func(*args)
         elif key_mapper is DoNotSerialize:
             return key_mapper
+        elif isinstance(key_mapper, Constant):
+            return key_mapper()
         elif not isinstance(key_mapper, (FunctionCall, str)):
             raise TypeError("mapper must have a FunctionCall or a string")