Merge pull request #22 from DanCardin/dc/type-lens

feat: Adopt type-lens.

Author: DanCardin

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-jame: Github Release/Publish PyPi
+name: Github Release/Publish PyPi
 
 on:
   push:

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.6
+
+### 0.6.0
+
+* feat: Adopt type-lens library to better handle 3.12-style annotations which
+  were incorrectly identified by typing_inspect
+- fix: Ignore `ClassVar` annotated fields
+
 ## 0.5
 
 ### 0.5.2

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dataclass-settings"
-version = "0.5.3"
+version = "0.6.0"
 description = "Declarative dataclass settings."
 
 urls = { repository = "https://github.com/dancardin/dataclass-settings" }
@@ -14,7 +14,7 @@ requires-python = ">=3.8,<4"
 
 dependencies = [
   "typing-extensions >= 4.7.1",
-  "typing-inspect",
+  "type-lens >= 0.2.5",
 ]
 
 [project.optional-dependencies]

src/dataclass_settings/base.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Sequence, TypeVar
+from typing import Any, ClassVar, Sequence, TypeVar
 
 from dataclass_settings import class_inspect
 from dataclass_settings.context import Context
@@ -80,6 +80,9 @@ def collect(
 ) -> dict[str, Any] | None:
     result = {}
     for field in class_inspect.fields(source_cls):
+        if field.type_view.fallback_origin is ClassVar:
+            continue
+
         field_context = context.enter(field.name)
 
         value: str | dict[str, Any] | None = None

src/dataclass_settings/class_inspect.py

@@ -2,10 +2,10 @@
 
 import dataclasses
 from enum import Enum
-from typing import Any, Callable, Tuple, Type
+from typing import Any, Callable, Sequence, Type
 
-import typing_inspect
-from typing_extensions import Annotated, Self, get_args, get_origin, get_type_hints
+from type_lens import TypeView
+from typing_extensions import Self, get_type_hints
 
 from dataclass_settings.loaders import Loader
 
@@ -22,7 +22,7 @@ def detect(cls: type) -> bool:
 @dataclasses.dataclass
 class Field:
     name: str
-    type: type
+    type_view: TypeView
     annotations: tuple[Any, ...]
     mapper: Callable[..., Any] | None = None
 
@@ -32,10 +32,10 @@ def get_loaders(self, loaders: tuple[Type[Loader], ...]):
                 yield m
 
     def get_nested_type(self) -> Type | None:
-        if typing_inspect.is_union_type(self.type):
-            args = typing_inspect.get_args(self.type)
+        if self.type_view.is_union:
+            args: Sequence[type] = self.type_view.args
         else:
-            args = [self.type]
+            args = [self.type_view.annotation]
 
         unsupported_args = []
         try:
@@ -61,66 +61,57 @@ def map_value(self, value: str | dict[str, Any]):
 
         return self.mapper(value)
 
+    @classmethod
+    def from_type_view(cls, name: str, type_view: TypeView) -> Self:
+        stripped = type_view.strip_optional()
+        return cls(
+            name=name,
+            type_view=stripped,
+            annotations=type_view.metadata,
+            mapper=stripped.annotation,
+        )
+
 
 @dataclasses.dataclass
 class DataclassField(Field):
     @classmethod
-    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, TypeView]) -> list[Self]:
         fields = []
         for f in value.__dataclass_fields__.values():  # type: ignore
-            annotation = get_type(type_hints[f.name])
-
-            annotation, args = get_annotation_args(annotation)
-
-            field = cls(
-                name=f.name,
-                type=annotation,
-                annotations=args,
-                mapper=annotation,
-            )
+            type_view = type_hints[f.name]
+            field = cls.from_type_view(f.name, type_view)
             fields.append(field)
         return fields
 
 
 @dataclasses.dataclass
 class AttrsField(Field):
     @classmethod
-    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, TypeView]) -> list[Self]:
         fields = []
 
         for f in value.__attrs_attrs__:  # type: ignore
-            annotation = get_type(type_hints[f.name])
-            annotation, args = get_annotation_args(annotation)
-
-            field = cls(
-                name=f.name,
-                type=annotation,
-                annotations=args,
-                mapper=annotation,
-            )
+            type_view = type_hints[f.name]
+            field = cls.from_type_view(f.name, type_view)
             fields.append(field)
         return fields
 
 
 @dataclasses.dataclass
 class MsgspecField(Field):
     @classmethod
-    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, TypeView]) -> list[Self]:
         import msgspec
 
         fields = []
         for f in msgspec.structs.fields(value):
-            annotation = get_type(type_hints[f.name])
-            annotation, args = get_annotation_args(annotation)
-
-            mapper = cls.splat_mapper(annotation) if detect(annotation) else annotation
+            type_view = type_hints[f.name]
+            field = cls.from_type_view(f.name, type_view)
 
-            field = cls(
-                name=f.name,
-                type=annotation,
-                annotations=args,
-                mapper=mapper,
-            )
+            if detect(field.type_view.annotation):
+                field = dataclasses.replace(
+                    field, mapper=cls.splat_mapper(type_view.annotation)
+                )
             fields.append(field)
         return fields
 
@@ -137,59 +128,45 @@ def convert(**value):
 @dataclasses.dataclass
 class PydanticV1Field(Field):
     @classmethod
-    def collect(cls, value, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value, type_hints: dict[str, TypeView]) -> list[Self]:
         fields = []
         for name, f in value.__fields__.items():
-            annotation = get_type(type_hints[name])
-            annotation, args = get_annotation_args(annotation)
-
-            mapper = annotation if detect(annotation) else None
+            type_view = type_hints[f.name]
+            field = cls.from_type_view(name, type_view)
 
-            field = cls(
-                name=name,
-                type=annotation,
-                annotations=args,
-                mapper=mapper,
-            )
+            if not detect(field.type_view.annotation):
+                field = dataclasses.replace(field, mapper=None)
             fields.append(field)
         return fields
 
 
 @dataclasses.dataclass
 class PydanticV2Field(Field):
     @classmethod
-    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, TypeView]) -> list[Self]:
         fields = []
         for name, f in value.model_fields.items():  # type: ignore
-            annotation = get_type(type_hints[name])
-            mapper = annotation if detect(annotation) else None
-
-            field = cls(
-                name=name,
-                type=annotation,
-                annotations=tuple(f.metadata),
-                mapper=mapper,
-            )
+            type_view = type_hints[f.name]
+            field = cls.from_type_view(name, type_view)
+
+            if not detect(field.type_view.annotation):
+                field = dataclasses.replace(field, mapper=None)
             fields.append(field)
         return fields
 
 
 @dataclasses.dataclass
 class PydanticV2DataclassField(Field):
     @classmethod
-    def collect(cls, value: type, type_hints: dict[str, Type]) -> list[Self]:
+    def collect(cls, value: type, type_hints: dict[str, TypeView]) -> list[Self]:
         fields = []
 
         for name, f in value.__pydantic_fields__.items():  # type: ignore
-            annotation = get_type(type_hints[name])
-            mapper = annotation if detect(annotation) else None
-
-            field = cls(
-                name=name,
-                type=annotation,
-                annotations=tuple(f.metadata),
-                mapper=mapper,
-            )
+            type_view = type_hints[name]
+            field = cls.from_type_view(name, type_view)
+
+            if not detect(field.type_view.annotation):
+                field = dataclasses.replace(field, mapper=None)
             fields.append(field)
         return fields
 
@@ -202,7 +179,9 @@ def fields(cls: type):
             "Must be one of: dataclass, pydantic, or attrs class."
         )
 
-    type_hints = get_type_hints(cls, include_extras=True)
+    type_hints = {
+        k: TypeView(v) for k, v in get_type_hints(cls, include_extras=True).items()
+    }
     return class_type.value.collect(cls, type_hints)
 
 
@@ -246,19 +225,3 @@ def from_cls(cls, obj: type) -> ClassTypes | None:
             return cls.attrs
 
         return None
-
-
-def get_type(value):
-    if typing_inspect.is_optional_type(value):
-        return get_args(value)[0]
-    return value
-
-
-def get_annotation_args(annotation) -> Tuple[Type, Tuple[Any, ...]]:
-    args: Tuple[Any, ...] = ()
-    if get_origin(annotation) is Annotated:
-        args = get_args(annotation)
-        annotation, *_args = args
-        args = tuple(_args)
-
-    return annotation, args

tests/test_312_annotatations.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+
+import pytest
+from attr import dataclass as attr_dataclass
+from msgspec import Struct
+from pydantic import BaseModel, ValidationError
+from pydantic.dataclasses import dataclass as pydantic_dataclass
+from typing_extensions import Annotated
+
+from dataclass_settings import Env, load_settings
+from tests.utils import env_setup
+
+if sys.version_info >= (3, 10):
+
+    @attr_dataclass
+    class Attr:
+        foo: Annotated[int | None, Env("FOO")] = None
+
+    @dataclass
+    class Dataclass:
+        foo: Annotated[int | None, Env("FOO")] = None
+
+    class Msgspec(Struct):
+        foo: Annotated[int | None, Env("FOO")] = None
+
+    class Pydantic(BaseModel):
+        foo: Annotated[int | None, Env("FOO")] = None
+
+    @pydantic_dataclass
+    class PDataclass:
+        foo: Annotated[int | None, Env("FOO")] = None
+
+    @pytest.mark.parametrize(
+        "config_class, exc_class",
+        [
+            (Attr, TypeError),
+            (Dataclass, TypeError),
+            (Msgspec, TypeError),
+            (Pydantic, ValidationError),
+            (PDataclass, ValidationError),
+        ],
+    )
+    def test_handles_312_syntax(config_class, exc_class):
+        with env_setup({}):
+            result = load_settings(config_class)
+        assert result.foo is None
+
+        with env_setup({"FOO": "5"}):
+            result = load_settings(config_class)
+        assert result.foo == 5

tests/test_classvar.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import ClassVar, Union
+
+from typing_extensions import Annotated
+
+from dataclass_settings import Env, load_settings
+from tests.utils import env_setup
+
+
+@dataclass
+class Dataclass:
+    foo: ClassVar[int] = 5
+    baz: Annotated[Union[int, None], Env("FOO")] = None
+
+
+def test_ignores_classvar():
+    with env_setup({}):
+        result = load_settings(Dataclass)
+    assert result.foo == 5
+    assert result.baz is None
+
+    with env_setup({"FOO": "5"}):
+        result = load_settings(Dataclass)
+    assert result.foo == 5
+    assert result.baz == 5