Improve support for Enum's

Author: mythz

servicestack/__init__.py

@@ -60,8 +60,14 @@
     'WebServiceExceptionType',
     'to_json',
     'from_json',
+    'convert',
     'qsvalue',
     'resolve_httpmethod',
+    'is_optional',
+    'is_list',
+    'is_dict',
+    'generic_args',
+    'generic_arg',
     'index_of',
     'last_index_of',
     'left_part',
@@ -75,11 +81,18 @@
     'from_datetime',
     'to_bytearray',
     'from_bytearray',
+    'from_base64url_safe',
+    'inspect_jwt',
+    'inspect_vars',
+    'dump',
+    'printdump',
+    'dumptable',
+    'printdumptable',
     'Bytes',
 ]
 
 from .dtos import *
 from .clients import TypeConverters, JsonServiceClient, WebServiceException, WebServiceExceptionType, to_json, \
-    from_json, qsvalue, resolve_httpmethod
+    from_json, convert, qsvalue, resolve_httpmethod
 from .utils import *
 from .fields import *

servicestack/clients.py

@@ -2,7 +2,7 @@
 import inspect
 import typing
 from dataclasses import field, fields, asdict, is_dataclass
-from enum import Enum
+from enum import Enum, IntEnum
 from typing import Callable, get_args, Type, get_origin, ForwardRef, Union
 from urllib.parse import urljoin, quote_plus
 
@@ -29,7 +29,9 @@ def _dump(obj):
     print("")
 
 
-def _get_type_vars_map(cls: Type, type_map: Dict[Union[type, TypeVar], type] = {}):
+def _get_type_vars_map(cls: Type, type_map=None):
+    if type_map is None:
+        type_map = {}
     if hasattr(cls, '__orig_bases__'):
         for base_cls in cls.__orig_bases__:
             _get_type_vars_map(base_cls, type_map)
@@ -178,7 +180,9 @@ def _json_encoder(obj: Any):
 
 def to_json(obj: Any):
     if is_dataclass(obj):
-        return json.dumps(clean_any(obj.to_dict()), default=_json_encoder)
+        obj_dict = clean_any(obj.to_dict())
+        print(obj_dict)
+        return json.dumps(obj_dict, default=_json_encoder)
     return json.dumps(obj, default=_json_encoder)
 
 
@@ -236,8 +240,8 @@ def sanitize_name(s: str):
 
 
 def enum_get(cls: Enum, key: Union[str, int]):
-    if type(key) == int:
-        return cls[key]
+    if type(key) == int or issubclass(cls, IntEnum):
+        return cls(key)
     try:
         return cls[key]
     except Exception as e:
@@ -246,6 +250,9 @@ def enum_get(cls: Enum, key: Union[str, int]):
             return cls[upper_snake]
         except Exception as e2:
             sanitize_key = sanitize_name(key)
+            for value in cls.__members__.values():
+                if sanitize_key == sanitize_name(value):
+                    return value
             for member in cls.__members__.keys():
                 if sanitize_key == sanitize_name(member):
                     return cls[member]
@@ -266,6 +273,10 @@ def convert(into: Type, obj: Any, substitute_types: Dict[Type, type] = None):
     if Log.debug_enabled():
         Log.debug(f"convert({into}, {substitute_types}, {obj})")
 
+    is_type = type(into) == type
+    if not is_type:
+        Log.debug(f"type of {into} is not a class")
+
     generic_def = get_origin(into)
     if generic_def is not None and is_dataclass(generic_def):
         reified_types = _get_type_vars_map(into)
@@ -290,6 +301,8 @@ def convert(into: Type, obj: Any, substitute_types: Dict[Type, type] = None):
         key_type = _resolve_type(key_type, substitute_types)
         val_type = _resolve_type(val_type, substitute_types)
         to = {}
+        if not hasattr(obj, 'items'):
+            Log.warn(f"dict {obj} ({type(type)}) does not have items()")
         for key, val in obj.items():
             to_key = convert(key_type, key, substitute_types)
             to_val = convert(val_type, val, substitute_types)
@@ -309,7 +322,7 @@ def convert(into: Type, obj: Any, substitute_types: Dict[Type, type] = None):
             except Exception as e:
                 Log.error(f"into().deserialize(obj) {into}({obj})", e)
                 raise e
-        elif issubclass(into, Enum):
+        elif is_type and issubclass(into, Enum):
             try:
                 return enum_get(into, obj)
             except Exception as e:
