Pydantic v2 support

.github/workflows/test.yml

@@ -159,6 +159,9 @@ jobs:
 
       - run: poetry install --with integrations
         if: steps.setup-python.outputs.cache-hit != 'true'
+      # Since we are running all the integrations at once, we can't use
+      # pydantic v2. It is not compatible with starlette yet
+      - run: poetry run pip install pydantic==1.10
 
       # we use poetry directly instead of nox since we want to
       # test all integrations at once on windows

RELEASE.md

@@ -0,0 +1,7 @@
+Release type: minor
+
+Adds initial support for pydantic V2.
+
+This is extremely experimental for wider initial testing.
+
+We do not encourage using this in production systems yet.

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

@@ -48,7 +48,7 @@ flask = {version = ">=1.1", optional = true}
 opentelemetry-api = {version = "<2", optional = true}
 opentelemetry-sdk = {version = "<2", optional = true}
 chalice = {version = "^1.22", optional = true}
-pydantic = {version = "<2", optional = true}
+pydantic = {version = ">1.6.1", optional = true}
 python-multipart = {version = ">=0.0.5,<0.0.7", optional = true}
 sanic = {version = ">=20.12.2", optional = true}
 aiohttp = {version = "^3.7.4.post0", optional = true}
@@ -112,7 +112,7 @@ channels = "^3.0.5"
 Django = ">=3.2"
 fastapi = {version = ">=0.65.0", optional = false}
 flask = ">=1.1"
-pydantic = {version = "<2", optional = false}
+pydantic = {version = ">1.6.1", optional = false}
 pytest-aiohttp = "^1.0.3"
 pytest-django = {version = "^4.5"}
 pytest-flask = {version = "^1.2.0"}

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(