typedpy 2.2.3__tar.gz → 2.2.4__tar.gz

home/dannyloya/github/typedpy/venv39/lib/python3.9/site-packages/typedpy/serialization.py

@@ -10,7 +10,7 @@ from typedpy.structures import (
     Structure,
     _get_all_fields_by_name,
     ADDITIONAL_PROPERTIES,
-    REQUIRED_FIELDS,
+    REQUIRED_FIELDS, IGNORE_NONE_VALUES,
 )
 from typedpy.fields import (
     Field,
@@ -39,7 +39,8 @@ from typedpy.fields import (
 
 
 def deserialize_list_like(
-    field, content_type, value, name, *, keep_undefined=True, mapper=None
+    field, content_type, value, name, *, keep_undefined=True, mapper=None,
+        camel_case_convert=False
 ):
     if not isinstance(value, (list, tuple, set)):
         raise ValueError("{}: must be list, set, or tuple; got {}".format(name, value))
@@ -47,11 +48,14 @@ def deserialize_list_like(
     values = []
     items = field.items
     if isinstance(items, Field):
+        ignore_none = getattr(items, IGNORE_NONE_VALUES, False)
         for i, v in enumerate(value):
             item_name = "{}_{}".format(name, i)
             try:
                 list_item = deserialize_single_field(
-                    items, v, item_name, keep_undefined=keep_undefined, mapper=mapper
+                    items, v, item_name, keep_undefined=keep_undefined, mapper=mapper,
+                    camel_case_convert=camel_case_convert,
+                    ignore_none=ignore_none
                 )
             except (ValueError, TypeError) as e:
                 prefix = (
@@ -62,8 +66,11 @@ def deserialize_list_like(
     elif isinstance(items, (list, tuple)):
         for i, item in enumerate(items):
             try:
+                ignore_none = getattr(item, IGNORE_NONE_VALUES, False)
                 res = deserialize_single_field(
-                    item, value[i], name, keep_undefined=keep_undefined, mapper=mapper
+                    item, value[i], name, keep_undefined=keep_undefined, mapper=mapper,
+                    camel_case_convert=camel_case_convert,
+                    ignore_none=ignore_none
                 )
             except (ValueError, TypeError) as e:
                 raise ValueError("{}_{}: {}".format(name, i, str(e))) from e
@@ -74,13 +81,14 @@ def deserialize_list_like(
     return content_type(values)
 
 
-def deserialize_array(array_field, value, name, *, keep_undefined=True, mapper):
+def deserialize_array(array_field, value, name, *, keep_undefined=True, mapper,camel_case_convert=False):
     return deserialize_list_like(
-        array_field, list, value, name, keep_undefined=keep_undefined, mapper=mapper
+        array_field, list, value, name, keep_undefined=keep_undefined, mapper=mapper,
+        camel_case_convert=camel_case_convert
     )
 
 
-def deserialize_deque(array_field, value, name, *, keep_undefined=True, mapper):
+def deserialize_deque(array_field, value, name, *, keep_undefined=True, mapper, camel_case_convert=False):
     return deserialize_list_like(
         array_field,
         collections.deque,
@@ -88,23 +96,27 @@ def deserialize_deque(array_field, value, name, *, keep_undefined=True, mapper):
         name,
         keep_undefined=keep_undefined,
         mapper=mapper,
+        camel_case_convert=camel_case_convert
     )
 
 
-def deserialize_tuple(tuple_field, value, name, *, keep_undefined=True, mapper):
+def deserialize_tuple(tuple_field, value, name, *, keep_undefined=True, mapper, camel_case_convert=False):
     return deserialize_list_like(
-        tuple_field, tuple, value, name, keep_undefined=keep_undefined, mapper=mapper
+        tuple_field, tuple, value, name, keep_undefined=keep_undefined, mapper=mapper,
+        camel_case_convert=camel_case_convert
     )
 
 
-def deserialize_set(set_field, value, name, *, keep_undefined=True, mapper):
+def deserialize_set(set_field, value, name, *, keep_undefined=True, mapper, camel_case_convert=False):
     return deserialize_list_like(
-        set_field, set, value, name, keep_undefined=keep_undefined, mapper=mapper
+        set_field, set, value, name, keep_undefined=keep_undefined, mapper=mapper,
+        camel_case_convert=camel_case_convert
     )
 
 
 def deserialize_multifield_wrapper(
-    field, source_val, name, *, keep_undefined=True, mapper=None
+    field, source_val, name, *, keep_undefined=True, mapper=None,
+        camel_case_convert=False
 ):
     """
     Only primitive values are supported, otherwise deserialization is ambiguous,
@@ -114,12 +126,16 @@ def deserialize_multifield_wrapper(
     found_previous_match = False
     for field_option in field.get_fields():
         try:
+            ignore_none = getattr(field_option, IGNORE_NONE_VALUES, False)
+
             deserialized = deserialize_single_field(
                 field_option,
                 source_val,
                 name,
                 keep_undefined=keep_undefined,
                 mapper=mapper,
+                camel_case_convert=camel_case_convert,
+                ignore_none=ignore_none
             )
             if isinstance(field, AnyOf):
                 return deserialized
@@ -146,7 +162,7 @@ def deserialize_multifield_wrapper(
     return deserialized
 
 
-def deserialize_map(map_field, source_val, name):
+def deserialize_map(map_field, source_val, name, camel_case_convert=False):
     if not isinstance(source_val, dict):
         raise TypeError(
             "{}: expected a dict. Got {}".format(name, wrap_val(source_val))
@@ -157,15 +173,26 @@ def deserialize_map(map_field, source_val, name):
         key_field, value_field = None, None
     res = {}
     for key, val in source_val.items():
-        res[deserialize_single_field(key_field, key, name)] = deserialize_single_field(
-            value_field, val, name
+        ignore_none = getattr(value_field, IGNORE_NONE_VALUES, False)
+
+        res[deserialize_single_field(key_field, key, name,
+                                     camel_case_convert=camel_case_convert)] = deserialize_single_field(
+            value_field, val, name,
+            camel_case_convert=camel_case_convert,
+            ignore_none=ignore_none
         )
     return res
 
 
 def deserialize_single_field(
-    field, source_val, name, *, mapper=None, keep_undefined=True
+    field, source_val, name, *,
+        mapper=None,
+        keep_undefined=True,
+        camel_case_convert=False,
+        ignore_none=False,
 ):
+    if source_val is None and ignore_none:
+        return source_val
     if isinstance(field, (Number, String, Enum, Boolean)):
         field._validate(source_val)
         value = source_val
@@ -177,23 +204,28 @@ def deserialize_single_field(
         value = source_val
     elif isinstance(field, Array):
         value = deserialize_array(
-            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper
+            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper,
+            camel_case_convert=camel_case_convert
         )
     elif isinstance(field, Deque):
         value = deserialize_deque(
-            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper
+            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper,
+            camel_case_convert=camel_case_convert
         )
     elif isinstance(field, Tuple):
         value = deserialize_tuple(
-            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper
+            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper,
+            camel_case_convert=camel_case_convert
         )
     elif isinstance(field, Set):
         value = deserialize_set(
-            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper
+            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper,
+            camel_case_convert=camel_case_convert
         )
     elif isinstance(field, MultiFieldWrapper):
         value = deserialize_multifield_wrapper(
-            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper
+            field, source_val, name, keep_undefined=keep_undefined, mapper=mapper,
+            camel_case_convert=camel_case_convert
         )
     elif isinstance(field, ClassReference):
         value = deserialize_structure_internal(
@@ -202,6 +234,7 @@ def deserialize_single_field(
             name,
             keep_undefined=keep_undefined,
             mapper=mapper,
+            camel_case_convert=camel_case_convert
         )
     elif isinstance(field, StructureReference):
         value = deserialize_structure_reference(
@@ -209,9 +242,10 @@ def deserialize_single_field(
             source_val,
             keep_undefined=keep_undefined,
             mapper=mapper,
+            camel_case_convert=camel_case_convert
         )
     elif isinstance(field, Map):
-        value = deserialize_map(field, source_val, name)
+        value = deserialize_map(field, source_val, name, camel_case_convert=camel_case_convert)
     elif isinstance(field, SerializableField):
         value = field.deserialize(source_val)
     elif isinstance(field, Anything) or field is None:
@@ -231,7 +265,7 @@ def deserialize_single_field(
     return value
 
 
-def deserialize_structure_reference(cls, the_dict: dict, *, keep_undefined, mapper):
+def deserialize_structure_reference(cls, the_dict: dict, *, keep_undefined, mapper, camel_case_convert=False):
     field_by_name = {k: v for k, v in cls.__dict__.items() if isinstance(v, Field)}
     kwargs = dict(
         [
@@ -241,30 +275,36 @@ def deserialize_structure_reference(cls, the_dict: dict, *, keep_undefined, mapp
         ]
     )
 
-    kwargs.update(construct_fields_map(field_by_name, keep_undefined, mapper, the_dict))
+    kwargs.update(construct_fields_map(field_by_name, keep_undefined, mapper, the_dict,
+                                       camel_case_convert=camel_case_convert))
     cls(**kwargs)
     return kwargs
 
 
-def construct_fields_map(field_by_name, keep_undefined, mapper, the_dict):
+def construct_fields_map(field_by_name, keep_undefined, mapper, input_dict,
+                         camel_case_convert=False,
+                         ignore_none=False):
     result = {}
     for key, field in field_by_name.items():
+        converted_key = _convert_to_camel_case_if_required(key, camel_case_convert=camel_case_convert)
         process = False
         processed_input = None
-        if key in the_dict and key not in mapper:
-            processed_input = the_dict[key]
+        if converted_key in input_dict and key not in mapper:
+            processed_input = input_dict[converted_key]
             process = True
         elif key in mapper:
-            processed_input = get_processed_input(key, mapper, the_dict)
+            processed_input = get_processed_input(key, mapper, input_dict)
             process = True
         if process:
-            sub_mapper = mapper.get(f"{key}._mapper", {})
+            sub_mapper = mapper.get(f"{converted_key}._mapper", {})
             result[key] = deserialize_single_field(
                 field,
                 processed_input,
                 key,
                 mapper=sub_mapper,
                 keep_undefined=keep_undefined,
+                camel_case_convert=camel_case_convert,
+                ignore_none=ignore_none
             )
     return result
 
@@ -288,7 +328,10 @@ class FunctionCall(Structure):
 
 
 def deserialize_structure_internal(
-    cls, the_dict, name=None, *, mapper=None, keep_undefined=True
+    cls, the_dict, name=None, *,
+        mapper=None,
+        keep_undefined=True,
+        camel_case_convert=False
 ):
     """
     Deserialize a dict to a Structure instance, Jackson style.
@@ -314,6 +357,7 @@ def deserialize_structure_internal(
     """
     if mapper is None:
         mapper = {}
+    ignore_none = getattr(cls, IGNORE_NONE_VALUES, False)
     if not isinstance(mapper, (collections.abc.Mapping,)):
         raise TypeError("Mapper must be a mapping")
     field_by_name = _get_all_fields_by_name(cls)
@@ -326,7 +370,7 @@ def deserialize_structure_internal(
         if len(fields) == 1 and required == fields and additional_props is False:
             field_name = fields[0]
             return cls(
-                deserialize_single_field(getattr(cls, field_name), the_dict, field_name)
+                deserialize_single_field(getattr(cls, field_name), the_dict, field_name, ignore_none=ignore_none)
             )
         raise TypeError(
             "{}: Expected a dictionary; Got {}".format(name, wrap_val(the_dict))
@@ -339,12 +383,17 @@ def deserialize_structure_internal(
             if k not in field_by_name and keep_undefined
         ]
     )
-    kwargs.update(construct_fields_map(field_by_name, keep_undefined, mapper, the_dict))
+    kwargs.update(construct_fields_map(field_by_name, keep_undefined, mapper, the_dict,
+                                       camel_case_convert=camel_case_convert,
+                                       ignore_none=ignore_none))
 
     return cls(**kwargs)
 
 
-def deserialize_structure(cls, the_dict, *, mapper=None, keep_undefined=True):
+def deserialize_structure(cls, the_dict, *,
+                          mapper=None,
+                          keep_undefined=True,
+                          camel_case_convert=False):
     """
     Deserialize a dict to a Structure instance, Jackson style.
     Note the top level must be a python dict - which implies that a JSON of
@@ -370,7 +419,9 @@ def deserialize_structure(cls, the_dict, *, mapper=None, keep_undefined=True):
         an instance of the provided :class:`Structure` deserialized
     """
     return deserialize_structure_internal(
-        cls, the_dict, mapper=mapper, keep_undefined=keep_undefined
+        cls, the_dict, mapper=mapper,
+        keep_undefined=keep_undefined,
+        camel_case_convert=camel_case_convert
     )
 
 
@@ -399,7 +450,7 @@ def get_processed_input(key, mapper, the_dict):
     return processed_input
 
 
-def serialize_val(field_definition, name, val, mapper=None):
+def serialize_val(field_definition, name, val, mapper=None, camel_case_convert=False):
     if isinstance(field_definition, SerializableField) and isinstance(
         field_definition, Field
     ):
@@ -416,32 +467,37 @@ def serialize_val(field_definition, name, val, mapper=None):
             ):
                 key_type, value_type = field_definition.items
                 return {
-                    serialize_val(key_type, name, k): serialize_val(value_type, name, v)
+                    serialize_val(key_type, name, k, camel_case_convert=camel_case_convert):
+                        serialize_val(value_type, name, v, camel_case_convert=camel_case_convert)
                     for (k, v) in val.items()
                 }
             else:
                 return {
-                    serialize_val(Anything, name, k): serialize_val(Anything, name, v)
+                    serialize_val(Anything, name, k, camel_case_convert=camel_case_convert):
+                        serialize_val(Anything, name, v, camel_case_convert=camel_case_convert)
                     for (k, v) in val.items()
                 }
         if isinstance(field_definition.items, list):
             return [
-                serialize_val(field_definition.items[ind], name, v, mapper=mapper)
+                serialize_val(field_definition.items[ind], name, v, mapper=mapper,
+                              camel_case_convert=camel_case_convert)
                 for ind, v in enumerate(val)
             ]
         elif isinstance(field_definition.items, Field):
             return [
-                serialize_val(field_definition.items, name, i, mapper=mapper)
+                serialize_val(field_definition.items, name, i, mapper=mapper,
+                              camel_case_convert=camel_case_convert)
                 for i in val
             ]
         else:
-            return [serialize_val(None, name, i, mapper=mapper) for i in val]
+            return [serialize_val(None, name, i, mapper=mapper, camel_case_convert=camel_case_convert)
+                    for i in val]
     if isinstance(val, (list, set, tuple)):
-        return [serialize_val(None, name, i) for i in val]
+        return [serialize_val(None, name, i, camel_case_convert=camel_case_convert) for i in val]
     if isinstance(field_definition, Anything) and isinstance(val, Structure):
-        return serialize(val, mapper=mapper)
+        return serialize(val, mapper=mapper, camel_case_convert=camel_case_convert)
     if isinstance(val, Structure) or isinstance(field_definition, Field):
-        return serialize_internal(val, mapper=mapper)
+        return serialize_internal(val, mapper=mapper, camel_case_convert=camel_case_convert)
 
     # nothing worked. Not a typedpy field. Last ditch effort.
     try:
@@ -450,7 +506,7 @@ def serialize_val(field_definition, name, val, mapper=None):
         raise ValueError(f"{name}: cannot serialize value: {ex}") from ex
 
 
-def serialize_field(field_definition: Field, value):
+def serialize_field(field_definition: Field, value, camel_case_convert=False):
     """
     Serialize a specific :class:`Field` from a structure to a JSON-like dict.
     Example:
@@ -479,7 +535,8 @@ def serialize_field(field_definition: Field, value):
     Returns:
         a serialized Python object that can be directly converted to JSON
     """
-    return serialize_val(field_definition, field_definition._name, value)
+    return serialize_val(field_definition, field_definition._name, value,
+                         camel_case_convert=camel_case_convert)
 
 
 def _get_mapped_value(mapper, key, items):
@@ -498,7 +555,23 @@ def _get_mapped_value(mapper, key, items):
     return None
 
 
-def serialize_internal(structure, mapper=None, compact=False):
+def _convert_to_camel_case_if_required(key, camel_case_convert):
+    if camel_case_convert:
+        words = key.split('_')
+        return words[0] + ''.join(w.title() for w in words[1:])
+    else:
+        return key
+
+def _convert_to_snake_case_if_required(key, camel_case_convert):
+    if camel_case_convert:
+        return ''.join(['_' + char.lower() if char.isupper()
+                        else char for char in key]).lstrip('_')
+    else:
+        return key
+
+
+
+def serialize_internal(structure, mapper=None, compact=False, camel_case_convert=False):
     if mapper is None:
         mapper = {}
     field_by_name = _get_all_fields_by_name(structure.__class__)
@@ -520,7 +593,8 @@ def serialize_internal(structure, mapper=None, compact=False):
     ):
         key = fields[0]
         result = serialize_val(
-            field_by_name.get(key, None), key, getattr(structure, key)
+            field_by_name.get(key, None), key, getattr(structure, key),
+            camel_case_convert=camel_case_convert
         )
     else:
         result = {}
@@ -531,7 +605,7 @@ def serialize_internal(structure, mapper=None, compact=False):
             mapped_key = (
                 mapper[key]
                 if key in mapper and isinstance(mapper[key], (str,))
-                else key
+                else _convert_to_camel_case_if_required(key, camel_case_convert)
             )
             mapped_value = _get_mapped_value(mapper, key, items_map)
             the_field_definition = (
@@ -539,12 +613,14 @@ def serialize_internal(structure, mapper=None, compact=False):
             )
             sub_mapper = mapper.get(f"{key}._mapper", {})
             result[mapped_key] = serialize_val(
-                the_field_definition, key, mapped_value or val, mapper=sub_mapper
+                the_field_definition, key, mapped_value or val,
+                mapper=sub_mapper,
+                camel_case_convert=camel_case_convert
             )
     return result
 
 
-def serialize(value, *, mapper: Dict = None, compact=False):
+def serialize(value, *, mapper: Dict = None, compact=False, camel_case_convert=False):
     """
     Serialize an instance of :class:`Structure` to a JSON-like dict.
     `See working examples in test. <https://github.com/loyada/typedpy/tree/master/tests/test_serialization.py>`_
@@ -580,11 +656,12 @@ def serialize(value, *, mapper: Dict = None, compact=False):
             return value
         if isinstance(value, (_ListStruct, _DictStruct)):
             field_definition = value._field_definition
-            return serialize_val(field_definition, field_definition._name, value)
+            return serialize_val(field_definition, field_definition._name, value,
+                                 camel_case_convert=camel_case_convert)
         if isinstance(value, (enum.Enum,)):
             return value.name
         raise TypeError(
             "serialize: Not a Structure or Field that with an obvious serialization. Got: {}."
             " Maybe try serialize_field() instead?".format(value)
         )
-    return serialize_internal(value, mapper=mapper, compact=compact)
+    return serialize_internal(value, mapper=mapper, compact=compact, camel_case_convert=camel_case_convert)

home/dannyloya/github/typedpy/venv39/lib/python3.9/site-packages/typedpy/serialization_wrappers.py

@@ -1,5 +1,5 @@
 from typedpy import Structure
-from typedpy.fields import StructureClass, Map, String, OneOf
+from typedpy.fields import StructureClass, Map, String, OneOf, Boolean
 from typedpy.serialization import FunctionCall, deserialize_structure, serialize
 from typedpy.structures import _get_all_fields_by_name
 
@@ -49,11 +49,15 @@ class Deserializer(Structure):
                 }
                 Deserializer(target_class=Foo, mapper = mapper).deserializer(the_input_dict)
 
+        camel_case_convert(bool): Optional
+            If true, will convert any camelCase key that does not have explicit mapping to a snake_case attribute
+            name. Default is False.
 
     """
 
     target_class = StructureClass
     mapper = Map[String, OneOf[String, FunctionCall, Map]]
+    camel_case_convert = Boolean(default = False)
 
     _required = ["target_class"]
 
@@ -74,6 +78,7 @@ class Deserializer(Structure):
             input_data,
             mapper=self.mapper,
             keep_undefined=keep_undefined,
+            camel_case_convert=self.camel_case_convert
         )
 
 
@@ -155,5 +160,20 @@ class Serializer(Structure):
             for key in self.mapper:
                 verify_key_in_mapper(key, valid_keys, source_class)
 
-    def serialize(self, compact=True):
-        return serialize(self.source, mapper=self.mapper, compact=compact)
+    def serialize(self, compact=True,  camel_case_convert=False):
+        """
+
+         Arguments:
+               compact(boolean): optional
+                     whether to use a compact form for Structure that is a simple wrapper of a field.
+                     for example: if a Structure has only one field of an int, if compact is True
+                     it will serialize the structure as an int instead of a dictionary.
+                     Default is False.
+
+               camel_case_convert(dict): optional
+                     If True, convert any camel-case key that does not have a mapping in the mapper to a snake-case
+                     attribute.
+                     Default is False.
+        """
+        return serialize(self.source, mapper=self.mapper, compact=compact,
+                         camel_case_convert=camel_case_convert)

home/dannyloya/github/typedpy/venv39/lib/python3.9/site-packages/{typedpy-2.2.3-py3.9.egg-info → typedpy-2.2.4-py3.9.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: typedpy
-Version: 2.2.3
+Version: 2.2.4
 Summary: Type-safe Python
 Home-page: http://github.com/loyada/typedpy
 Author: Danny Loya
 Author-email: dan.loya@gmail.com
 License: MIT
-Download-URL: https://github.com/loyada/typedpy/archive/v2.2.3.tar.gz
+Download-URL: https://github.com/loyada/typedpy/archive/v2.2.4.tar.gz
 Description: [![][travis img]][travis]
         [![][docs img]][docs]