WIP: Pydantic v2 compat

strawberry/experimental/__init__.py

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

strawberry/experimental/pydantic/v2_compat.py

@@ -0,0 +1,17 @@
+import pydantic
+
+if pydantic.VERSION[0] == "2":
+    from pydantic._internal._utils import smart_deepcopy
+    from pydantic._internal._utils import lenient_issubclass
+    from typing_extensions import get_args, get_origin
+    from pydantic._internal._typing_extra import is_new_type
+
+    def new_type_supertype(type_):
+        return type_.__supertype__
+
+else:
+    from pydantic.utils import smart_deepcopy
+    from pydantic.utils import lenient_issubclass
+    from pydantic.typing import get_args, get_origin, is_new_type, new_type_supertype
+
+__all__ = ["smart_deepcopy", "lenient_issubclass"]

strawberry/experimental/pydantic2/__init__.py

@@ -0,0 +1,11 @@
+from .error_type import error_type
+from .exceptions import UnregisteredTypeException
+from .object_type import input, interface, type
+
+__all__ = [
+    "error_type",
+    "UnregisteredTypeException",
+    "input",
+    "type",
+    "interface",
+]

strawberry/experimental/pydantic2/conversion.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import copy
+import dataclasses
+from typing import TYPE_CHECKING, Any, Type, Union, cast
+
+from strawberry.enum import EnumDefinition
+from strawberry.type import StrawberryList, StrawberryOptional
+from strawberry.union import StrawberryUnion
+
+if TYPE_CHECKING:
+    from strawberry.type import StrawberryType
+
+
+def _convert_from_pydantic_to_strawberry_type(
+    type_: Union[StrawberryType, type], data_from_model=None, extra=None  # noqa: ANN001
+):
+    data = data_from_model if data_from_model is not None else extra
+
+    if isinstance(type_, StrawberryOptional):
+        if data is None:
+            return data
+        return _convert_from_pydantic_to_strawberry_type(
+            type_.of_type, data_from_model=data, extra=extra
+        )
+    if isinstance(type_, StrawberryUnion):
+        for option_type in type_.types:
+            if hasattr(option_type, "_pydantic_type"):
+                source_type = option_type._pydantic_type
+            else:
+                source_type = cast(type, option_type)
+            if isinstance(data, source_type):
+                return _convert_from_pydantic_to_strawberry_type(
+                    option_type, data_from_model=data, extra=extra
+                )
+    if isinstance(type_, EnumDefinition):
+        return data
+    if isinstance(type_, StrawberryList):
+        items = []
+        for index, item in enumerate(data):
+            items.append(
+                _convert_from_pydantic_to_strawberry_type(
+                    type_.of_type,
+                    data_from_model=item,
+                    extra=extra[index] if extra else None,
+                )
+            )
+
+        return items
+
+    if hasattr(type_, "_type_definition"):
+        # in the case of an interface, the concrete type may be more specific
+        # than the type in the field definition
+        # don't check _strawberry_input_type because inputs can't be interfaces
+        if hasattr(type(data), "_strawberry_type"):
+            type_ = type(data)._strawberry_type
+        if hasattr(type_, "from_pydantic"):
+            return type_.from_pydantic(data_from_model, extra)
+        return convert_pydantic_model_to_strawberry_class(
+            type_, model_instance=data_from_model, extra=extra
+        )
+
+    return data
+
+
+def convert_pydantic_model_to_strawberry_class(
+    cls, *, model_instance=None, extra=None  # noqa: ANN001
+) -> Any:
+    extra = extra or {}
+    kwargs = {}
+
+    for field_ in cls._type_definition.fields:
+        field = cast("StrawberryField", field_)
+        python_name = field.python_name
+
+        data_from_extra = extra.get(python_name, None)
+        data_from_model = (
+            getattr(model_instance, python_name, None) if model_instance else None
+        )
+
+        # only convert and add fields to kwargs if they are present in the `__init__`
+        # method of the class
+        if field.init:
+            kwargs[python_name] = _convert_from_pydantic_to_strawberry_type(
+                field.type, data_from_model, extra=data_from_extra
+            )
+
+    return cls(**kwargs)
+
+
+def convert_strawberry_class_to_pydantic_model(obj: Type) -> Any:
+    if hasattr(obj, "to_pydantic"):
+        return obj.to_pydantic()
+    elif dataclasses.is_dataclass(obj):
+        result = []
+        for f in dataclasses.fields(obj):
+            value = convert_strawberry_class_to_pydantic_model(getattr(obj, f.name))
+            result.append((f.name, value))
+        return dict(result)
+    elif isinstance(obj, (list, tuple)):
+        # Assume we can create an object of this type by passing in a
+        # generator (which is not true for namedtuples, not supported).
+        return type(obj)(convert_strawberry_class_to_pydantic_model(v) for v in obj)
+    elif isinstance(obj, dict):
+        return type(obj)(
+            (
+                convert_strawberry_class_to_pydantic_model(k),
+                convert_strawberry_class_to_pydantic_model(v),
+            )
+            for k, v in obj.items()
+        )
+    else:
+        return copy.deepcopy(obj)

