Add Annotated support and therefore set minimum python version as 3.9

Author: mvanderlee

.pre-commit-config.yaml

@@ -3,7 +3,7 @@ repos:
   rev: v3.3.1
   hooks:
   - id: pyupgrade
-    args: ["--py36-plus"]
+    args: ["--py37-plus"]
 - repo: https://github.com/python/black
   rev: 23.1.0
   hooks:

README.md

@@ -242,28 +242,25 @@ class Sample:
 
 See [marshmallow's documentation about extending `Schema`](https://marshmallow.readthedocs.io/en/stable/extending.html).
 
-### Custom NewType declarations
+### Custom type declarations
 
-This library exports a `NewType` function to create types that generate [customized marshmallow fields](https://marshmallow.readthedocs.io/en/stable/custom_fields.html#creating-a-field-class).
-
-Keyword arguments to `NewType` are passed to the marshmallow field constructor.
+This library allows you to specify [customized marshmallow fields](https://marshmallow.readthedocs.io/en/stable/custom_fields.html#creating-a-field-class) using python's Annoted type [PEP-593](https://peps.python.org/pep-0593/).
 
 ```python
-import marshmallow.validate
-from marshmallow_dataclass import NewType
+from typing import Annotated
+import marshmallow.fields as mf
+import marshmallow.validate as mv
 
-IPv4 = NewType(
-    "IPv4", str, validate=marshmallow.validate.Regexp(r"^([0-9]{1,3}\\.){3}[0-9]{1,3}$")
-)
+IPv4 = Annotated[str, mf.String(validate=mv.Regexp(r"^([0-9]{1,3}\\.){3}[0-9]{1,3}$"))]
 ```
 
-You can also pass a marshmallow field to `NewType`.
+You can also pass a marshmallow field class.
 
 ```python
 import marshmallow
 from marshmallow_dataclass import NewType
 
-Email = NewType("Email", str, field=marshmallow.fields.Email)
+Email = Annotated[str, marshmallow.fields.Email]
 ```
 
 For convenience, some custom types are provided:

marshmallow_dataclass/__init__.py

@@ -43,6 +43,8 @@ class User:
 import warnings
 from enum import Enum
 from functools import lru_cache, partial
+from typing import Annotated, Any, Callable, Dict, FrozenSet, List, Mapping
+from typing import NewType as typing_NewType
 from typing import (
     Any,
     Callable,
@@ -52,32 +54,28 @@ class User:
     Mapping,
     NewType as typing_NewType,
     Optional,
+    Sequence,
     Set,
     Tuple,
     Type,
     TypeVar,
     Union,
     cast,
+    get_args,
+    get_origin,
     get_type_hints,
     overload,
-    Sequence,
-    FrozenSet,
 )
 
 import marshmallow
 import typing_inspect
 
 from marshmallow_dataclass.lazy_class_attribute import lazy_class_attribute
 
-
 if sys.version_info >= (3, 11):
     from typing import dataclass_transform
-elif sys.version_info >= (3, 7):
-    from typing_extensions import dataclass_transform
 else:
-    # @dataclass_transform() only helps us with mypy>=1.1 which is only available for python>=3.7
-    def dataclass_transform(**kwargs):
-        return lambda cls: cls
+    from typing_extensions import dataclass_transform
 
 
 __all__ = ["dataclass", "add_schema", "class_schema", "field_for_schema", "NewType"]
@@ -547,7 +545,7 @@ def _internal_class_schema(
 
     # Update the schema members to contain marshmallow fields instead of dataclass fields
     type_hints = get_type_hints(
-        clazz, globalns=schema_ctx.globalns, localns=schema_ctx.localns
+        clazz, globalns=schema_ctx.globalns, localns=schema_ctx.localns, include_extras=True,
     )
     attributes.update(
         (
@@ -639,12 +637,27 @@ def _field_for_generic_type(
     """
     If the type is a generic interface, resolve the arguments and construct the appropriate Field.
     """
-    origin = typing_inspect.get_origin(typ)
-    arguments = typing_inspect.get_args(typ, True)
+    origin = get_origin(typ)
+    arguments = get_args(typ)
     if origin:
         # Override base_schema.TYPE_MAPPING to change the class used for generic types below
         type_mapping = base_schema.TYPE_MAPPING if base_schema else {}
 
+        if origin is Annotated:
+            marshmallow_annotations = [
+                arg
+                for arg in arguments[1:]
+                if (inspect.isclass(arg) and issubclass(arg, marshmallow.fields.Field))
+                or isinstance(arg, marshmallow.fields.Field)
+            ]
+            if marshmallow_annotations:
+                field = marshmallow_annotations[-1]
+                # Got a field instance, return as is. User must know what they're doing
+                if isinstance(field, marshmallow.fields.Field):
+                    return field
+
+                return field(**metadata)
+
         if origin in (list, List):
             child_type = _field_for_schema(arguments[0], base_schema=base_schema)
             list_type = cast(
@@ -806,6 +819,7 @@ def _field_for_schema(
         metadata.setdefault("allow_none", True)
         return marshmallow.fields.Raw(**metadata)
 
+    # i.e.: Literal['abc']
     if typing_inspect.is_literal_type(typ):
         arguments = typing_inspect.get_args(typ)
         return marshmallow.fields.Raw(
@@ -817,6 +831,7 @@ def _field_for_schema(
             **metadata,
         )
 
+    # i.e.: Final[str] = 'abc'
     if typing_inspect.is_final_type(typ):
         arguments = typing_inspect.get_args(typ)
         if arguments:
@@ -870,13 +885,7 @@ def _field_for_schema(
 
     # enumerations
     if issubclass(typ, Enum):
-        try:
-            return marshmallow.fields.Enum(typ, **metadata)
-        except AttributeError:
-            # Remove this once support for python 3.6 is dropped.
-            import marshmallow_enum
-
-            return marshmallow_enum.EnumField(typ, **metadata)
+        return marshmallow.fields.Enum(typ, **metadata)
 
     # Nested marshmallow dataclass
     # it would be just a class name instead of actual schema util the schema is not ready yet
@@ -939,7 +948,8 @@ def NewType(
     field: Optional[Type[marshmallow.fields.Field]] = None,
     **kwargs,
 ) -> Callable[[_U], _U]:
-    """NewType creates simple unique types
+    """DEPRECATED: Use typing.Annotated instead.
+    NewType creates simple unique types
     to which you can attach custom marshmallow attributes.
     All the keyword arguments passed to this function will be transmitted
     to the marshmallow field constructor.

marshmallow_dataclass/typing.py

@@ -1,8 +1,9 @@
+from typing import Annotated
+
 import marshmallow.fields
-from . import NewType
 
-Url = NewType("Url", str, field=marshmallow.fields.Url)
-Email = NewType("Email", str, field=marshmallow.fields.Email)
+Url = Annotated[str, marshmallow.fields.Url]
+Email = Annotated[str, marshmallow.fields.Email]
 
 # Aliases
 URL = Url

tests/test_annotated.py

@@ -0,0 +1,31 @@
+import unittest
+from typing import Annotated, Optional
+
+import marshmallow
+import marshmallow.fields
+
+from marshmallow_dataclass import dataclass
+
+
+class TestAnnotatedField(unittest.TestCase):
+    def test_annotated_field(self):
+        @dataclass
+        class AnnotatedValue:
+            value: Annotated[str, marshmallow.fields.Email]
+            default_string: Annotated[
+                Optional[str], marshmallow.fields.String(load_default="Default String")
+            ] = None
+
+        schema = AnnotatedValue.Schema()
+
+        self.assertEqual(
+            schema.load({"value": "test@test.com"}),
+            AnnotatedValue(value="test@test.com", default_string="Default String"),
+        )
+        self.assertEqual(
+            schema.load({"value": "test@test.com", "default_string": "override"}),
+            AnnotatedValue(value="test@test.com", default_string="override"),
+        )
+
+        with self.assertRaises(marshmallow.exceptions.ValidationError):
+            schema.load({"value": "notavalidemail"})

tests/test_mypy.yml

@@ -27,7 +27,7 @@
     reveal_type(user.email)  # N: Revealed type is "builtins.str"
 
     User(id=42, email="user@email.com")  # E: Argument "id" to "User" has incompatible type "int"; expected "str"  [arg-type]
-    User(id="a"*32, email=["not", "a", "string"])  # E: Argument "email" to "User" has incompatible type "List[str]"; expected "str"  [arg-type]
+    User(id="a"*32, email=["not", "a", "string"])  # E: Argument "email" to "User" has incompatible type "list[str]"; expected "str"  [arg-type]
 - case: marshmallow_dataclass_keyword_arguments
   mypy_config: |
     follow_imports = silent