feature/pydantic 1 and 2

RELEASE.md

@@ -0,0 +1,6 @@
+Release type: minor
+
+This release adds support for using both Pydantic v1 and v2, when importing from
+`pydantic.v1`.
+
+This is automatically detected and the correct version is used.

noxfile.py

@@ -107,7 +107,7 @@ def tests_integrations(session: Session, integration: str) -> None:
     session.run("pytest", *COMMON_PYTEST_OPTIONS, "-m", integration)
 
 
-@session(python=PYTHON_VERSIONS, name="Pydantic tests", tags=["tests"])
+@session(python=PYTHON_VERSIONS, name="Pydantic tests", tags=["tests", "pydantic"])
 @nox.parametrize("pydantic", ["1.10", "2.0.3"])
 def test_pydantic(session: Session, pydantic: str) -> None:
     session.run_always("poetry", "install", external=True)

strawberry/experimental/__init__.py

@@ -1,6 +1,6 @@
 try:
     from . import pydantic
-except ImportError:
+except ModuleNotFoundError:
     pass
 else:
     __all__ = ["pydantic"]

strawberry/experimental/pydantic/_compat.py

@@ -1,10 +1,16 @@
 import dataclasses
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type
+from decimal import Decimal
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Type
+from uuid import UUID
 
+import pydantic
 from pydantic import BaseModel
 from pydantic.version import VERSION as PYDANTIC_VERSION
 
+from strawberry.experimental.pydantic.exceptions import UnsupportedTypeError
+
 if TYPE_CHECKING:
     from pydantic.fields import FieldInfo
 
@@ -24,21 +30,101 @@
     allow_none: bool
     has_alias: bool
     description: Optional[str]
+    _missing_type: Any
+    is_v1: bool
 
+    @property
+    def has_default_factory(self) -> bool:
+        return self.default_factory is not self._missing_type
 
-if IS_PYDANTIC_V2:
-    from typing_extensions import get_args, get_origin
+    @property
+    def has_default(self) -> bool:
+        return self.default is not self._missing_type
 
-    from pydantic._internal._typing_extra import is_new_type
-    from pydantic._internal._utils import lenient_issubclass, smart_deepcopy
-    from pydantic_core import PydanticUndefined
 
-    PYDANTIC_MISSING_TYPE = PydanticUndefined
+ATTR_TO_TYPE_MAP = {
+    "NoneStr": Optional[str],
+    "NoneBytes": Optional[bytes],
+    "StrBytes": None,
+    "NoneStrBytes": None,
+    "StrictStr": str,
+    "ConstrainedBytes": bytes,
+    "conbytes": bytes,
+    "ConstrainedStr": str,
+    "constr": str,
+    "EmailStr": str,
+    "PyObject": None,
+    "ConstrainedInt": int,
+    "conint": int,
+    "PositiveInt": int,
+    "NegativeInt": int,
+    "ConstrainedFloat": float,
+    "confloat": float,
+    "PositiveFloat": float,
+    "NegativeFloat": float,
+    "ConstrainedDecimal": Decimal,
+    "condecimal": Decimal,
+    "UUID1": UUID,
+    "UUID3": UUID,
+    "UUID4": UUID,
+    "UUID5": UUID,
+    "FilePath": None,
+    "DirectoryPath": None,
+    "Json": None,
+    "JsonWrapper": None,
+    "SecretStr": str,
+    "SecretBytes": bytes,
+    "StrictBool": bool,
+    "StrictInt": int,
+    "StrictFloat": float,
+    "PaymentCardNumber": None,
+    "ByteSize": None,
+    "AnyUrl": str,
+    "AnyHttpUrl": str,
+    "HttpUrl": str,
+    "PostgresDsn": str,
+    "RedisDsn": str,
+}
+
+ATTR_TO_TYPE_MAP_Pydantic_V2 = {
+    "EmailStr": str,
+    "SecretStr": str,
+    "SecretBytes": bytes,
+    "AnyUrl": str,
+}
+
+ATTR_TO_TYPE_MAP_Pydantic_Core_V2 = {
+    "MultiHostUrl": str,
+}
 
-    def new_type_supertype(type_: Any) -> Any:
-        return type_.__supertype__
 
-    def get_model_fields(model: Type[BaseModel]) -> Dict[str, CompatModelField]:
+def get_fields_map_for_v2() -> Dict[Any, Any]:
+    import pydantic_core
+
+    fields_map = {
+        getattr(pydantic, field_name): type
+        for field_name, type in ATTR_TO_TYPE_MAP_Pydantic_V2.items()
+        if hasattr(pydantic, field_name)
+    }
+    fields_map.update(
+        {
+            getattr(pydantic_core, field_name): type
+            for field_name, type in ATTR_TO_TYPE_MAP_Pydantic_Core_V2.items()
+            if hasattr(pydantic_core, field_name)
+        }
+    )
+
+    return fields_map
+
+
+class PydanticV2Compat:
+    @property
+    def PYDANTIC_MISSING_TYPE(self) -> Any:
+        from pydantic_core import PydanticUndefined
+
+        return PydanticUndefined
+
+    def get_model_fields(self, model: Type[BaseModel]) -> Dict[str, CompatModelField]:
         field_info: dict[str, FieldInfo] = model.model_fields
         new_fields = {}
         # Convert it into CompatModelField
@@ -55,24 +141,34 @@
                 allow_none=False,
                 has_alias=field is not None,
                 description=field.description,
+                _missing_type=self.PYDANTIC_MISSING_TYPE,
+                is_v1=False,
             )
         return new_fields
 
