Pydantic v2 support

noxfile.py

@@ -106,7 +106,7 @@ def tests_integrations(session: Session, integration: str) -> None:
 
 @session(python=["3.11"], name="Pydantic tests", tags=["tests"])
 # TODO: add pydantic 2.0 here :)
-@nox.parametrize("pydantic", ["1.10"])
+@nox.parametrize("pydantic", ["1.10", "2.0.3"])
 def test_pydantic(session: Session, pydantic: str) -> None:
     session.run_always("poetry", "install", external=True)
 

pyproject.toml

@@ -167,6 +167,8 @@ markers = [
     "sanic",
     "starlette",
     "starlite",
+    "skip_on_",
+    "pydantic_v1"
 ]
 asyncio_mode = "auto"
 filterwarnings = [

strawberry/experimental/__init__.py

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

strawberry/experimental/pydantic/error_type.py

@@ -3,7 +3,6 @@
 import dataclasses
 import warnings
 from typing import (
-    TYPE_CHECKING,
     Any,
     Callable,
     List,
@@ -16,25 +15,26 @@
 )
 
 from pydantic import BaseModel
-from pydantic.utils import lenient_issubclass
 
 from strawberry.auto import StrawberryAuto
 from strawberry.experimental.pydantic.utils import (
     get_private_fields,
     get_strawberry_type_from_model,
     normalize_type,
 )
+from strawberry.experimental.pydantic.v2_compat import (
+    CompatModelField,
+    get_model_fields,
+    lenient_issubclass,
+)
 from strawberry.object_type import _process_type, _wrap_dataclass
 from strawberry.types.type_resolver import _get_fields
 from strawberry.utils.typing import get_list_annotation, is_list
 
 from .exceptions import MissingFieldsListError
 
-if TYPE_CHECKING:
-    from pydantic.fields import ModelField
-
 
-def get_type_for_field(field: ModelField) -> Union[Any, Type[None], Type[List]]:
+def get_type_for_field(field: CompatModelField) -> Union[Any, Type[None], Type[List]]:
     type_ = field.outer_type_
     type_ = normalize_type(type_)
     return field_type_to_type(type_)
@@ -72,7 +72,7 @@ def error_type(
     all_fields: bool = False,
 ) -> Callable[..., Type]:
     def wrap(cls: Type) -> Type:
-        model_fields = model.__fields__
+        model_fields = get_model_fields(model)
         fields_set = set(fields) if fields else set()
 
         if fields:

strawberry/experimental/pydantic/fields.py

@@ -1,20 +1,27 @@
 import builtins
 from decimal import Decimal
-from typing import Any, List, Optional, Type
+from typing import Any, List, Optional, Type, Union
 from uuid import UUID
 
 import pydantic
 from pydantic import BaseModel
-from pydantic.typing import get_args, get_origin, is_new_type, new_type_supertype
-from pydantic.utils import lenient_issubclass
 
 from strawberry.experimental.pydantic.exceptions import (
     UnregisteredTypeException,
     UnsupportedTypeError,
 )
+from strawberry.experimental.pydantic.v2_compat import (
+    IS_PYDANTIC_V2,
+    get_args,
+    get_origin,
+    is_new_type,
+    lenient_issubclass,
+    new_type_supertype,
+)
 from strawberry.types.types import StrawberryObjectDefinition
 
 try:
+    from types import UnionType as TypingUnionType
     from typing import GenericAlias as TypingGenericAlias  # type: ignore
 except ImportError:
     import sys
@@ -25,6 +32,10 @@
         TypingGenericAlias = ()
     else:
         raise
+    if sys.version_info < (3, 10):
+        TypingUnionType = ()
+    else:
+        raise
 
 ATTR_TO_TYPE_MAP = {
     "NoneStr": Optional[str],
@@ -70,23 +81,31 @@
     "RedisDsn": str,
 }
 
-
-FIELDS_MAP = {
-    getattr(pydantic, field_name): type
-    for field_name, type in ATTR_TO_TYPE_MAP.items()
-    if hasattr(pydantic, field_name)
-}
+"""TODO:
+Most of these fields are not supported by pydantic V2
+"""
+FIELDS_MAP = (
+    {
+        getattr(pydantic, field_name): type
+        for field_name, type in ATTR_TO_TYPE_MAP.items()
+        if hasattr(pydantic, field_name)
+    }
+    if not IS_PYDANTIC_V2
+    else {}
+)
 
 
 def get_basic_type(type_: Any) -> Type[Any]:
-    if lenient_issubclass(type_, pydantic.ConstrainedInt):
-        return int
-    if lenient_issubclass(type_, pydantic.ConstrainedFloat):
-        return float
-    if lenient_issubclass(type_, pydantic.ConstrainedStr):
-        return str
-    if lenient_issubclass(type_, pydantic.ConstrainedList):
-        return List[get_basic_type(type_.item_type)]  # type: ignore
+    if not IS_PYDANTIC_V2:
+        # only pydantic v1 has these
+        if lenient_issubclass(type_, pydantic.ConstrainedInt):
+            return int
+        if lenient_issubclass(type_, pydantic.ConstrainedFloat):
+            return float
+        if lenient_issubclass(type_, pydantic.ConstrainedStr):
+            return str
+        if lenient_issubclass(type_, pydantic.ConstrainedList):
+            return List[get_basic_type(type_.item_type)]  # type: ignore
 
     if type_ in FIELDS_MAP:
         type_ = FIELDS_MAP.get(type_)
@@ -125,7 +144,8 @@ def replace_types_recursively(type_: Any, is_input: bool) -> Any:
 
     if isinstance(replaced_type, TypingGenericAlias):
         return TypingGenericAlias(origin, converted)
-
+    if isinstance(replaced_type, TypingUnionType):
+        return Union[converted]
     replaced_type = replaced_type.copy_with(converted)
 
     if isinstance(replaced_type, StrawberryObjectDefinition):

strawberry/experimental/pydantic/object_type.py

@@ -30,28 +30,34 @@
     get_default_factory_for_field,
     get_private_fields,
 )
