Include additional properties in TypedDict deserialization

.github/workflows/ci.yml

@@ -7,6 +7,7 @@ on:
       - v[0-9]*.*
     paths:
       - "**.py"
+      - tests/**
   pull_request:
     paths:
       - "**.py"

apischema/deserialization/__init__.py

@@ -422,9 +422,9 @@ def factory(
                 and not flattened_fields
                 and not pattern_fields
                 and not additional_field
-                and not self.additional_properties
+                and (is_typed_dict(cls) == self.additional_properties)
+                and (not is_typed_dict(cls) or self.no_copy)
                 and not validators
-                and not (is_typed_dict(cls) and self.no_copy)
                 and all(
                     check_only(f.method)
                     and f.alias == f.name
@@ -437,6 +437,7 @@ def factory(
                     cls,
                     tuple(normal_fields),
                     all_alliases,
+                    is_typed_dict(cls),
                     settings.errors.missing_property,
                     settings.errors.unexpected_property,
                 )
@@ -449,6 +450,7 @@ def factory(
                 additional_field,
                 all_alliases,
                 self.additional_properties,
+                is_typed_dict(cls),
                 tuple(validators),
                 tuple(
                     (f.name, f.default_factory)

apischema/deserialization/methods.py

@@ -1,6 +1,5 @@
 from dataclasses import dataclass, field
 from typing import (
-    TYPE_CHECKING,
     AbstractSet,
     Any,
     Callable,
@@ -29,9 +28,6 @@
 from apischema.validation.mock import ValidatorMock
 from apischema.validation.validators import Validator, validate
 
-if TYPE_CHECKING:
-    pass
-
 
 @dataclass
 class Constraint:
@@ -426,6 +422,7 @@ class SimpleObjectMethod(DeserializationMethod):
     cls: Any  # cython doesn't handle type subclasses properly
     fields: Tuple[Field, ...]
     all_aliases: AbstractSet[str]
+    typed_dict: bool
     missing: str
     unexpected: str
 
@@ -448,7 +445,7 @@ def deserialize(self, data: Any) -> Any:
                 field_errors = set_child_error(
                     field_errors, field.alias, ValidationError([self.missing])
                 )
-        if len(data2) != fields_count:
+        if len(data2) != fields_count and not self.typed_dict:
             for key in data2.keys() - self.all_aliases:
                 field_errors = set_child_error(
                     field_errors, key, ValidationError([self.unexpected])
@@ -489,6 +486,7 @@ class ObjectMethod(DeserializationMethod):
     additional_field: Optional[AdditionalField]
     all_aliases: AbstractSet[str]
     additional_properties: bool
+    typed_dict: bool
     validators: Tuple[Validator, ...]
     init_defaults: Tuple[Tuple[str, Optional[Callable[[], Any]]], ...]
     post_init_modified: AbstractSet[str]
@@ -596,16 +594,24 @@ def deserialize(self, data: Any) -> Any:
                         field_errors = update_children_errors(
                             field_errors, err.children
                         )
-            elif remain and not self.additional_properties:
-                for key in remain:
+            elif remain:
+                if not self.additional_properties:
+                    for key in remain:
+                        field_errors = set_child_error(
+                            field_errors, key, ValidationError([self.unexpected])
+                        )
+                elif self.typed_dict:
+                    for key in remain:
+                        values[key] = data2[key]
+        elif len(data2) != fields_count:
+            if not self.additional_properties:
+                for key in data2.keys() - self.all_aliases:
                     field_errors = set_child_error(
                         field_errors, key, ValidationError([self.unexpected])
                     )
-        elif not self.additional_properties and len(data2) != fields_count:
-            for key in data2.keys() - self.all_aliases:
-                field_errors = set_child_error(
-                    field_errors, key, ValidationError([self.unexpected])
-                )
+            elif self.typed_dict:
+                for key in data2.keys() - self.all_aliases:
+                    values[key] = data2[key]
         if self.validators:
             init = None
             if self.init_defaults:

apischema/objects/fields.py

@@ -81,7 +81,7 @@ def __post_init__(self, default: Any):
         if self.default_factory is MISSING:
             object.__setattr__(self, "default_factory", None)
         if not self.required and self.default_factory is None:
-            if default is MISSING_DEFAULT:
+            if default is MISSING_DEFAULT or default is MISSING:
                 raise ValueError("Missing default for non-required ObjectField")
             object.__setattr__(self, "default_factory", LazyValue(default))
         if self.none_as_undefined and is_union_of(self.type, NoneType):

setup.cfg

@@ -3,7 +3,7 @@ max-line-length = 88
 ignore = E203, E302, E501, W503, E731, E741
 
 [isort]
-profile=black
+profile = black
 
 [coverage:report]
 ;fail_under = 100

tests/conftest.py

@@ -27,7 +27,7 @@ def from_datetime(obj: datetime) -> str:
 
     @deserializer
     def to_date(s: str) -> date:
-        return date.strptime(s, "%Y-%m-%d")
+        return datetime.strptime(s, "%Y-%m-%d").date()
 
     @serializer
     def from_date(obj: date) -> str:

tests/integration/test_typed_dict.py

@@ -1,8 +1,11 @@
+from datetime import date
+
 import pytest
 
 from apischema import ValidationError, deserialize, serialize
 from apischema.json_schema import deserialization_schema, serialization_schema
-from apischema.typing import TypedDict
+from apischema.metadata import flatten
+from apischema.typing import Annotated, TypedDict
 
 
 class TD1(TypedDict, total=False):
@@ -40,3 +43,29 @@ def test_typed_dict():
     with pytest.raises(ValidationError):
         assert deserialize(TD3, {})
     assert serialize(TD1, {"key1": ""}) == {"key1": ""}
+
+
+class SimpleAdditional(TypedDict):
+    key: str
+
+
+class ComplexAdditional(TypedDict):
+    key: date
+
+
+class AggregateAdditional(TypedDict):
+    simple: Annotated[SimpleAdditional, flatten]
+
+
+@pytest.mark.parametrize(
+    "cls", [SimpleAdditional, ComplexAdditional, AggregateAdditional]
+)
+def test_additional_properties(cls):
+    with pytest.raises(ValidationError):
+        deserialize(cls, {"key": "1970-01-01", "additional": 42})
+    assert (
+        deserialize(
+            cls, {"key": "1970-01-01", "additional": 42}, additional_properties=True
+        )["additional"]
+        == 42
+    )