-else:
-    from pydantic.typing import (  # type: ignore[no-redef]
-        get_args,
-        get_origin,
-        is_new_type,
-        new_type_supertype,
-    )
-    from pydantic.utils import (  # type: ignore[no-redef]
-        lenient_issubclass,
-        smart_deepcopy,
-    )
+    @cached_property
+    def fields_map(self) -> Dict[Any, Any]:
+        return get_fields_map_for_v2()
 
-    PYDANTIC_MISSING_TYPE = dataclasses.MISSING  # type: ignore[assignment]
+    def get_basic_type(self, type_: Any) -> Type[Any]:
+        if type_ in self.fields_map:
+            type_ = self.fields_map[type_]
 
-    def get_model_fields(model: Type[BaseModel]) -> Dict[str, CompatModelField]:
+            if type_ is None:
+                raise UnsupportedTypeError()
+
+        if is_new_type(type_):
+            return new_type_supertype(type_)
+
+        return type_
+
+
+class PydanticV1Compat:
+    @property
+    def PYDANTIC_MISSING_TYPE(self) -> Any:
+        return dataclasses.MISSING
+
+    def get_model_fields(self, model: Type[BaseModel]) -> Dict[str, CompatModelField]:
         new_fields = {}
         # Convert it into CompatModelField
         for name, field in model.__fields__.items():  # type: ignore[attr-defined]
@@ -87,17 +183,104 @@
                 allow_none=field.allow_none,
                 has_alias=field.has_alias,
                 description=field.field_info.description,
+                _missing_type=self.PYDANTIC_MISSING_TYPE,
+                is_v1=True,
             )
         return new_fields
 
+    @cached_property
+    def fields_map(self) -> Dict[Any, Any]:
+        if IS_PYDANTIC_V2:
+            return {
+                getattr(pydantic.v1, field_name): type
+                for field_name, type in ATTR_TO_TYPE_MAP.items()
+                if hasattr(pydantic.v1, field_name)
+            }
+
+        return {
+            getattr(pydantic, field_name): type
+            for field_name, type in ATTR_TO_TYPE_MAP.items()
+            if hasattr(pydantic, field_name)
+        }
+
+    def get_basic_type(self, type_: Any) -> Type[Any]:
+        if IS_PYDANTIC_V1:
+            ConstrainedInt = pydantic.ConstrainedInt
+            ConstrainedFloat = pydantic.ConstrainedFloat
+            ConstrainedStr = pydantic.ConstrainedStr
+            ConstrainedList = pydantic.ConstrainedList
+        else:
+            ConstrainedInt = pydantic.v1.ConstrainedInt
+            ConstrainedFloat = pydantic.v1.ConstrainedFloat
+            ConstrainedStr = pydantic.v1.ConstrainedStr
+            ConstrainedList = pydantic.v1.ConstrainedList
+
+        if lenient_issubclass(type_, ConstrainedInt):
+            return int
+        if lenient_issubclass(type_, ConstrainedFloat):
+            return float
+        if lenient_issubclass(type_, ConstrainedStr):
+            return str
+        if lenient_issubclass(type_, ConstrainedList):
+            return List[self.get_basic_type(type_.item_type)]  # type: ignore
+
+        if type_ in self.fields_map:
+            type_ = self.fields_map[type_]
+
+            if type_ is None:
+                raise UnsupportedTypeError()
+
+        if is_new_type(type_):
+            return new_type_supertype(type_)
+
+        return type_
+
+
+class PydanticCompat:
+    def __init__(self, is_v2: bool):
+        if is_v2:
+            self._compat = PydanticV2Compat()
+        else:
+            self._compat = PydanticV1Compat()  # type: ignore[assignment]
+
+    @classmethod
+    def from_model(cls, model: Type[BaseModel]) -> "PydanticCompat":
+        if hasattr(model, "model_fields"):
+            return cls(is_v2=True)
+
+        return cls(is_v2=False)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._compat, name)
+
+
+if IS_PYDANTIC_V2:
+    from typing_extensions import get_args, get_origin
+
+    from pydantic._internal._typing_extra import is_new_type
+    from pydantic._internal._utils import lenient_issubclass, smart_deepcopy
+
+    def new_type_supertype(type_: Any) -> Any:
+        return type_.__supertype__
+else:
+    from pydantic.typing import (  # type: ignore[no-redef]
+        get_args,
+        get_origin,
+        is_new_type,
+        new_type_supertype,
+    )
+    from pydantic.utils import (  # type: ignore[no-redef]
+        lenient_issubclass,
+        smart_deepcopy,
+    )
+
 
 __all__ = [
-    "smart_deepcopy",
+    "PydanticCompat",
+    "is_new_type",
     "lenient_issubclass",
-    "get_args",
     "get_origin",
-    "is_new_type",
+    "get_args",
     "new_type_supertype",
-    "get_model_fields",
-    "PYDANTIC_MISSING_TYPE",
+    "smart_deepcopy",
 ]

strawberry/experimental/pydantic/error_type.py

@@ -19,7 +19,7 @@
 from strawberry.auto import StrawberryAuto
 from strawberry.experimental.pydantic._compat import (
     CompatModelField,
-    get_model_fields,
+    PydanticCompat,
     lenient_issubclass,
 )
 from strawberry.experimental.pydantic.utils import (
@@ -72,7 +72,8 @@
     all_fields: bool = False,
 ) -> Callable[..., Type]:
     def wrap(cls: Type) -> Type:
-        model_fields = get_model_fields(model)
+        compat = PydanticCompat.from_model(model)
+        model_fields = compat.get_model_fields(model)
         fields_set = set(fields) if fields else set()
 
         if fields: