Add support for enums, bump version to 0.9.0

Author: Dobiasd

setup.py

@@ -5,7 +5,7 @@
 
 setuptools.setup(
     name="undictify",
-    version="0.8.1",
+    version="0.9.0",
     author="Tobias Hermann",
     author_email="[email protected]",
     description="Type-checked function calls at runtime",

undictify/_unpack.py

@@ -1,9 +1,9 @@
 """
 undictify - Type-checked function calls at runtime
 """
+import enum
 import inspect
 import sys
-from enum import Enum
 from functools import wraps
 from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Union, get_type_hints, Tuple
 
@@ -20,7 +20,7 @@
 TypeT = TypeVar('TypeT')
 
 
-class ConverterTag(Enum):
+class ConverterTag(enum.Enum):
     """When to apply a converter"""
     OPTIONAL = 1
     MANDATORY = 2
@@ -278,6 +278,11 @@ def _get_value(func: WrappedOrFunc[TypeT],
                                 f'{_get_type_name(type(result))}')
             return result
         if Any not in allowed_types and not _isinstanceofone(value, allowed_types):
+            if _is_enum_type(func):
+                for entry in func:  # type: ignore
+                    if value == entry.value:
+                        return entry
+                raise TypeError(f'Unable to instantiate {func} from {value}.')
             if optional_converters and param_name in optional_converters:
                 result = optional_converters[param_name](value)
                 if not _isinstanceofone(result, allowed_types):
@@ -300,11 +305,11 @@ def _get_value(func: WrappedOrFunc[TypeT],
                     if isinstance(value, str) and func is bool:  # type: ignore
                         return _string_to_bool(value)
                     return func(value)
-                except ValueError:
+                except ValueError as ex:
                     raise TypeError(f'Can not convert {value} '
                                     f'from type {_get_type_name(value_type)} '
                                     f'into type {_get_type_name(func)} '
-                                    f'for key {param_name}.')
+                                    f'for key {param_name}.') from ex
 
             raise TypeError(f'Key {param_name} has incorrect type: '
                             f'{_get_type_name(value_type)} instead of '
@@ -499,6 +504,14 @@ def _is_optional_type(the_type: Callable[..., TypeT]) -> bool:
     return any(_is_none_type(union_arg) for union_arg in union_args)
 
 
+def _is_enum_type(the_type: Callable[..., TypeT]) -> bool:
+    """Return True if the type is an Enum."""
+    try:
+        return issubclass(the_type, enum.Enum)  # type: ignore
+    except TypeError:
+        return False
+
+
 def _is_union_of_builtins_type(the_type: Callable[..., TypeT]) -> bool:
     """Return True if the type is an Union only made of
     None, str, int, float and bool."""

undictify/tests.py

@@ -2,6 +2,7 @@
 undictify - tests
 """
 
+import enum
 import json
 import pickle
 import sys
@@ -1395,3 +1396,61 @@ def hello(x: dataclasses.InitVar[Any], y: dataclasses.InitVar[Any],  # pylint: d
 
         with self.assertRaises(TypeError):
             hello(**{'x': 'hello', 'y': 'world', 'z': 'twelve'})
+
+
+class SomeIntEnum(enum.Enum):
+    """An enum with int values"""
+    FOO = 1
+    BAR = 2
+
+
+class SomeAutoEnum(enum.Enum):
+    """An enum with auto values"""
+    FOO = enum.auto()
+    BAR = enum.auto()
+
+
+class SomeStrEnum(enum.Enum):
+    """An enum with str values"""
+    FOO = "FOO"
+    BAR = "NOTEXACTLYBAR"
+
+
+@type_checked_constructor()
+class WithIntEnum(NamedTuple):
+    """Some dummy class with int enum."""
+    int_enum: SomeIntEnum
+
+
+@type_checked_constructor()
+class WithStrEnum(NamedTuple):
+    """Some dummy class with str enum."""
+    str_enum: SomeStrEnum
+
+
+@type_checked_constructor()
+class WithAutoEnum(NamedTuple):
+    """Some dummy class with auto enum."""
+    auto_enum: SomeAutoEnum
+
+
+class TestWithEnums(unittest.TestCase):
+    """Enums should work too"""
+
+    def test_int_enum(self) -> None:
+        """Valid JSON string."""
+        object_repr = '''{"int_enum": 2}'''
+        obj = WithIntEnum(**json.loads(object_repr))
+        self.assertEqual(SomeIntEnum.BAR, obj.int_enum)
+
+    def test_str_enum(self) -> None:
+        """Valid JSON string."""
+        object_repr = '''{"str_enum": "NOTEXACTLYBAR"}'''
+        obj = WithStrEnum(**json.loads(object_repr))
+        self.assertEqual(SomeStrEnum.BAR, obj.str_enum)
+
+    def test_auto_enum(self) -> None:
+        """Valid JSON string."""
+        object_repr = '''{"auto_enum": ''' + str(SomeAutoEnum.FOO.value) + '''}'''
+        obj = WithAutoEnum(**json.loads(object_repr))
+        self.assertEqual(SomeAutoEnum.FOO, obj.auto_enum)