Fix for pydantic 1.X (#24)

* Use pydantic.v1 trick

* style(pre-commit.ci): auto fixes [...]

* Remove henious tuple calls

* Fix merge conflict

* style(pre-commit.ci): auto fixes [...]

* Type checking

* Add explicit __mro__ check

* Fix type annotations

* Reformat

* Mypy labours

* fix typing

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Co-authored-by: Talley Lambert <talley.lambert@gmail.com>

Author: 3 people

src/fieldz/adapters/_pydantic.py

@@ -3,7 +3,7 @@
 import dataclasses
 import re
 import sys
-from typing import TYPE_CHECKING, Any, Iterator, overload
+from typing import TYPE_CHECKING, Any, Iterator, cast, overload
 
 from fieldz._types import (
     Constraints,
@@ -16,6 +16,7 @@
 if TYPE_CHECKING:
     import pydantic
     import pydantic.fields
+    from pydantic.v1 import BaseModel as PydanticV1BaseModel
     from typing_extensions import TypeGuard
 
 
@@ -30,9 +31,12 @@ def is_pydantic_model(obj: object) -> TypeGuard[pydantic.BaseModel]: ...
 def is_pydantic_model(obj: Any) -> bool:
     """Return True if obj is a pydantic.BaseModel subclass or instance."""
     pydantic = sys.modules.get("pydantic", None)
+    pydantic_v1 = sys.modules.get("pydantic.v1", None)
     cls = obj if isinstance(obj, type) else type(obj)
     if pydantic is not None and issubclass(cls, pydantic.BaseModel):
         return True
+    elif pydantic_v1 is not None and issubclass(cls, pydantic_v1.BaseModel):
+        return True
     elif hasattr(cls, "__pydantic_model__") or hasattr(cls, "__pydantic_fields__"):
         return True
     return False
@@ -66,11 +70,14 @@ def replace(obj: pydantic.BaseModel, /, **changes: Any) -> Any:
     return obj.copy(update=changes)
 
 
-def _fields_v1(obj: pydantic.BaseModel | type[pydantic.BaseModel]) -> Iterator[Field]:
-    from pydantic.fields import Undefined  # type: ignore
+def _fields_v1(obj: PydanticV1BaseModel | type[PydanticV1BaseModel]) -> Iterator[Field]:
+    try:
+        from pydantic.v1.fields import Undefined
+    except ImportError:
+        from pydantic.fields import Undefined  # type: ignore
 
-    annotations = getattr(obj, "__annotations__", {})
-    for name, modelfield in obj.__fields__.items():  # type: ignore
+    annotations = {key: field.annotation for key, field in obj.__fields__.items()}
+    for name, modelfield in obj.__fields__.items():
         factory = (
             modelfield.default_factory
             if callable(modelfield.default_factory)
@@ -83,7 +90,7 @@ def _fields_v1(obj: pydantic.BaseModel | type[pydantic.BaseModel]) -> Iterator[F
             else modelfield.default
         )
         # backport from pydantic2
-        _extra_dict = modelfield.field_info.extra.copy()  # type: ignore
+        _extra_dict = modelfield.field_info.extra.copy()
         if "json_schema_extra" in _extra_dict:
             _extra_dict.update(_extra_dict.pop("json_schema_extra"))
 
@@ -93,14 +100,16 @@ def _fields_v1(obj: pydantic.BaseModel | type[pydantic.BaseModel]) -> Iterator[F
             default=default,
             default_factory=(factory if callable(factory) else Field.MISSING),
             native_field=modelfield,
-            description=modelfield.field_info.description,  # type: ignore
+            description=modelfield.field_info.description,
             metadata=_extra_dict,
             constraints=_constraints_v1(modelfield),
         )
 
 
 def _constraints_v1(modelfield: Any) -> Constraints | None:
     kwargs = {}
+    if not hasattr(modelfield.type_, "__mro__"):
+        return None
     # check if the type is a pydantic constrained type
     for subt in modelfield.type_.__mro__:
         if (subt.__module__ or "").startswith("pydantic.types"):
@@ -163,11 +172,18 @@ def _fields_v2(obj: pydantic.BaseModel | type[pydantic.BaseModel]) -> Iterator[F
         )
 
 
-def fields(obj: pydantic.BaseModel | type[pydantic.BaseModel]) -> tuple[Field, ...]:
+def fields(
+    obj: pydantic.BaseModel
+    | PydanticV1BaseModel
+    | type[pydantic.BaseModel]
+    | type[PydanticV1BaseModel],
+) -> tuple[Field, ...]:
     if hasattr(obj, "model_fields") or hasattr(obj, "__pydantic_fields__"):
+        obj = cast("pydantic.BaseModel | type[pydantic.BaseModel]", obj)
         return tuple(_fields_v2(obj))
     if hasattr(obj, "__pydantic_model__"):
         obj = obj.__pydantic_model__  # v1 dataclass
+    obj = cast("PydanticV1BaseModel | type[PydanticV1BaseModel]", obj)
     return tuple(_fields_v1(obj))
 
 

tests/test_fieldz.py

@@ -1,5 +1,5 @@
 import dataclasses
-from typing import Callable, List, NamedTuple, Optional, TypedDict
+from typing import Any, Callable, List, NamedTuple, Optional, TypedDict
 
 import pytest
 
@@ -15,6 +15,7 @@ class Model:
         c: float = 0.0
         d: bool = False
         e: List[int] = dataclasses.field(default_factory=list)
+        f: Any = ()
 
     return Model
 
@@ -26,6 +27,35 @@ class Model(NamedTuple):
         c: float = 0.0
         d: bool = False
         e: List[int] = []  # noqa
+        f: Any = ()
+
+    return Model
+
+
+def _pydantic_v1_model_str() -> type:
+    from pydantic.v1 import BaseModel, Field
+
+    class Model(BaseModel):
+        a: "int" = 0
+        b: "Optional[str]" = None
+        c: "float" = 0.0
+        d: "bool" = False
+        e: "List[int]" = Field(default_factory=list)
+        f: "Any" = ()
+
+    return Model
+
+
+def _pydantic_v1_model() -> type:
+    from pydantic.v1 import BaseModel, Field
+
+    class Model(BaseModel):
+        a: int = 0
+        b: Optional[str] = None
+        c: float = 0.0
+        d: bool = False
+        e: List[int] = Field(default_factory=list)
+        f: Any = ()
 
     return Model
 
@@ -39,6 +69,7 @@ class Model(BaseModel):
         c: float = 0.0
         d: bool = False
         e: List[int] = Field(default_factory=list)
+        f: Any = ()
 
     return Model
 
@@ -53,6 +84,7 @@ class Model:
         c: float = 0.0
         d: bool = False
         e: List[int] = dataclasses.field(default_factory=list)
+        f: Any = ()
 
     return Model
 
@@ -67,6 +99,7 @@ class Model(SQLModel):
         c: float = 0.0
         d: bool = False
         e: List[int] = Field(default_factory=list)
+        f: Any = ()
 
     return Model
 
@@ -81,6 +114,7 @@ class Model:
         c: float = 0.0
         d: bool = False
         e: List[int] = attr.field(default=attr.Factory(list))
+        f: Any = ()
 
     return Model
 
@@ -94,6 +128,7 @@ class Model(msgspec.Struct):
         c: float = 0.0
         d: bool = False
         e: List[int] = msgspec.field(default_factory=list)
+        f: Any = ()
 
     return Model
 
@@ -108,6 +143,7 @@ class Model:
         c: float = 0.0
         d: bool = False
         e: List[int] = []  # noqa
+        f: Any = ()
 
     return Model
 
@@ -121,6 +157,7 @@ class Model(models.Model):
         c: float = models.FloatField(default=0.0)
         d: bool = models.BooleanField(default=False)
         e: List[int] = models.JSONField(default=list)
+        f: Any = ()
 
     return Model
 
@@ -132,6 +169,8 @@ class Model(models.Model):
         _named_tuple,
         _dataclassy_model,
         _pydantic_model,
+        _pydantic_v1_model,
+        _pydantic_v1_model_str,
         _attrs_model,
         _msgspec_model,
         _sqlmodel,
@@ -142,30 +181,39 @@ class Model(models.Model):
 def test_adapters(builder: Callable) -> None:
     model = builder()
     obj = model()
-    assert asdict(obj) == {"a": 0, "b": None, "c": 0.0, "d": False, "e": []}
-    assert astuple(obj) == (0, None, 0.0, False, [])
+    assert asdict(obj) == {"a": 0, "b": None, "c": 0.0, "d": False, "e": [], "f": ()}
+    assert astuple(obj) == (0, None, 0.0, False, [], ())
     fields_ = fields(obj)
-    assert [f.name for f in fields_] == ["a", "b", "c", "d", "e"]
-    assert [f.type for f in fields_] == [int, Optional[str], float, bool, List[int]]
-    assert [f.frozen for f in fields_] == [False] * 5
+    assert [f.name for f in fields_] == ["a", "b", "c", "d", "e", "f"]
+    assert [f.type for f in fields_] == [
+        int,
+        Optional[str],
+        float,
+        bool,
+        List[int],
+        Any,
+    ]
+    assert [f.frozen for f in fields_] == [False] * 6
     if is_named_tuple(obj):
-        assert [f.default for f in fields_] == [0, None, 0.0, False, []]
+        assert [f.default for f in fields_] == [0, None, 0.0, False, [], ()]
     else:
         # namedtuples don't have default_factory
-        assert [f.default for f in fields_] == [
-            0,
-            None,
-            0.0,
-            False,
-            Field.MISSING,
-        ]
+        assert [f.default for f in fields_] == [0, None, 0.0, False, Field.MISSING, ()]
         assert [f.default_factory for f in fields_] == [
             *[Field.MISSING] * 4,
             list,
+            Field.MISSING,
         ]
 
-    obj2 = replace(obj, a=1, b="b2", c=1.0, d=True, e=[1, 2, 3])
-    assert asdict(obj2) == {"a": 1, "b": "b2", "c": 1.0, "d": True, "e": [1, 2, 3]}
+    obj2 = replace(obj, a=1, b="b2", c=1.0, d=True, e=[1, 2, 3], f={})
+    assert asdict(obj2) == {
+        "a": 1,
+        "b": "b2",
+        "c": 1.0,
+        "d": True,
+        "e": [1, 2, 3],
+        "f": {},
+    }
 
     p = params(obj)
     assert p.eq is True