+from strawberry.experimental.pydantic.v2_compat import (
+    IS_PYDANTIC_V2,
+    CompatModelField,
+    get_model_fields,
+)
 from strawberry.field import StrawberryField
 from strawberry.object_type import _process_type, _wrap_dataclass
 from strawberry.types.type_resolver import _get_fields
 from strawberry.utils.dataclasses import add_custom_init_fn
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
-    from pydantic.fields import ModelField
 
 
-def get_type_for_field(field: ModelField, is_input: bool):  # noqa: ANN201
+def get_type_for_field(field: CompatModelField, is_input: bool):  # noqa: ANN201
     outer_type = field.outer_type_
     replaced_type = replace_types_recursively(outer_type, is_input)
-    should_add_optional: bool = field.allow_none
-    if should_add_optional:
-        return Optional[replaced_type]
-    else:
-        return replaced_type
+    if not IS_PYDANTIC_V2:
+        # only pydantic v1 has this Optional logic
+        should_add_optional: bool = field.allow_none
+        if should_add_optional:
+            return Optional[replaced_type]
+
+    return replaced_type
 
 
 def _build_dataclass_creation_fields(
-    field: ModelField,
+    field: CompatModelField,
     is_input: bool,
     existing_fields: Dict[str, StrawberryField],
     auto_fields_set: Set[str],
@@ -85,7 +91,7 @@ def _build_dataclass_creation_fields(
             default=dataclasses.MISSING,
             default_factory=get_default_factory_for_field(field),
             type_annotation=StrawberryAnnotation.from_annotation(field_type),
-            description=field.field_info.description,
+            description=field.description,
             deprecation_reason=(
                 existing_field.deprecation_reason if existing_field else None
             ),
@@ -123,7 +129,7 @@ def type(
     use_pydantic_alias: bool = True,
 ) -> Callable[..., Type[StrawberryTypeFromPydantic[PydanticModel]]]:
     def wrap(cls: Any) -> Type[StrawberryTypeFromPydantic[PydanticModel]]:
-        model_fields = model.__fields__
+        model_fields = get_model_fields(model)
         original_fields_set = set(fields) if fields else set()
 
         if fields:

strawberry/experimental/pydantic/utils.py

@@ -14,13 +14,17 @@
     cast,
 )
 
-from pydantic.utils import smart_deepcopy
-
 from strawberry.experimental.pydantic.exceptions import (
     AutoFieldsNotInBaseModelError,
     BothDefaultAndDefaultFactoryDefinedError,
     UnregisteredTypeException,
 )
+from strawberry.experimental.pydantic.v2_compat import (
+    PYDANTIC_MISSING_TYPE,
+    CompatModelField,
+    get_model_fields,
+    smart_deepcopy,
+)
 from strawberry.private import is_private
 from strawberry.unset import UNSET
 from strawberry.utils.typing import (
@@ -32,7 +36,6 @@
 
 if TYPE_CHECKING:
     from pydantic import BaseModel
-    from pydantic.fields import ModelField
     from pydantic.typing import NoArgAnyCallable
 
 
@@ -70,7 +73,7 @@ def to_tuple(self) -> Tuple[str, Type, dataclasses.Field]:
 
 
 def get_default_factory_for_field(
-    field: ModelField,
+    field: CompatModelField,
 ) -> Union[NoArgAnyCallable, dataclasses._MISSING_TYPE]:
     """
     Gets the default factory for a pydantic field.
@@ -83,10 +86,10 @@ def get_default_factory_for_field(
     # replace dataclasses.MISSING with our own UNSET to make comparisons easier
     default_factory = (
         field.default_factory
-        if field.default_factory is not dataclasses.MISSING
+        if field.default_factory is not PYDANTIC_MISSING_TYPE
         else UNSET
     )
-    default = field.default if field.default is not dataclasses.MISSING else UNSET
+    default = field.default if field.default is not PYDANTIC_MISSING_TYPE else UNSET
 
     has_factory = default_factory is not None and default_factory is not UNSET
     has_default = default is not None and default is not UNSET
@@ -125,7 +128,7 @@ def ensure_all_auto_fields_in_pydantic(
     model: Type[BaseModel], auto_fields: Set[str], cls_name: str
 ) -> Union[NoReturn, None]:
     # Raise error if user defined a strawberry.auto field not present in the model
-    non_existing_fields = list(auto_fields - model.__fields__.keys())
+    non_existing_fields = list(auto_fields - get_model_fields(model).keys())
 
     if non_existing_fields:
         raise AutoFieldsNotInBaseModelError(

strawberry/experimental/pydantic/v2_compat.py

@@ -0,0 +1,101 @@
+import dataclasses
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type
+
+import pydantic
+from pydantic import BaseModel
+from pydantic.version import VERSION as PYDANTIC_VERSION
+
+if TYPE_CHECKING:
+    from pydantic.fields import FieldInfo
+
+IS_PYDANTIC_V2: bool = PYDANTIC_VERSION.startswith("2.")
+IS_PYDANTIC_V1: bool = not IS_PYDANTIC_V2
+
+
+@dataclass
+class CompatModelField:
+    name: str
+    outer_type_: Any
+    default: Any
+    default_factory: Optional[Callable[[], Any]]
+    required: bool
+    alias: Optional[str]
+    allow_none: bool
+    has_alias: bool
+    description: Optional[str]
+
+
+if pydantic.VERSION[0] == "2":
+    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
+    from pydantic_core import PydanticUndefined
+
+    PYDANTIC_MISSING_TYPE = PydanticUndefined
+
+    def new_type_supertype(type_: Any) -> Any:
+        return type_.__supertype__
+
+    def get_model_fields(model: Type[BaseModel]) -> Dict[str, CompatModelField]:
+        field_info: dict[str, FieldInfo] = model.model_fields
+        new_fields = {}
+        # Convert it into CompatModelField
+        for name, field in field_info.items():
+            new_fields[name] = CompatModelField(
+                name=name,
+                outer_type_=field.annotation,
+                default=field.default,
+                default_factory=field.default_factory,
+                required=field.is_required(),
+                alias=field.alias,
+                # v2 doesn't have allow_none
+                allow_none=False,
+                has_alias=field is not None,
+                description=field.description,
+            )
+        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 (
+        lenient_issubclass,  # type: ignore[no-redef]
+        smart_deepcopy,  # type: ignore[no-redef]
+    )
+
+    PYDANTIC_MISSING_TYPE = dataclasses.MISSING  # type: ignore[assignment]
+
+    def get_model_fields(model: Type[BaseModel]) -> Dict[str, CompatModelField]:
+        new_fields = {}
+        # Convert it into CompatModelField
+        for name, field in model.__fields__.items():  # type: ignore[attr-defined]
+            new_fields[name] = CompatModelField(
+                name=name,
+                outer_type_=field.type_,
+                default=field.default,
+                default_factory=field.default_factory,
+                required=field.required,
+                alias=field.alias,
+                allow_none=field.allow_none,
+                has_alias=field.has_alias,
+                description=field.field_info.description,
+            )
+        return new_fields
+
+
+__all__ = [
+    "smart_deepcopy",
+    "lenient_issubclass",
+    "get_args",
+    "get_origin",
+    "is_new_type",
+    "new_type_supertype",
+    "get_model_fields",
+    "PYDANTIC_MISSING_TYPE",
+]