Milestone to v1

benchmarks/complex.py

@@ -16,7 +16,7 @@
 import attr
 import mashumaro
 
-from dataclass_wizard import JSONWizard
+from dataclass_wizard import JSONWizard, LoadMeta
 from dataclass_wizard.class_helper import create_new_class
 from dataclass_wizard.utils.string_conv import to_snake_case
 from dataclass_wizard.utils.type_conv import as_datetime
@@ -135,6 +135,10 @@ class PersonDJ:
     attr_dict=vars(MyClass).copy())
 
 
+# Enable experimental `v1` mode for optimized de/serialization
+LoadMeta(v1=True).bind_to(MyClassWizard)
+
+
 @pytest.fixture(scope='session')
 def data():
     return {
@@ -214,14 +218,14 @@ def test_load(request, data, data_2, data_dacite, n):
     """
     [ RESULTS ON MAC OS X ]
 
-    benchmarks.complex.complex - [INFO] dataclass-wizard     0.800521
-    benchmarks.complex.complex - [INFO] dataclass-factory    0.827150
-    benchmarks.complex.complex - [INFO] dataclasses-json     37.087781
-    benchmarks.complex.complex - [INFO] dacite               9.421210
-    benchmarks.complex.complex - [INFO] mashumaro            0.608496
-    benchmarks.complex.complex - [INFO] pydantic             1.039472
-    benchmarks.complex.complex - [INFO] jsons                39.677698
-    benchmarks.complex.complex - [INFO] jsons (strict)       41.592585
+    benchmarks.complex.complex - [INFO] dataclass-wizard     0.373847
+    benchmarks.complex.complex - [INFO] dataclass-factory    0.777164
+    benchmarks.complex.complex - [INFO] dataclasses-json     28.177022
+    benchmarks.complex.complex - [INFO] dacite               6.619898
+    benchmarks.complex.complex - [INFO] mashumaro            0.351623
+    benchmarks.complex.complex - [INFO] pydantic             0.563395
+    benchmarks.complex.complex - [INFO] jsons                30.564242
+    benchmarks.complex.complex - [INFO] jsons (strict)       35.122489
     """
     g = globals().copy()
     g.update(locals())

benchmarks/nested.py

@@ -13,7 +13,7 @@
 from pydantic import BaseModel
 import mashumaro
 
-from dataclass_wizard import JSONWizard
+from dataclass_wizard import JSONWizard, LoadMeta
 from dataclass_wizard.class_helper import create_new_class
 from dataclass_wizard.utils.string_conv import to_snake_case
 from dataclass_wizard.utils.type_conv import as_datetime, as_date
@@ -141,6 +141,8 @@ class Data2DJ:
 JsonsType = TypeVar('JsonsType', Data1, JsonSerializable)
 # Model for `dataclasses-json`
 DJType = TypeVar('DJType', Data1, DataClassJsonMixin)
+# Model for `mashumaro`
+MashumaroType = TypeVar('MashumaroType', Data1, mashumaro.DataClassDictMixin)
 # Factory for `dataclass-factory`
 factory = dataclass_factory.Factory()
 
@@ -150,12 +152,19 @@ class Data2DJ:
 MyClassJsons: JsonsType = create_new_class(
     Data1, (Data1, JsonSerializable), 'Jsons',
     attr_dict=vars(Data1).copy())
+MyClassMashumaroModel: MashumaroType = create_new_class(
+    Data1, (Data1, mashumaro.DataClassDictMixin), 'Mashumaro',
+    attr_dict=vars(Data1).copy())
 
 # Pydantic Model for Benchmarking
 MyClassPydanticModel = MyClassPydantic
 
 # Mashumaro Model for Benchmarking
-MyClassMashumaroModel = MyClassMashumaro
+# MyClassMashumaroModel = MyClassMashumaro
+
+
+# Enable experimental `v1` mode for optimized de/serialization
+LoadMeta(v1=True).bind_to(MyClassWizard)
 
 
 @pytest.fixture(scope='session')
@@ -205,18 +214,20 @@ def test_load(request, data, n):
     """
     [ RESULTS ON MAC OS X ]
 
-    benchmarks.nested.nested - [INFO] dataclass-wizard     0.397123
-    benchmarks.nested.nested - [INFO] dataclass-factory    0.418530
-    benchmarks.nested.nested - [INFO] dataclasses-json     11.443072
-    benchmarks.nested.nested - [INFO] mashumaro            0.158189
-    benchmarks.nested.nested - [INFO] pydantic             0.346031
-    benchmarks.nested.nested - [INFO] jsons                28.124958
-    benchmarks.nested.nested - [INFO] jsons (strict)       28.816675
+    benchmarks.nested.nested - [INFO] dataclass-wizard     0.135700
+    benchmarks.nested.nested - [INFO] dataclass-factory    0.412265
+    benchmarks.nested.nested - [INFO] dataclasses-json     11.448704
+    benchmarks.nested.nested - [INFO] mashumaro            0.150680
+    benchmarks.nested.nested - [INFO] pydantic             0.328947
+    benchmarks.nested.nested - [INFO] jsons                25.052287
+    benchmarks.nested.nested - [INFO] jsons (strict)       43.233567
 
     """
     g = globals().copy()
     g.update(locals())
 
+    MyClassWizard.from_dict(data)
+
     log.info('dataclass-wizard     %f',
              timeit('MyClassWizard.from_dict(data)', globals=g, number=n))
 

benchmarks/simple.py

@@ -13,7 +13,7 @@
 import attr
 import mashumaro
 
-from dataclass_wizard import JSONWizard
+from dataclass_wizard import JSONWizard, LoadMeta
 from dataclass_wizard.class_helper import create_new_class
 from dataclass_wizard.utils.string_conv import to_snake_case
 
@@ -65,6 +65,10 @@ class MyClassMashumaro(mashumaro.DataClassDictMixin):
 MyClassDJ: DJType = create_new_class(MyClass, (MyClass, DataClassJsonMixin), "DJ")
 MyClassJsons: JsonsType = create_new_class(MyClass, (MyClass, JsonSerializable), "Jsons")
 
+# Enable experimental `v1` mode for optimized de/serialization
+LoadMeta(v1=True).bind_to(MyClassWizard)
+
+
 @pytest.fixture(scope="session")
 def data():
     return {
@@ -77,7 +81,7 @@ def test_load(data, n):
     """
     [ RESULTS ON MAC OS X ]
 
-    benchmarks.simple.simple - [INFO] dataclass-wizard     0.076336
+    benchmarks.simple.simple - [INFO] dataclass-wizard     0.033917
     benchmarks.simple.simple - [INFO] dataclass-factory    0.103837
     benchmarks.simple.simple - [INFO] dataclasses-json     3.941902
     benchmarks.simple.simple - [INFO] jsons                5.636863

dataclass_wizard/__init__.py

@@ -114,18 +114,23 @@
     'IS_NOT',
     'IS_TRUTHY',
     'IS_FALSY',
+    # V1
+    'Alias',
+    'AliasPath',
 ]
 
 import logging
 
 from .bases_meta import LoadMeta, DumpMeta, EnvMeta
 from .dumpers import DumpMixin, setup_default_dumper, asdict
-from .loaders import LoadMixin, setup_default_loader, fromlist, fromdict
+from .loaders import LoadMixin, setup_default_loader
+from .loader_selection import fromlist, fromdict
 from .models import (env_field, json_field, json_key, path_field, skip_if_field,
                      KeyPath, Container,
                      Pattern, DatePattern, TimePattern, DateTimePattern,
                      CatchAll, SkipIf, SkipIfNone,
                      EQ, NE, LT, LE, GT, GE, IS, IS_NOT, IS_TRUTHY, IS_FALSY)
+from .v1.models import Alias, AliasPath
 from .environ.wizard import EnvWizard
 from .property_wizard import property_wizard
 from .serial_json import JSONWizard, JSONPyWizard, JSONSerializable

dataclass_wizard/abstractions.py

@@ -9,6 +9,7 @@
 
 from .bases import META
 from .models import Extras
+from .v1.models import TypeInfo
 from .type_def import T, TT
 
 
@@ -252,3 +253,222 @@ def get_parser_for_annotation(cls, ann_type,
 
 class AbstractDumper(ABC):
     __slots__ = ()
+
+
+class AbstractLoaderGenerator(ABC):
+    """
+    Abstract code generator which defines helper methods to generate the
+    code for deserializing an object `o` of a given annotated type into
+    the corresponding dataclass field during dynamic function construction.
+    """
+    __slots__ = ()
+
+    @staticmethod
+    @abstractmethod
+    def transform_json_field(string: str) -> str:
+        """
+        Transform a JSON field name (which will typically be camel-cased)
+        into the conventional format for a dataclass field name
+        (which will ideally be snake-cased).
+        """
+
+    @staticmethod
+    @abstractmethod
+    def default_load_to(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code for the default load function if no other types match.
+        Generally, this will be a stub load method.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_after_type_check(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load an object after confirming its type.
+
+        :param type_str: The type annotation of the field as a string.
+        :param i: Index of the value being processed.
+        :param extras: Additional context or dependencies for code generation.
+        :raises ParseError: If the object type is not as expected.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_str(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into a string field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_int(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into an integer field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_float(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into a float field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_bool(_: str, extras: Extras) -> str:
+        """
+        Generate code to load a value into a boolean field.
+        Adds a helper function `as_bool` to the local context.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_bytes(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into a bytes field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_bytearray(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into a bytearray field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_none(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into a None.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_literal(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to confirm a value is equivalent to one
+        of the provided literals.
+        """
+
+    @classmethod
+    @abstractmethod
+    def load_to_union(cls, tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a `Union[X, Y, ...]` (one of [X, Y, ...] possible types)
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_enum(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into an Enum field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_uuid(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a UUID field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_iterable(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into an iterable field (list, set, etc.).
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_tuple(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a tuple field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_named_tuple(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a named tuple field.
+        """
+
+    @classmethod
+    @abstractmethod
+    def load_to_named_tuple_untyped(cls, tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into an untyped named tuple.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_dict(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a dictionary field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_defaultdict(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a defaultdict field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_typed_dict(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a typed dictionary field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_decimal(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into a Decimal field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_datetime(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into a datetime field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_time(tp: TypeInfo, extras: Extras) -> str:
+        """
+        Generate code to load a value into a time field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_date(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a date field.
+        """
+
+    @staticmethod
+    @abstractmethod
+    def load_to_timedelta(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a timedelta field.
+        """
+
+    @staticmethod
+    def load_to_dataclass(tp: TypeInfo, extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to load a value into a `dataclass` type field.
+        """
+
+    @classmethod
+    @abstractmethod
+    def get_string_for_annotation(cls,
+                                  tp: TypeInfo,
+                                  extras: Extras) -> 'str | TypeInfo':
+        """
+        Generate code to get the parser (dispatcher) for a given annotation type.
+
+        `base_cls` is the original class object, useful when the annotated
+        type is a :class:`typing.ForwardRef` object.
+        """