@@ -320,6 +333,8 @@ def convert(into: Type, obj: Any, substitute_types: Dict[Type, type] = None):
             try:
                 return into(obj)
             except Exception as e:
+                # if into == typing.Dict or get_origin(into) == typing.Dict:
+                #     print("WAS A typing.Dict")
                 Log.error(f"into(obj) {into}({obj})", e)
                 raise e
 

tests/dtos.py

@@ -1,20 +1,20 @@
 """ Options:
-Date: 2021-07-11 10:30:38
+Date: 2021-07-11 12:33:01
 Version: 5.111
 Tip: To override a DTO option, remove "//" prefix before updating
 BaseUrl: https://test.servicestack.net
 
-#GlobalNamespace:
+#GlobalNamespace: 
 #MakePropertiesOptional: False
 #AddServiceStackTypes: True
 #AddResponseStatus: False
-#AddImplicitVersion:
+#AddImplicitVersion: 
 #AddDescriptionAsComments: True
-#IncludeTypes:
-#ExcludeTypes:
-#DefaultImports: datetime,decimal,marshmallow.fields:*,servicestack:*,typing:*,dataclasses:dataclass/field,dataclasses_json:dataclass_json/LetterCase/Undefined/config,enum:Enum
-#DataClass:
-#DataClassJson:
+#IncludeTypes: 
+#ExcludeTypes: 
+#DefaultImports: datetime,decimal,marshmallow.fields:*,servicestack:*,typing:*,dataclasses:dataclass/field,dataclasses_json:dataclass_json/LetterCase/Undefined/config,enum:Enum/IntEnum
+#DataClass: 
+#DataClassJson: 
 """
 
 import datetime
@@ -24,7 +24,7 @@
 from typing import *
 from dataclasses import dataclass, field
 from dataclasses_json import dataclass_json, LetterCase, Undefined, config
-from enum import Enum
+from enum import Enum, IntEnum
 
 
 @dataclass_json(letter_case=LetterCase.CAMEL, undefined=Undefined.EXCLUDE)
@@ -172,7 +172,7 @@ class EnumType(str, Enum):
 
 
 # @Flags()
-class EnumTypeFlags(Enum):
+class EnumTypeFlags(IntEnum):
     VALUE1 = 0
     VALUE2 = 1
     VALUE3 = 2
@@ -185,15 +185,15 @@ class EnumWithValues(str, Enum):
 
 
 # @Flags()
-class EnumFlags(Enum):
-    VALUE0 = 'Value0'
-    VALUE1 = 'Value 1'
-    VALUE2 = 'Value2'
-    VALUE3 = 'Value3'
-    VALUE123 = 'Value123'
+class EnumFlags(IntEnum):
+    VALUE0 = 0
+    VALUE1 = 1
+    VALUE2 = 2
+    VALUE3 = 4
+    VALUE123 = 7
 
 
-class EnumAsInt(Enum):
+class EnumAsInt(IntEnum):
     VALUE1 = 1000
     VALUE2 = 2000
     VALUE3 = 3000
@@ -295,7 +295,7 @@ class DayOfWeek(str, Enum):
     SATURDAY = 'Saturday'
 
 
-class ScopeType(Enum):
+class ScopeType(IntEnum):
     GLOBAL_ = 1
     SALE = 2
 
@@ -2005,3 +2005,4 @@ class RealDeleteAuditTenant(IReturn[RockstarWithIdAndCountResponse], IDeleteDb[R
 @dataclass
 class CreateRockstarVersion(RockstarBase, IReturn[RockstarWithIdAndRowVersionResponse], ICreateDb[RockstarVersion]):
     pass
+

tests/techstacks_dtos.py

@@ -1,20 +1,20 @@
 """ Options:
-Date: 2021-07-11 08:30:48
+Date: 2021-07-11 10:33:03
 Version: 5.111
 Tip: To override a DTO option, remove "//" prefix before updating
 BaseUrl: https://techstacks.io
 
-#GlobalNamespace:
+#GlobalNamespace: 
 #MakePropertiesOptional: False
 #AddServiceStackTypes: True
 #AddResponseStatus: False
-#AddImplicitVersion:
+#AddImplicitVersion: 
 #AddDescriptionAsComments: True
-#IncludeTypes:
-#ExcludeTypes:
+#IncludeTypes: 
+#ExcludeTypes: 
 #DefaultImports: datetime,decimal,marshmallow.fields:*,servicestack:*,typing:*,dataclasses:dataclass/field,dataclasses_json:dataclass_json/LetterCase/Undefined/config,enum:Enum
-#DataClass:
-#DataClassJson:
+#DataClass: 
+#DataClassJson: 
 """
 
 import datetime
@@ -2021,3 +2021,4 @@ class QueryPostComments(QueryDb[PostComment], IReturn[QueryResponse[PostComment]
     word_count_below: Optional[int] = None
     report_count_above: Optional[int] = None
     report_count_below: Optional[int] = None
+

tests/test_enum_serialization.py

@@ -0,0 +1,74 @@
+"""Enum Serialization
+"""
+
+import unittest
+
+import requests
+from dataclasses_json import config, dataclass_json, Undefined
+
+from .dtos import *
+from datetime import datetime, timedelta, timezone
+from servicestack import JsonServiceClient, WebServiceException, to_json, convert
+from .config import create_test_client
+from servicestack.utils import *
+from tests.dtos import HelloWithEnum
+
+
+class TestEnumSerialization(unittest.TestCase):
+
+    def assert_HelloWithEnum(self, actual: HelloWithEnum, expected: HelloWithEnum):
+        self.assertEqual(actual.enum_prop, expected.enum_prop)
+        self.assertEqual(actual.enum_with_values, expected.enum_with_values)
+        self.assertEqual(actual.nullable_enum_prop, expected.nullable_enum_prop)
+        self.assertEqual(actual.enum_flags, expected.enum_flags)
+        self.assertEqual(actual.enum_style, expected.enum_style)
+
+    def test_does_serialize_HelloWithEnum_empty(self):
+        dto = HelloWithEnum()
+        json_str = to_json(dto)
+        json_obj = json.loads(json_str)
+        from_json_obj = convert(HelloWithEnum, json_obj)
+        self.assertEqual(from_json_obj, dto)
+
+    def test_does_serialize_HelloWithEnum_EnumFlags(self):
+        dto = HelloWithEnum(enum_flags=EnumFlags.VALUE1)
+        json_str = to_json(dto)
+        json_obj = json.loads(json_str)
+        from_json_obj = convert(HelloWithEnum, json_obj)
+        self.assertEqual(from_json_obj, dto)
+
+    def test_does_serialize_HelloWithEnum_all(self):
+        dto = HelloWithEnum(
+            enum_prop=EnumType.VALUE2,
+            enum_with_values=EnumWithValues.VALUE1,
+            enum_flags=EnumFlags.VALUE1,
+            enum_style=EnumStyle.UPPER)
+        json_str = to_json(dto)
+        json_obj = json.loads(json_str)
+        from_json_obj = convert(HelloWithEnum, json_obj)
+        self.assertEqual(from_json_obj, dto)
+
+    def assert_HelloWithEnumMap(self, actual: HelloWithEnumMap, expected: HelloWithEnumMap):
+        self.assertDictEqual(actual.enum_prop, expected.enum_prop)
+        self.assertDictEqual(actual.enum_with_values, expected.enum_with_values)
+        self.assertDictEqual(actual.nullable_enum_prop, expected.nullable_enum_prop)
+        self.assertDictEqual(actual.enum_flags, expected.enum_flags)
+        self.assertDictEqual(actual.enum_style, expected.enum_style)
+
+    def test_does_serialize_HelloWithEnumMap_empty(self):
+        dto = HelloWithEnumMap()
+        json_str = to_json(dto)
+        json_obj = json.loads(json_str)
+        from_json_obj = convert(HelloWithEnumMap, json_obj)
+        self.assertEqual(from_json_obj, dto)
+
+    def test_does_serialize_HelloWithEnumMap_all(self):
+        dto = HelloWithEnumMap(
+            enum_prop={f"{EnumType.VALUE2}": EnumType.VALUE2},
+            enum_with_values={f"{EnumWithValues.VALUE1}": EnumWithValues.VALUE1},
+            enum_flags={f"{EnumFlags.VALUE1}": EnumFlags.VALUE1},
+            enum_style={f"{EnumStyle.UPPER}": EnumStyle.UPPER})
+        json_str = to_json(dto)
+        json_obj = json.loads(json_str)
+        from_json_obj = convert(HelloWithEnumMap, json_obj)
+        self.assertEqual(from_json_obj, dto)