python-introspect 0.1.13__tar.gz → 0.1.14__tar.gz

{python_introspect-0.1.13/src/python_introspect.egg-info → python_introspect-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-introspect
-Version: 0.1.13
+Version: 0.1.14
 Summary: Pure Python introspection toolkit for function signatures, dataclasses, and type hints
 Author-email: Tristan Simas <tristan.simas@mail.mcgill.ca>
 License: MIT

{python_introspect-0.1.13 → python_introspect-0.1.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-introspect"
-version = "0.1.13"
+version = "0.1.14"
 description = "Pure Python introspection toolkit for function signatures, dataclasses, and type hints"
 readme = "README.md"
 requires-python = ">=3.10"

{python_introspect-0.1.13 → python_introspect-0.1.14}/src/python_introspect/dataclass_projection.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Mapping, Sequence
 from dataclasses import MISSING, fields, is_dataclass
 from enum import Enum
 from pathlib import Path
@@ -19,7 +19,6 @@ from typing import (
 from .annotation_types import is_union_type
 from .validation import validate_annotated_dataclass, validate_annotation_value
 
-
 DataclassT = TypeVar("DataclassT")
 
 
@@ -31,8 +30,7 @@ def dataclass_from_mapping(
 
     if not isinstance(target_type, type) or not is_dataclass(target_type):
         raise TypeError(
-            "dataclass_from_mapping requires a dataclass type; "
-            f"got {target_type!r}."
+            "dataclass_from_mapping requires a dataclass type; " f"got {target_type!r}."
         )
     if not isinstance(values, Mapping):
         raise TypeError("dataclass_from_mapping requires a mapping.")
@@ -58,7 +56,10 @@ def dataclass_from_mapping(
     missing: list[str] = []
     for declared_field in declared_fields:
         if declared_field.name not in values:
-            if declared_field.default is MISSING and declared_field.default_factory is MISSING:
+            if (
+                declared_field.default is MISSING
+                and declared_field.default_factory is MISSING
+            ):
                 missing.append(declared_field.name)
             continue
         annotation = annotations.get(declared_field.name, declared_field.type)
@@ -154,9 +155,7 @@ def _mapping_value_for_annotation(
         if len(successes) == 1:
             return successes[0]
         exact_matches = tuple(
-            converted
-            for converted in successes
-            if type(converted) is type(value)
+            converted for converted in successes if type(converted) is type(value)
         )
         if len(exact_matches) == 1:
             return exact_matches[0]
@@ -164,9 +163,7 @@ def _mapping_value_for_annotation(
             raise TypeError(
                 f"{path} ambiguously matches multiple members of {annotation!r}."
             )
-        value_errors = tuple(
-            error for error in errors if isinstance(error, ValueError)
-        )
+        value_errors = tuple(error for error in errors if isinstance(error, ValueError))
         if len(value_errors) == 1:
             raise value_errors[0]
         if value_errors:
@@ -197,7 +194,9 @@ def _mapping_value_for_annotation(
                 for index, item in enumerate(value)
             )
         if member_types and len(value) != len(member_types):
-            raise ValueError(f"{path} must contain {len(member_types)} item(s); got {len(value)}.")
+            raise ValueError(
+                f"{path} must contain {len(member_types)} item(s); got {len(value)}."
+            )
         return tuple(
             _mapping_value_for_annotation(
                 member_type,
@@ -206,13 +205,19 @@ def _mapping_value_for_annotation(
             )
             for index, (member_type, item) in enumerate(zip(member_types, value))
         )
-    if origin is list:
-        if not isinstance(value, list):
+    if origin in {list, Sequence}:
+        if (origin is list and not isinstance(value, list)) or (
+            origin is Sequence
+            and (
+                not isinstance(value, Sequence)
+                or isinstance(value, (str, bytes, bytearray))
+            )
+        ):
             raise TypeError(f"{path} must be an array.")
         member_types = get_args(annotation)
         if not member_types:
-            return list(value)
-        return [
+            return list(value) if origin is list else tuple(value)
+        converted = [
             _mapping_value_for_annotation(
                 member_types[0],
                 item,
@@ -220,6 +225,7 @@ def _mapping_value_for_annotation(
             )
             for index, item in enumerate(value)
         ]
+        return converted if origin is list else tuple(converted)
     if origin in {dict, Mapping}:
         if not isinstance(value, Mapping):
             raise TypeError(f"{path} must be an object.")
@@ -250,7 +256,9 @@ def _mapping_value_for_annotation(
             return annotation(value)
         except ValueError as error:
             choices = tuple(member.value for member in annotation)
-            raise ValueError(f"{path} must be one of {choices!r}; got {value!r}.") from error
+            raise ValueError(
+                f"{path} must be one of {choices!r}; got {value!r}."
+            ) from error
     if isinstance(annotation, type) and is_dataclass(annotation):
         if isinstance(value, annotation):
             return value

{python_introspect-0.1.13 → python_introspect-0.1.14/src/python_introspect.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-introspect
-Version: 0.1.13
+Version: 0.1.14
 Summary: Pure Python introspection toolkit for function signatures, dataclasses, and type hints
 Author-email: Tristan Simas <tristan.simas@mail.mcgill.ca>
 License: MIT

{python_introspect-0.1.13 → python_introspect-0.1.14}/tests/test_dataclass_projection.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum
+from collections.abc import Sequence
 
 import pytest
 
@@ -36,6 +37,59 @@ class UntypedTupleEnvelope:
     values: tuple
 
 
+@dataclass(frozen=True)
+class RecursiveSequenceNode:
+    name: str
+    children: Sequence["RecursiveSequenceNode"] = ()
+
+
+@dataclass(frozen=True)
+class SequenceEnvelope:
+    nodes: Sequence[RecursiveSequenceNode]
+
+
+@pytest.mark.parametrize("container", (list, tuple))
+def test_dataclass_mapping_recurses_from_abstract_sequence_annotations(container):
+    result = dataclass_from_mapping(
+        SequenceEnvelope,
+        {
+            "nodes": container([{"name": "parent", "children": [{"name": "child"}]}]),
+        },
+    )
+    assert result == SequenceEnvelope(
+        (RecursiveSequenceNode("parent", (RecursiveSequenceNode("child"),)),)
+    )
+
+
+@pytest.mark.parametrize(
+    "value", ("text", b"bytes", bytearray(b"bytes"), {"name": "mapping"}, 7)
+)
+def test_dataclass_mapping_sequence_rejects_non_array_values(value):
+    with pytest.raises(TypeError, match="must be an array"):
+        dataclass_from_mapping(SequenceEnvelope, {"nodes": value})
+
+
+def test_dataclass_mapping_recursive_sequence_rejects_unknown_fields_and_wrong_elements():
+    with pytest.raises(ValueError, match="undeclared.*extra"):
+        dataclass_from_mapping(
+            SequenceEnvelope,
+            {
+                "nodes": [
+                    {"name": "parent", "children": [{"name": "child", "extra": 1}]}
+                ]
+            },
+        )
+    with pytest.raises(TypeError, match="must be an object"):
+        dataclass_from_mapping(SequenceEnvelope, {"nodes": [42]})
+
+
+def test_dataclass_mapping_abstract_sequence_preserves_typed_members():
+    node = RecursiveSequenceNode("typed")
+    assert dataclass_from_mapping(
+        SequenceEnvelope, {"nodes": [node]}
+    ) == SequenceEnvelope((node,))
+
+
 def test_dataclass_mapping_uses_nested_types_as_the_schema() -> None:
     result = dataclass_from_mapping(
         Envelope,