Issue #146

 2.13.1

Author: loyada

setup.py

@@ -29,9 +29,9 @@
     license="MIT",
     long_description=long_description,
     url="http://github.com/loyada/typedpy",
-    download_url ="https://github.com/loyada/typedpy/archive/v2.13.0.tar.gz",
+    download_url ="https://github.com/loyada/typedpy/archive/v2.13.1.tar.gz",
     keywords=['testing', 'type-safe', 'strict', 'schema', 'validation'],
-    version='2.13.0'
+    version='2.13.1'
 )
 
 # coverage run --source=typedpy/ setup.py test

tests/test_structure_extend.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from typedpy import ImmutableStructure, Map, Structure, mappers, Serializer, Extend
+from typedpy import Deserializer, ImmutableStructure, Map, Structure, mappers, Serializer, Extend
 
 
 class Blah(Structure):
@@ -106,4 +106,5 @@ class Bar(Extend[Foo], Structure):
         _serialization_mapper = mappers.TO_LOWERCASE
 
     assert Bar._serialization_mapper == mappers.TO_LOWERCASE
-    assert Bar._deserialization_mapper is None
+    assert not hasattr(Bar, "_deserialization_mapper")
+    assert Deserializer(Bar).deserialize({"X": "a", "Y": "b"}) == Bar(x="a", y="b")

typedpy/__init__.py

@@ -13,7 +13,7 @@
     FinalStructure,
     ImmutableField,
     unique,
-    AbstractStructure
+    AbstractStructure,
 )
 
 from typedpy.structures_reuse import (
@@ -85,7 +85,7 @@
     serialize_field,
     FunctionCall,
     deserialize_single_field,
-    HasTypes
+    HasTypes,
 )
 
 from .serialization_wrappers import (
@@ -117,4 +117,4 @@
 
 from .commons import nested, deep_get, first_in, flatten, default_factories
 
-from .keysof import keys_of
+from .keysof import keys_of

typedpy/commons.py

@@ -19,10 +19,10 @@ def wrap_val(v):
 def _is_dunder(name):
     """Returns True if a __dunder__ name, False otherwise."""
     return (
-            len(name) > 4
-            and name[:2] == name[-2:] == "__"
-            and name[2] != "_"
-            and name[-3] != "_"
+        len(name) > 4
+        and name[:2] == name[-2:] == "__"
+        and name[2] != "_"
+        and name[-3] != "_"
     )
 
 
@@ -37,21 +37,20 @@ def raise_errs_if_needed(errors):
         raise errors[0].__class__(messages) from errors[0]
 
 
-
 def first_in(my_list: Iterable, ignore_none: bool = False) -> Optional:
     """
-     get the first in an Iterable (i.e. list, tuple, generator, dict, etc.).
-     Optionally ignoring None values.
+    get the first in an Iterable (i.e. list, tuple, generator, dict, etc.).
+    Optionally ignoring None values.
 
-        Arguments:
-            my_list(Iterable):
-                The input iterable, such as a list
-            ignore_none(bool): optional
-                whether or not to ignore None values. Default is False
+       Arguments:
+           my_list(Iterable):
+               The input iterable, such as a list
+           ignore_none(bool): optional
+               whether or not to ignore None values. Default is False
 
 
-        Returns:
-            The first value found in the input, or None if none found
+       Returns:
+           The first value found in the input, or None if none found
     """
     if ignore_none:
         return next(filter(None, iter(my_list)), None)
@@ -60,28 +59,28 @@ def first_in(my_list: Iterable, ignore_none: bool = False) -> Optional:
 
 def nested(func, default=None):
     """
-        get a nested value if it exists, or return the given default if it doesn't
+    get a nested value if it exists, or return the given default if it doesn't
 
-            Arguments:
-                func(function):
-                    A function with no arguments that returns the nested value
-                default:
-                    the default value, in case the nested value does not exist
+        Arguments:
+            func(function):
+                A function with no arguments that returns the nested value
+            default:
+                the default value, in case the nested value does not exist
 
 
-            Returns:
-                the nested attribute(s) or the default value. For example:
+        Returns:
+            the nested attribute(s) or the default value. For example:
 
-            For example:
+        For example:
 
-                .. code-block:: python
+            .. code-block:: python
 
-                   d = D(c=C(b=B(a=A(i=5))))
-                   assert nested(lambda: d.c.b.a.i) == 5
+               d = D(c=C(b=B(a=A(i=5))))
+               assert nested(lambda: d.c.b.a.i) == 5
 
-                   d.c.foo = [1, 2, 3]
-                   assert nested(lambda: d.c.foo[100]) is None
-                   assert nested(lambda: d.c.foo[2]) == 3
+               d.c.foo = [1, 2, 3]
+               assert nested(lambda: d.c.foo[100]) is None
+               assert nested(lambda: d.c.foo[2]) == 3
     """
     try:
         return func()
@@ -91,27 +90,27 @@ def nested(func, default=None):
 
 def flatten(iterable, ignore_none=False) -> list:
     """
-         Flatten an iterable completely, getting rid of None values
+    Flatten an iterable completely, getting rid of None values
 
-            Arguments:
-                   iterable(Iterable):
-                        the input
-                   ignore_none(bool): optional
-                        whether to skip None values or not. Default is False.
+       Arguments:
+              iterable(Iterable):
+                   the input
+              ignore_none(bool): optional
+                   whether to skip None values or not. Default is False.
 
-            Returns:
-                A flattened list
+       Returns:
+           A flattened list
 
-                .. code-block:: python
+           .. code-block:: python
 
-                   flatten(
-                   [
-                     [[1]],
-                     [[2], 3, None, (5,)],
-                     []
-                   ], ignore_none=True) == [1, 2, 3, 5]
+              flatten(
+              [
+                [[1]],
+                [[2], 3, None, (5,)],
+                []
+              ], ignore_none=True) == [1, 2, 3, 5]
 
-        """
+    """
     res = (
         sum([flatten(x, ignore_none) for x in iterable], [])
         if isinstance(iterable, (list, tuple, Generator))
@@ -124,29 +123,29 @@ def flatten(iterable, ignore_none=False) -> list:
 
 def deep_get(dictionary, deep_key, default=None, do_flatten=False):
     """
-        Get a nested value from within a dictionary. Supports also nested lists, in
-        which case the result is a a list of values
+    Get a nested value from within a dictionary. Supports also nested lists, in
+    which case the result is a a list of values
 
-        Arguments:
-               dictionary(dict):
-                    the input
-               deep_key(str):
-                    nested key of the form aaa.bbb.ccc.ddd
-               default:
-                    the default value, in case the path does not exist
-               do_flatten(bool): optional
-                    flatten the outputs, in case the result is multiple outputs
+    Arguments:
+           dictionary(dict):
+                the input
+           deep_key(str):
+                nested key of the form aaa.bbb.ccc.ddd
+           default:
+                the default value, in case the path does not exist
+           do_flatten(bool): optional
+                flatten the outputs, in case the result is multiple outputs
 
-        Returns:
-            the nested attribute(s) or the default value. For example:
+    Returns:
+        the nested attribute(s) or the default value. For example:
 
-        For example:
+    For example:
 
-            .. code-block:: python
+        .. code-block:: python
 
-               example = {"a": {"b": [{"c": [None, {"d": [1]}]}, {"c": [None, {"d": [2]}, {"d": 3}]}, {"c": []}]}}
-               assert deep_get(example, "a.b.c.d") == [[[1]], [[2], 3], []]
-               assert deep_get(example, "a.b.c.d", do_flatten=True) == [1, 2, 3]
+           example = {"a": {"b": [{"c": [None, {"d": [1]}]}, {"c": [None, {"d": [2]}, {"d": 3}]}, {"c": []}]}}
+           assert deep_get(example, "a.b.c.d") == [[[1]], [[2], 3], []]
+           assert deep_get(example, "a.b.c.d", do_flatten=True) == [1, 2, 3]
 
     """
 
@@ -159,36 +158,40 @@ def _get_next_level(d: Optional[Union[Mapping, Iterable]], key, default):
         return default
 
     keys = deep_key.split(".")
-    result = reduce(lambda d, key: _get_next_level(d, key, default) if d else default, keys, dictionary)
+    result = reduce(
+        lambda d, key: _get_next_level(d, key, default) if d else default,
+        keys,
+        dictionary,
+    )
     if isinstance(result, (list, tuple, Generator)) and do_flatten:
         result = flatten(result)
     return result
 
 
 def default_factories(func):
     """
-         A function decorator that allows to have default values that are generators of the actual
-         default values to be used. This is useful when the default values are mutable, like
-         dicts or lists
+     A function decorator that allows to have default values that are generators of the actual
+     default values to be used. This is useful when the default values are mutable, like
+     dicts or lists
 
-            Arguments:
-                   iterable(Iterable):
-                        the input
-                   ignore_none(bool): optional
-                        whether to skip None values or not. Default is False.
+        Arguments:
+               iterable(Iterable):
+                    the input
+               ignore_none(bool): optional
+                    whether to skip None values or not. Default is False.
 
-            Returns:
-                A flattened list
+        Returns:
+            A flattened list
 
-        For example:
+    For example:
 
-                .. code-block:: python
+            .. code-block:: python
 
-                   @default_factories
-                   def func(a, b = 0, c = list, d = dict):
-                        return a, b, c, d
+               @default_factories
+               def func(a, b = 0, c = list, d = dict):
+                    return a, b, c, d
 
-                   assert func(1) == 1, 0, [] , {}
+               assert func(1) == 1, 0, [] , {}
 
     """
     func_signature = signature(func, follow_wrapped=True)
@@ -199,7 +202,11 @@ def decorated(*args, **kwargs):
 
         for k, v in func_signature.parameters.items():
             if k not in bound.arguments:
-                default = v.default() if callable(v.default) and v.default != v.empty else v.default
+                default = (
+                    v.default()
+                    if callable(v.default) and v.default != v.empty
+                    else v.default
+                )
                 if v.default != v.empty:
                     kwargs[k] = default
         return func(*args, **kwargs)

typedpy/enum.py

@@ -14,7 +14,7 @@ def __getitem__(cls, values):
 
 def _all_values_from_single_enum(values):
     clazz = first_in(values).__class__
-    if not(isinstance(clazz, (type,)) and issubclass(clazz, enum.Enum)):
+    if not (isinstance(clazz, (type,)) and issubclass(clazz, enum.Enum)):
         return False
     return all([v.__class__ is clazz for v in values])
 
@@ -28,9 +28,9 @@ class Enum(SerializableField, metaclass=_EnumMeta):
              allowed values. Can be of any type.
              Alternatively, can be an enum.Enum type. See example below.
              When defined with an enum.Enum, serialization converts to strings,
-             while deserialization expects strings (unless using serialization_by_value). 
+             while deserialization expects strings (unless using serialization_by_value).
              In this case, strings are converted to the original enum values.
-             
+
              Another option is assign a list of specific values from an enum.Enum class.
              In this case, it will work like asigning an Enum class, but allowing only specific values
              of that enum (see example below).
@@ -80,9 +80,9 @@ class Action(Structure):
 
 
         assert Deserializer(Action).deserialize({"command": "delete stream"}).command is StreamCommand.delete
-        
+
     An example of allowing only specific values of an Enum class, referencging StreamCommand in the previous example:
-    
+
     .. code-block:: python
 
        class Action(Structure):
@@ -98,15 +98,22 @@ class Action(Structure):
     def __init__(self, *args, values, serialization_by_value: bool = False, **kwargs):
         if not values:
             raise ValueError("Enum requires values parameters")
-        self._is_enum = (isinstance(values, (type,)) and issubclass(values, enum.Enum)
-                         or _all_values_from_single_enum(values))
+        self._is_enum = (
+            isinstance(values, (type,))
+            and issubclass(values, enum.Enum)
+            or _all_values_from_single_enum(values)
+        )
         self.serialization_by_value = serialization_by_value
 
         if self._is_enum:
-            self._enum_class = values if isinstance(values, (type,)) else first_in(values).__class__
+            self._enum_class = (
+                values if isinstance(values, (type,)) else first_in(values).__class__
+            )
             if serialization_by_value:
                 self._enum_by_value = {e.value: e for e in self._enum_class}
-            self._valid_enum_values = [v for v in self._enum_class] if  isinstance(values, (type,)) else values
+            self._valid_enum_values = (
+                [v for v in self._enum_class] if isinstance(values, (type,)) else values
+            )
             self.values = list(values)
         else:
             self.values = values
@@ -134,7 +141,9 @@ def serialize(self, value):
         if self._is_enum:
             if self.serialization_by_value:
                 if not isinstance(value.value, (bool, str, int, float)):
-                    raise TypeError(f"{self._name}: Cannot serialize value: {value.value}")
+                    raise TypeError(
+                        f"{self._name}: Cannot serialize value: {value.value}"
+                    )
             return value.value if self.serialization_by_value else value.name
         return value
 

typedpy/fields.py

@@ -262,7 +262,7 @@ def err_prefix():
             )
         if self.pattern is not None and not self._compiled_pattern.match(value):
             raise ValueError(
-                f'{err_prefix()}Does not match regular expression: {wrap_val(self.pattern)}'
+                f"{err_prefix()}Does not match regular expression: {wrap_val(self.pattern)}"
             )
 
     def __set__(self, instance, value):