strawberry-graphql 0.223.0__tar.gz → 0.224.0__tar.gz

{strawberry_graphql-0.223.0 → strawberry_graphql-0.224.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.223.0
+Version: 0.224.0
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.223.0 → strawberry_graphql-0.224.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.223.0"
+version = "0.224.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"

{strawberry_graphql-0.223.0 → strawberry_graphql-0.224.0}/strawberry/experimental/__init__.py

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

strawberry_graphql-0.224.0/strawberry/experimental/pydantic/_compat.py

@@ -0,0 +1,286 @@
+import dataclasses
+from dataclasses import dataclass
+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
+
+IS_PYDANTIC_V2: bool = PYDANTIC_VERSION.startswith("2.")
+IS_PYDANTIC_V1: bool = not IS_PYDANTIC_V2
+
+
+@dataclass
+class CompatModelField:
+    name: str
+    type_: Any
+    outer_type_: Any
+    default: Any
+    default_factory: Optional[Callable[[], Any]]
+    required: bool
+    alias: Optional[str]
+    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
+
+    @property
+    def has_default(self) -> bool:
+        return self.default is not self._missing_type
+
+
+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 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
+        for name, field in field_info.items():
+            new_fields[name] = CompatModelField(
+                name=name,
+                type_=field.annotation,
+                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,
+                _missing_type=self.PYDANTIC_MISSING_TYPE,
+                is_v1=False,
+            )
+        return new_fields
+
+    @cached_property
+    def fields_map(self) -> Dict[Any, Any]:
+        return get_fields_map_for_v2()
+
+    def get_basic_type(self, type_: Any) -> Type[Any]:
+        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 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]
+            new_fields[name] = CompatModelField(
+                name=name,
+                type_=field.type_,
+                outer_type_=field.outer_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,
+                _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__ = [
+    "PydanticCompat",
+    "is_new_type",
+    "lenient_issubclass",
+    "get_origin",
+    "get_args",
+    "new_type_supertype",
+    "smart_deepcopy",
+]

{strawberry_graphql-0.223.0 → strawberry_graphql-0.224.0}/strawberry/experimental/pydantic/error_type.py

@@ -19,7 +19,7 @@ from pydantic import BaseModel
 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 @@ def error_type(
     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:

strawberry_graphql-0.224.0/strawberry/experimental/pydantic/fields.py

@@ -0,0 +1,88 @@
+import builtins
+from typing import Any, Union
+from typing_extensions import Annotated
+
+from pydantic import BaseModel
+
+from strawberry.experimental.pydantic._compat import (
+    PydanticCompat,
+    get_args,
+    get_origin,
+    lenient_issubclass,
+)
+from strawberry.experimental.pydantic.exceptions import (
+    UnregisteredTypeException,
+)
+from strawberry.types.types import StrawberryObjectDefinition
+
+try:
+    from types import UnionType as TypingUnionType
+except ImportError:
+    import sys
+
+    if sys.version_info < (3, 10):
+        TypingUnionType = ()
+    else:
+        raise
+
+try:
+    from typing import GenericAlias as TypingGenericAlias  # type: ignore
+except ImportError:
+    import sys
+
+    # python < 3.9 does not have GenericAlias (list[int], tuple[str, ...] and so on)
+    # we do this under a conditional to avoid a mypy :)
+    if sys.version_info < (3, 9):
+        TypingGenericAlias = ()
+    else:
+        raise
+
+
+def replace_pydantic_types(type_: Any, is_input: bool) -> Any:
+    if lenient_issubclass(type_, BaseModel):
+        attr = "_strawberry_input_type" if is_input else "_strawberry_type"
+        if hasattr(type_, attr):
+            return getattr(type_, attr)
+        else:
+            raise UnregisteredTypeException(type_)
+    return type_
+
+
+def replace_types_recursively(
+    type_: Any, is_input: bool, compat: PydanticCompat
+) -> Any:
+    """Runs the conversions recursively into the arguments of generic types if any"""
+    basic_type = compat.get_basic_type(type_)
+    replaced_type = replace_pydantic_types(basic_type, is_input)
+
+    origin = get_origin(type_)
+
+    if not origin or not hasattr(type_, "__args__"):
+        return replaced_type
+
+    converted = tuple(
+        replace_types_recursively(t, is_input=is_input, compat=compat)
+        for t in get_args(replaced_type)
+    )
+
+    if isinstance(replaced_type, TypingGenericAlias):
+        return TypingGenericAlias(origin, converted)
+    if isinstance(replaced_type, TypingUnionType):
+        return Union[converted]
+
+    # TODO: investigate if we could move the check for annotated to the top
+    if origin is Annotated and converted:
+        converted = (converted[0],)
+
+    replaced_type = replaced_type.copy_with(converted)
+
+    if isinstance(replaced_type, StrawberryObjectDefinition):
+        # TODO: Not sure if this is necessary. No coverage in tests
+        # TODO: Unnecessary with StrawberryObject
+        replaced_type = builtins.type(
+            replaced_type.name,
+            (),
+            {"__strawberry_definition__": replaced_type},
+        )
+
+    return replaced_type

{strawberry_graphql-0.223.0 → strawberry_graphql-0.224.0}/strawberry/experimental/pydantic/object_type.py

@@ -19,9 +19,8 @@ from typing import (
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.auto import StrawberryAuto
 from strawberry.experimental.pydantic._compat import (
-    IS_PYDANTIC_V1,
     CompatModelField,
-    get_model_fields,
+    PydanticCompat,
 )
 from strawberry.experimental.pydantic.conversion import (
     convert_pydantic_model_to_strawberry_class,
@@ -44,10 +43,12 @@ if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
 
 
-def get_type_for_field(field: CompatModelField, is_input: bool):  # noqa: ANN201
+def get_type_for_field(field: CompatModelField, is_input: bool, compat: PydanticCompat):  # noqa: ANN201
     outer_type = field.outer_type_
-    replaced_type = replace_types_recursively(outer_type, is_input)
-    if IS_PYDANTIC_V1:
+
+    replaced_type = replace_types_recursively(outer_type, is_input, compat=compat)
+
+    if field.is_v1:
         # only pydantic v1 has this Optional logic
         should_add_optional: bool = field.allow_none
         if should_add_optional:
@@ -62,9 +63,10 @@ def _build_dataclass_creation_fields(
     existing_fields: Dict[str, StrawberryField],
     auto_fields_set: Set[str],
     use_pydantic_alias: bool,
+    compat: PydanticCompat,
 ) -> DataclassCreationFields:
     field_type = (
-        get_type_for_field(field, is_input)
+        get_type_for_field(field, is_input, compat=compat)
         if field.name in auto_fields_set
         else existing_fields[field.name].type
     )
@@ -129,7 +131,8 @@ def type(
     use_pydantic_alias: bool = True,
 ) -> Callable[..., Type[StrawberryTypeFromPydantic[PydanticModel]]]:
     def wrap(cls: Any) -> Type[StrawberryTypeFromPydantic[PydanticModel]]:
-        model_fields = get_model_fields(model)
+        compat = PydanticCompat.from_model(model)
+        model_fields = compat.get_model_fields(model)
         original_fields_set = set(fields) if fields else set()
 
         if fields:
@@ -182,7 +185,12 @@ def type(
 
         all_model_fields: List[DataclassCreationFields] = [
             _build_dataclass_creation_fields(
-                field, is_input, extra_fields_dict, auto_fields_set, use_pydantic_alias
+                field,
+                is_input,
+                extra_fields_dict,
+                auto_fields_set,
+                use_pydantic_alias,
+                compat=compat,
             )
             for field_name, field in model_fields.items()
             if field_name in fields_set

{strawberry_graphql-0.223.0 → strawberry_graphql-0.224.0}/strawberry/experimental/pydantic/utils.py

@@ -14,9 +14,8 @@ from typing import (
 )
 
 from strawberry.experimental.pydantic._compat import (
-    PYDANTIC_MISSING_TYPE,
     CompatModelField,
-    get_model_fields,
+    PydanticCompat,
     smart_deepcopy,
 )
 from strawberry.experimental.pydantic.exceptions import (
@@ -83,12 +82,8 @@ def get_default_factory_for_field(
     Returns optionally a NoArgAnyCallable representing a default_factory parameter
     """
     # replace dataclasses.MISSING with our own UNSET to make comparisons easier
-    default_factory = (
-        field.default_factory
-        if field.default_factory is not PYDANTIC_MISSING_TYPE
-        else UNSET
-    )
-    default = field.default if field.default is not PYDANTIC_MISSING_TYPE else UNSET
+    default_factory = field.default_factory if field.has_default_factory else UNSET
+    default = field.default if field.has_default 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
@@ -126,8 +121,9 @@ def get_default_factory_for_field(
 def ensure_all_auto_fields_in_pydantic(
     model: Type[BaseModel], auto_fields: Set[str], cls_name: str
 ) -> None:
+    compat = PydanticCompat.from_model(model)
     # Raise error if user defined a strawberry.auto field not present in the model
-    non_existing_fields = list(auto_fields - get_model_fields(model).keys())
+    non_existing_fields = list(auto_fields - compat.get_model_fields(model).keys())
 
     if non_existing_fields:
         raise AutoFieldsNotInBaseModelError(

strawberry_graphql-0.223.0/strawberry/experimental/pydantic/_compat.py

@@ -1,103 +0,0 @@
-import dataclasses
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Type
-
-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
-    type_: Any
-    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 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
-    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,
-                type_=field.annotation,
-                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 (  # type: ignore[no-redef]
-        lenient_issubclass,
-        smart_deepcopy,
-    )
-
-    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,
-                type_=field.type_,
-                outer_type_=field.outer_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",
-]