typedpy 2.2.2__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/structures.py

@@ -145,7 +145,7 @@ def _check_for_final_violations(classes):
                     )
                 )
             if "ImmutableStructure" in globals() and is_sub_class(
-                c, ImmutableStructure
+                    c, ImmutableStructure
             ):
                 raise TypeError(
                     "Tried to extend {}, which is an ImmutableStructure. This is forbidden".format(
@@ -210,9 +210,9 @@ class UniqueMixin:
     def __manage_uniqueness__(self):
         myclass = self.__class__
         if (
-            getattr(myclass, MUST_BE_UNIQUE, False)
-            and len(getattr(myclass, "_ALL_INSTANCES", set()))
-            < MAX_NUMBER_OF_INSTANCES_TO_VERIFY_UNIQUENESS
+                getattr(myclass, MUST_BE_UNIQUE, False)
+                and len(getattr(myclass, "_ALL_INSTANCES", set()))
+                < MAX_NUMBER_OF_INSTANCES_TO_VERIFY_UNIQUENESS
         ):
             hash_of_instance = self.__hash__()
             if hash_of_instance in getattr(myclass, "_ALL_INSTANCES", set()):
@@ -236,14 +236,14 @@ class UniqueMixin:
             structure_class_name
         ]
         if (
-            getattr(self, MUST_BE_UNIQUE, False)
-            and len(instance_by_value_for_current_struct)
-            < MAX_NUMBER_OF_INSTANCES_TO_VERIFY_UNIQUENESS
+                getattr(self, MUST_BE_UNIQUE, False)
+                and len(instance_by_value_for_current_struct)
+                < MAX_NUMBER_OF_INSTANCES_TO_VERIFY_UNIQUENESS
         ):
             hash_of_field_val = value.__hash__()
             if (
-                instance_by_value_for_current_struct.get(hash_of_field_val, instance)
-                != instance
+                    instance_by_value_for_current_struct.get(hash_of_field_val, instance)
+                    != instance
             ):
                 raise ValueError(
                     "Instance copy of field {} in {}, which is defined as unique. Instance is {}".format(
@@ -320,13 +320,13 @@ class Field(UniqueMixin, metaclass=_FieldMeta):
             else owner.__dict__[self._name]
         )
         is_immutable = (
-            instance is not None
-            and getattr(instance, IS_IMMUTABLE, False)
-            or getattr(self, IS_IMMUTABLE, False)
+                instance is not None
+                and getattr(instance, IS_IMMUTABLE, False)
+                or getattr(self, IS_IMMUTABLE, False)
         )
         needs_defensive_copy = (
-            not isinstance(res, (ImmutableMixin, int, float, str, bool, enum.Enum))
-            or res is None
+                not isinstance(res, (ImmutableMixin, int, float, str, bool, enum.Enum))
+                or res is None
         )
         return deepcopy(res) if (is_immutable and needs_defensive_copy) else res
 
@@ -334,7 +334,7 @@ class Field(UniqueMixin, metaclass=_FieldMeta):
         if getattr(self, IS_IMMUTABLE, False) and self._name in instance.__dict__:
             raise ValueError("{}: Field is immutable".format(self._name))
         if getattr(self, IS_IMMUTABLE, False) and not getattr(
-            self, "_custom_deep_copy_implementation", False
+                self, "_custom_deep_copy_implementation", False
         ):
             try:
                 instance.__dict__[self._name] = deepcopy(value)
@@ -349,7 +349,7 @@ class Field(UniqueMixin, metaclass=_FieldMeta):
             instance.__dict__[self._name] = value
             instance.__manage__uniqueness_of_all_fields__()
         if getattr(instance, "_instantiated", False) and not getattr(
-            instance, "_skip_validation", False
+                instance, "_skip_validation", False
         ):
             instance.__validate__()
 
@@ -413,34 +413,34 @@ def _get_all_fields_by_name(cls):
 def _instantiate_fields_if_needed(cls_dict: dict, defaults: dict):
     for key, val in cls_dict.items():
         if (
-            key
-            not in {
-                REQUIRED_FIELDS,
-                ADDITIONAL_PROPERTIES,
-                IS_IMMUTABLE,
-                DEFAULTS,
-                OPTIONAL_FIELDS,
-                IGNORE_NONE_VALUES,
-            }
-            and not isinstance(val, Field)
-            and not key.startswith("__")
-            and (
+                key
+                not in {
+            REQUIRED_FIELDS,
+            ADDITIONAL_PROPERTIES,
+            IS_IMMUTABLE,
+            DEFAULTS,
+            OPTIONAL_FIELDS,
+            IGNORE_NONE_VALUES,
+        }
+                and not isinstance(val, Field)
+                and not key.startswith("__")
+                and (
                 Field in getattr(val, "__mro__", []) or is_function_returning_field(val)
-            )
+        )
         ):
             new_val = val(default=defaults[key]) if key in defaults else val()
             cls_dict[key] = new_val
 
 
 def _apply_default_and_update_required_not_to_include_fields_with_defaults(
-    cls_dict: dict, defaults: dict, fields: list
+        cls_dict: dict, defaults: dict, fields: list
 ):
     required_fields = set(cls_dict.get(REQUIRED_FIELDS, []))
     optional_fields = set(cls_dict.get(OPTIONAL_FIELDS, []))
     required_fields_predefined = REQUIRED_FIELDS in cls_dict
     for field_name in fields:
         if field_name in defaults and not getattr(
-            cls_dict[field_name], "_default", None
+                cls_dict[field_name], "_default", None
         ):
             cls_dict[field_name]._try_default_value(defaults[field_name])
             cls_dict[field_name]._default = defaults[field_name]
@@ -547,15 +547,15 @@ def _type_is_generic(v):
     generic_alias = getattr(typing, "_GenericAlias", Foo)
     special_generic_alias = getattr(typing, "_SpecialGenericAlias", Foo)
     return (
-        (python_ver_36 and isinstance(v, typing_base))
-        or (
-            python_ver_atleast_than_37
-            and isinstance(v, (generic_alias, special_generic_alias))
-        )
-        or (
-            python_ver_atleast_39
-            and origin in {list, dict, tuple, set, frozenset, deque, typing.Union}
-        )
+            (python_ver_36 and isinstance(v, typing_base))
+            or (
+                    python_ver_atleast_than_37
+                    and isinstance(v, (generic_alias, special_generic_alias))
+            )
+            or (
+                    python_ver_atleast_39
+                    and origin in {list, dict, tuple, set, frozenset, deque, typing.Union}
+            )
     )
 
 
@@ -614,7 +614,7 @@ def add_annotations_to_class_dict(cls_dict):
                     from .fields import AnyOf
 
                     if isinstance(the_type, AnyOf) and getattr(
-                        the_type, "_is_optional", False
+                            the_type, "_is_optional", False
                     ):
                         optional_fields.add(k)
                     if k in cls_dict:
@@ -691,6 +691,7 @@ class Structure(UniqueMixin, metaclass=StructMeta):
         _ignore_none(bool): optional
              Ignore assignment to None for any field value.
              Default is False.
+             Required fields never ignore None (since they are required)
 
     Decorating it with @unique ensures that no all instances of this structure will be unique. It
     will raise an exception otherwise (see "Uniqueness" section).
@@ -723,14 +724,18 @@ class Structure(UniqueMixin, metaclass=StructMeta):
             if key in self.__dict__:
                 raise ValueError("Structure is immutable")
             value = deepcopy(value)
-        if getattr(self, IGNORE_NONE_VALUES, False) and value is None:
+        if all([getattr(self, IGNORE_NONE_VALUES, False),
+                value is None,
+                key not in getattr(self.__class__, REQUIRED_FIELDS, [])]
+               ):
             return
+
         super().__setattr__(key, value)
 
         if (
-            getattr(self, "_instantiated", False)
-            and not _is_dunder(key)
-            and not _is_sunder(key)
+                getattr(self, "_instantiated", False)
+                and not _is_dunder(key)
+                and not _is_sunder(key)
         ):
             self.__manage_uniqueness__()
 
@@ -766,7 +771,7 @@ class Structure(UniqueMixin, metaclass=StructMeta):
 
         name = self.__class__.__name__
         if name.startswith("StructureReference_") and self.__class__.__bases__ == (
-            Structure,
+                Structure,
         ):
             name = "Structure"
         props = []
@@ -797,7 +802,7 @@ class Structure(UniqueMixin, metaclass=StructMeta):
 
     def __delitem__(self, key):
         if isinstance(getattr(self, REQUIRED_FIELDS), list) and key in getattr(
-            self, REQUIRED_FIELDS
+                self, REQUIRED_FIELDS
         ):
             raise ValueError("{} is mandatory".format(key))
         del self.__dict__[key]
@@ -842,9 +847,9 @@ class Structure(UniqueMixin, metaclass=StructMeta):
         required = props.get(REQUIRED_FIELDS, field_names)
         additional_props = props.get(ADDITIONAL_PROPERTIES, True)
         if (
-            len(field_names) == 1
-            and required == field_names
-            and additional_props is False
+                len(field_names) == 1
+                and required == field_names
+                and additional_props is False
         ):
             return item in getattr(self, field_names[0], {})
 

home/dannyloya/github/typedpy/venv39/lib/python3.9/site-packages/{typedpy-2.2.2-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.2
+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.2.tar.gz
+Download-URL: https://github.com/loyada/typedpy/archive/v2.2.4.tar.gz
 Description: [![][travis img]][travis]
         [![][docs img]][docs]