strawberry/experimental/pydantic2/conversion_types.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Optional, Type, TypeVar
+from typing_extensions import Protocol
+
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from strawberry.types.types import TypeDefinition
+
+
+PydanticModel = TypeVar("PydanticModel", bound=BaseModel)
+
+
+class StrawberryTypeFromPydantic(Protocol[PydanticModel]):
+    """This class does not exist in runtime.
+    It only makes the methods below visible for IDEs"""
+
+    def __init__(self, **kwargs):
+        ...
+
+    @staticmethod
+    def from_pydantic(
+        instance: PydanticModel, extra: Optional[Dict[str, Any]] = None
+    ) -> StrawberryTypeFromPydantic[PydanticModel]:
+        ...
+
+    def to_pydantic(self, **kwargs) -> PydanticModel:
+        ...
+
+    @property
+    def _type_definition(self) -> TypeDefinition:
+        ...
+
+    @property
+    def _pydantic_type(self) -> Type[PydanticModel]:
+        ...

strawberry/experimental/pydantic2/error_type.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import dataclasses
+import warnings
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    Union,
+    cast,
+)
+
+from pydantic import BaseModel
+
+from strawberry.auto import StrawberryAuto
+from strawberry.experimental.pydantic2.utils import (
+    get_private_fields,
+    get_strawberry_type_from_model,
+    normalize_type,
+)
+from strawberry.experimental.pydantic2.v2_compat import 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]]:
+    type_ = field.outer_type_
+    type_ = normalize_type(type_)
+    return field_type_to_type(type_)
+
+
+def field_type_to_type(type_: Type) -> Union[Any, List[Any], None]:
+    error_class: Any = str
+    strawberry_type: Any = error_class
+
+    if is_list(type_):
+        child_type = get_list_annotation(type_)
+
+        if is_list(child_type):
+            strawberry_type = field_type_to_type(child_type)
+        elif lenient_issubclass(child_type, BaseModel):
+            strawberry_type = get_strawberry_type_from_model(child_type)
+        else:
+            strawberry_type = List[error_class]
+
+        strawberry_type = Optional[strawberry_type]
+    elif lenient_issubclass(type_, BaseModel):
+        strawberry_type = get_strawberry_type_from_model(type_)
+        return Optional[strawberry_type]
+
+    return Optional[List[strawberry_type]]
+
+
+def error_type(
+    model: Type[BaseModel],
+    *,
+    fields: Optional[List[str]] = None,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+    all_fields: bool = False,
+) -> Callable[..., Type]:
+    def wrap(cls: Type) -> Type:
+        model_fields = model.__fields__
+        fields_set = set(fields) if fields else set()
+
+        if fields:
+            warnings.warn(
+                "`fields` is deprecated, use `auto` type annotations instead",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        existing_fields = getattr(cls, "__annotations__", {})
+        fields_set = fields_set.union(
+            {
+                name
+                for name, type_ in existing_fields.items()
+                if isinstance(type_, StrawberryAuto)
+            }
+        )
+
+        if all_fields:
+            if fields_set:
+                warnings.warn(
+                    "Using all_fields overrides any explicitly defined fields "
+                    "in the model, using both is likely a bug",
+                    stacklevel=2,
+                )
+            fields_set = set(model_fields.keys())
+
+        if not fields_set:
+            raise MissingFieldsListError(cls)
+
+        all_model_fields: List[Tuple[str, Any, dataclasses.Field]] = [
+            (
+                name,
+                get_type_for_field(field),
+                dataclasses.field(default=None),  # type: ignore[arg-type]
+            )
+            for name, field in model_fields.items()
+            if name in fields_set
+        ]
+
+        wrapped = _wrap_dataclass(cls)
+        extra_fields = cast(List[dataclasses.Field], _get_fields(wrapped))
+        private_fields = get_private_fields(wrapped)
+
+        all_model_fields.extend(
+            (
+                field.name,
+                field.type,
+                field,
+            )
+            for field in extra_fields + private_fields
+            if not isinstance(field.type, StrawberryAuto)
+        )
+
+        cls = dataclasses.make_dataclass(
+            cls.__name__,
+            all_model_fields,
+            bases=cls.__bases__,
+        )
+
+        _process_type(
+            cls,
+            name=name,
+            is_input=False,
+            is_interface=False,
+            description=description,
+            directives=directives,
+        )
+
+        model._strawberry_type = cls  # type: ignore[attr-defined]
+        cls._pydantic_type = model
+        return cls
+
+    return wrap

strawberry/experimental/pydantic2/exceptions.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, List, Type
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+    from pydantic.typing import NoArgAnyCallable
+
+
+class MissingFieldsListError(Exception):
+    def __init__(self, type: Type[BaseModel]):
+        message = (
+            f"List of fields to copy from {type} is empty. Add fields with the "
+            f"`auto` type annotation"
+        )
+
+        super().__init__(message)
+
+
+class UnsupportedTypeError(Exception):
+    pass
+
+
+class UnregisteredTypeException(Exception):
+    def __init__(self, type: Type[BaseModel]):
+        message = (
+            f"Cannot find a Strawberry Type for {type} did you forget to register it?"
+        )
+
+        super().__init__(message)
+
+
+class BothDefaultAndDefaultFactoryDefinedError(Exception):
+    def __init__(self, default: Any, default_factory: NoArgAnyCallable):
+        message = (
+            f"Not allowed to specify both default and default_factory. "
+            f"default:{default} default_factory:{default_factory}"
+        )
+
+        super().__init__(message)
+
+
+class AutoFieldsNotInBaseModelError(Exception):
+    def __init__(self, fields: List[str], cls_name: str, model: Type[BaseModel]):
+        message = (
+            f"{cls_name} defines {fields} with strawberry.auto. "
+            f"Field(s) not present in {model.__name__} BaseModel."
+        )
+
+        super().__init__(message)