typedpy 2.2.2__tar.gz → 2.2.3__tar.gz

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.3-py3.9.egg-info}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: typedpy
-Version: 2.2.2
+Version: 2.2.3
 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.3.tar.gz
 Description: [![][travis img]][travis]
         [![][docs img]][docs]