strawberry-graphql 0.278.0__py3-none-any.whl → 0.279.0.dev1754156227__py3-none-any.whl

strawberry/__init__.py

@@ -4,7 +4,7 @@ Strawberry is a Python library for GraphQL that aims to stay close to the GraphQ
 specification and allow for a more natural way of defining GraphQL schemas.
 """
 
-from . import experimental, federation, relay
+from . import experimental, federation, pydantic, relay
 from .directive import directive, directive_field
 from .parent import Parent
 from .permission import BasePermission
@@ -54,6 +54,7 @@ __all__ = [
     "interface",
     "lazy",
     "mutation",
+    "pydantic",
     "relay",
     "scalar",
     "schema_directive",

strawberry/experimental/pydantic/_compat.py

@@ -8,7 +8,6 @@ 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:

strawberry/experimental/pydantic/error_type.py

@@ -12,7 +12,6 @@ from typing import (
 )
 
 from pydantic import BaseModel
-
 from strawberry.experimental.pydantic._compat import (
     CompatModelField,
     PydanticCompat,

strawberry/experimental/pydantic/fields.py

@@ -2,7 +2,6 @@ import builtins
 from typing import Annotated, Any, Union
 
 from pydantic import BaseModel
-
 from strawberry.experimental.pydantic._compat import (
     PydanticCompat,
     get_args,

strawberry/experimental/pydantic/utils.py

@@ -10,7 +10,6 @@ from typing import (
 )
 
 from pydantic import BaseModel
-
 from strawberry.experimental.pydantic._compat import (
     CompatModelField,
     PydanticCompat,

strawberry/pydantic/__init__.py

@@ -0,0 +1,22 @@
+"""Strawberry Pydantic integration.
+
+This module provides first-class support for Pydantic models in Strawberry GraphQL.
+You can directly decorate Pydantic BaseModel classes to create GraphQL types.
+
+Example:
+    @strawberry.pydantic.type
+    class User(BaseModel):
+        name: str
+        age: int
+"""
+
+from .error import Error
+from .object_type import input as input_decorator
+from .object_type import interface
+from .object_type import type as type_decorator
+
+# Re-export with proper names
+input = input_decorator
+type = type_decorator
+
+__all__ = ["Error", "input", "interface", "type"]

strawberry/pydantic/error.py

@@ -0,0 +1,51 @@
+"""Generic error type for Pydantic validation errors in Strawberry GraphQL.
+
+This module provides a generic Error type that can be used to represent
+Pydantic validation errors in GraphQL responses.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from strawberry.types.object_type import type as strawberry_type
+
+if TYPE_CHECKING:
+    from pydantic import ValidationError
+
+
+@strawberry_type
+class ErrorDetail:
+    """Represents a single validation error detail."""
+
+    type: str
+    loc: list[str]
+    msg: str
+
+
+@strawberry_type
+class Error:
+    """Generic error type for Pydantic validation errors."""
+
+    errors: list[ErrorDetail]
+
+    @staticmethod
+    def from_validation_error(exc: ValidationError) -> Error:
+        """Create an Error instance from a Pydantic ValidationError.
+
+        Args:
+            exc: The Pydantic ValidationError to convert
+
+        Returns:
+            An Error instance containing all validation errors
+        """
+        return Error(
+            errors=[
+                ErrorDetail(
+                    type=error["type"],
+                    loc=[str(loc) for loc in error["loc"]],
+                    msg=error["msg"],
+                )
+                for error in exc.errors()
+            ]
+        )

strawberry/pydantic/fields.py

@@ -0,0 +1,202 @@
+"""Field processing utilities for Pydantic models in Strawberry GraphQL.
+
+This module provides functions to extract and process fields from Pydantic BaseModel
+classes, converting them to StrawberryField instances that can be used in GraphQL schemas.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+from strawberry.annotation import StrawberryAnnotation
+from strawberry.experimental.pydantic._compat import PydanticCompat
+from strawberry.experimental.pydantic.utils import get_default_factory_for_field
+from strawberry.types.field import StrawberryField
+from strawberry.types.private import is_private
+from strawberry.utils.typing import get_args, get_origin, is_union
+
+if TYPE_CHECKING:
+    from pydantic import BaseModel
+    from pydantic.fields import FieldInfo
+
+from strawberry.experimental.pydantic._compat import lenient_issubclass
+
+
+def replace_pydantic_types(type_: Any, is_input: bool) -> Any:
+    """Replace Pydantic types with their Strawberry equivalents for first-class integration."""
+    from pydantic import BaseModel
+
+    if lenient_issubclass(type_, BaseModel):
+        # For first-class integration, check if the type has been decorated
+        if hasattr(type_, "__strawberry_definition__"):
+            # Return the type itself as it's already a Strawberry type
+            return type_
+        # If not decorated, raise an error
+        from strawberry.experimental.pydantic.exceptions import (
+            UnregisteredTypeException,
+        )
+
+        raise UnregisteredTypeException(type_)
+
+    return type_
+
+
+def replace_types_recursively(
+    type_: Any,
+    is_input: bool,
+    compat: PydanticCompat,
+) -> Any:
+    """Recursively replace Pydantic types with their Strawberry equivalents."""
+    # For now, use a simpler approach similar to the experimental module
+    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)
+    )
+
+    # Handle special cases for typing generics
+    from typing import Union as TypingUnion
+    from typing import _GenericAlias as TypingGenericAlias
+
+    if isinstance(replaced_type, TypingGenericAlias):
+        return TypingGenericAlias(origin, converted)
+    if is_union(replaced_type):
+        return TypingUnion[converted]
+
+    # Handle Annotated types
+    from typing import Annotated
+
+    if origin is Annotated and converted:
+        converted = (converted[0],)
+
+    # For other types, try to use copy_with if available
+    if hasattr(replaced_type, "copy_with"):
+        return replaced_type.copy_with(converted)
+
+    # Fallback to origin[converted] for standard generic types
+    return origin[converted]
+
+
+def get_type_for_field(field: FieldInfo, is_input: bool, compat: PydanticCompat) -> Any:
+    """Get the GraphQL type for a Pydantic field."""
+    outer_type = field.outer_type_
+
+    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:
+            from typing import Optional
+
+            return Optional[replaced_type]
+
+    return replaced_type
+
+
+def _get_pydantic_fields(
+    cls: type[BaseModel],
+    original_type_annotations: dict[str, type[Any]],
+    is_input: bool = False,
+    include_computed: bool = False,
+) -> list[StrawberryField]:
+    """Extract StrawberryFields from a Pydantic BaseModel class.
+
+    This function processes a Pydantic BaseModel and extracts its fields,
+    converting them to StrawberryField instances that can be used in GraphQL schemas.
+    All fields from the Pydantic model are included by default, except those marked
+    with strawberry.Private.
+
+    Args:
+        cls: The Pydantic BaseModel class to extract fields from
+        original_type_annotations: Type annotations that may override field types
+        is_input: Whether this is for an input type
+        include_computed: Whether to include computed fields
+
+    Returns:
+        List of StrawberryField instances
+    """
+    fields: list[StrawberryField] = []
+
+    # Get compatibility layer for this model
+    compat = PydanticCompat.from_model(cls)
+
+    # Extract Pydantic model fields
+    model_fields = compat.get_model_fields(cls, include_computed=include_computed)
+
+    # Get annotations from the class to check for strawberry.Private and other custom fields
+    existing_annotations = getattr(cls, "__annotations__", {})
+
+    # Process each field from the Pydantic model
+    for field_name, pydantic_field in model_fields.items():
+        # Check if this field is marked as private
+        if field_name in existing_annotations:
+            field_type = existing_annotations[field_name]
+            # Skip private fields - they shouldn't be included in GraphQL schema
+            if is_private(field_type):
+                continue
+
+        # Get the field type from the Pydantic model
+        field_type = get_type_for_field(pydantic_field, is_input, compat=compat)
+
+        # Check if there's a custom field definition on the class
+        custom_field = getattr(cls, field_name, None)
+        if isinstance(custom_field, StrawberryField):
+            # Use the custom field but update its type if needed
+            strawberry_field = custom_field
+            strawberry_field.type_annotation = StrawberryAnnotation.from_annotation(
+                field_type
+            )
+        else:
+            # Create a new StrawberryField
+            graphql_name = None
+            if pydantic_field.has_alias:
+                graphql_name = pydantic_field.alias
+
+            strawberry_field = StrawberryField(
+                python_name=field_name,
+                graphql_name=graphql_name,
+                type_annotation=StrawberryAnnotation.from_annotation(field_type),
+                description=pydantic_field.description,
+                default_factory=get_default_factory_for_field(
+                    pydantic_field, compat=compat
+                ),
+            )
+
+        # Set the origin module for proper type resolution
+        origin = cls
+        module = sys.modules[origin.__module__]
+
+        if (
+            isinstance(strawberry_field.type_annotation, StrawberryAnnotation)
+            and strawberry_field.type_annotation.namespace is None
+        ):
+            strawberry_field.type_annotation.namespace = module.__dict__
+
+        strawberry_field.origin = origin
+
+        # Apply any type overrides from original_type_annotations
+        if field_name in original_type_annotations:
+            strawberry_field.type = original_type_annotations[field_name]
+            strawberry_field.type_annotation = StrawberryAnnotation(
+                annotation=strawberry_field.type
+            )
+
+        fields.append(strawberry_field)
+
+    return fields
+
+
+__all__ = [
+    "_get_pydantic_fields",
+    "replace_pydantic_types",
+    "replace_types_recursively",
+]

strawberry/pydantic/object_type.py

@@ -0,0 +1,348 @@
+"""Object type decorators for Pydantic models in Strawberry GraphQL.
+
+This module provides decorators to convert Pydantic BaseModel classes directly
+into GraphQL types, inputs, and interfaces without requiring a separate wrapper class.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Optional, Union, overload
+
+if TYPE_CHECKING:
+    import builtins
+    from collections.abc import Sequence
+
+from strawberry.experimental.pydantic._compat import PydanticCompat
+from strawberry.experimental.pydantic.conversion import (
+    convert_strawberry_class_to_pydantic_model,
+)
+from strawberry.types.base import StrawberryObjectDefinition
+from strawberry.types.cast import get_strawberry_type_cast
+from strawberry.utils.str_converters import to_camel_case
+
+from .fields import _get_pydantic_fields
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from pydantic import BaseModel
+
+
+def _get_interfaces(cls: builtins.type[Any]) -> list[StrawberryObjectDefinition]:
+    """Extract interfaces from a class's inheritance hierarchy."""
+    interfaces: list[StrawberryObjectDefinition] = []
+
+    for base in cls.__mro__[1:]:  # Exclude current class
+        if hasattr(base, "__strawberry_definition__"):
+            type_definition = base.__strawberry_definition__
+            if type_definition.is_interface:
+                interfaces.append(type_definition)
+
+    return interfaces
+
+
+def _process_pydantic_type(
+    cls: type[BaseModel],
+    *,
+    name: Optional[str] = None,
+    is_input: bool = False,
+    is_interface: bool = False,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+    include_computed: bool = False,
+) -> type[BaseModel]:
+    """Process a Pydantic BaseModel class and add GraphQL metadata.
+
+    Args:
+        cls: The Pydantic BaseModel class to process
+        name: The GraphQL type name (defaults to class name)
+        is_input: Whether this is an input type
+        is_interface: Whether this is an interface type
+        description: The GraphQL type description
+        directives: GraphQL directives to apply
+        include_computed: Whether to include computed fields
+
+    Returns:
+        The processed BaseModel class with GraphQL metadata
+    """
+    # Get the GraphQL type name
+    name = name or to_camel_case(cls.__name__)
+
+    # Get compatibility layer for this model
+    compat = PydanticCompat.from_model(cls)
+
+    # Extract fields using our custom function
+    # All fields from the Pydantic model are included by default, except strawberry.Private fields
+    fields = _get_pydantic_fields(
+        cls=cls,
+        original_type_annotations={},
+        is_input=is_input,
+        include_computed=include_computed,
+    )
+
+    # Get interfaces from inheritance hierarchy
+    interfaces = _get_interfaces(cls)
+
+    # Create the is_type_of method for proper type resolution
+    def is_type_of(obj: Any, _info: GraphQLResolveInfo) -> bool:
+        if (type_cast := get_strawberry_type_cast(obj)) is not None:
+            return type_cast is cls
+        return isinstance(obj, cls)
+
+    # Create the GraphQL type definition
+    cls.__strawberry_definition__ = StrawberryObjectDefinition(  # type: ignore
+        name=name,
+        is_input=is_input,
+        is_interface=is_interface,
+        interfaces=interfaces,
+        description=description,
+        directives=directives,
+        origin=cls,
+        extend=False,
+        fields=fields,
+        is_type_of=is_type_of,
+        resolve_type=getattr(cls, "resolve_type", None),
+    )
+
+    # Add the is_type_of method to the class for testing purposes
+    cls.is_type_of = is_type_of  # type: ignore
+
+    # Add conversion methods
+    def from_pydantic(
+        instance: BaseModel, extra: Optional[dict[str, Any]] = None
+    ) -> BaseModel:
+        """Convert a Pydantic model instance to a GraphQL-compatible instance."""
+        if extra:
+            # If there are extra fields, create a new instance with them
+            instance_dict = compat.model_dump(instance)
+            instance_dict.update(extra)
+            return cls(**instance_dict)
+        return instance
+
+    def to_pydantic(self: Any, **kwargs: Any) -> BaseModel:
+        """Convert a GraphQL instance back to a Pydantic model."""
+        if isinstance(self, cls):
+            # If it's already the right type, return it
+            if not kwargs:
+                return self
+            # Create a new instance with the updated kwargs
+            instance_dict = compat.model_dump(self)
+            instance_dict.update(kwargs)
+            return cls(**instance_dict)
+
+        # If it's a different type, convert it
+        return convert_strawberry_class_to_pydantic_model(self, **kwargs)
+
+    # Add conversion methods if they don't exist
+    if not hasattr(cls, "from_pydantic"):
+        cls.from_pydantic = staticmethod(from_pydantic)  # type: ignore
+    if not hasattr(cls, "to_pydantic"):
+        cls.to_pydantic = to_pydantic  # type: ignore
+
+    return cls
+
+
+@overload
+def type(
+    cls: type[BaseModel],
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+    include_computed: bool = False,
+) -> type[BaseModel]: ...
+
+
+@overload
+def type(
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+    include_computed: bool = False,
+) -> Callable[[type[BaseModel]], type[BaseModel]]: ...
+
+
+def type(
+    cls: Optional[type[BaseModel]] = None,
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+    include_computed: bool = False,
+) -> Union[type[BaseModel], Callable[[type[BaseModel]], type[BaseModel]]]:
+    """Decorator to convert a Pydantic BaseModel directly into a GraphQL type.
+
+    This decorator allows you to use Pydantic models directly as GraphQL types
+    without needing to create a separate wrapper class.
+
+    Args:
+        cls: The Pydantic BaseModel class to convert
+        name: The GraphQL type name (defaults to class name)
+        description: The GraphQL type description
+        directives: GraphQL directives to apply to the type
+        include_computed: Whether to include computed fields
+
+    Returns:
+        The decorated BaseModel class with GraphQL metadata
+
+    Example:
+        @strawberry.pydantic.type
+        class User(BaseModel):
+            name: str
+            age: int
+
+        # All fields from the Pydantic model will be included in the GraphQL type
+    """
+
+    def wrap(cls: type[BaseModel]) -> type[BaseModel]:
+        return _process_pydantic_type(
+            cls,
+            name=name,
+            is_input=False,
+            is_interface=False,
+            description=description,
+            directives=directives,
+            include_computed=include_computed,
+        )
+
+    if cls is None:
+        return wrap
+
+    return wrap(cls)
+
+
+@overload
+def input(
+    cls: type[BaseModel],
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+) -> type[BaseModel]: ...
+
+
+@overload
+def input(
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+) -> Callable[[type[BaseModel]], type[BaseModel]]: ...
+
+
+def input(
+    cls: Optional[type[BaseModel]] = None,
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+) -> Union[type[BaseModel], Callable[[type[BaseModel]], type[BaseModel]]]:
+    """Decorator to convert a Pydantic BaseModel directly into a GraphQL input type.
+
+    This decorator allows you to use Pydantic models directly as GraphQL input types
+    without needing to create a separate wrapper class.
+
+    Args:
+        cls: The Pydantic BaseModel class to convert
+        name: The GraphQL input type name (defaults to class name)
+        description: The GraphQL input type description
+        directives: GraphQL directives to apply to the input type
+
+    Returns:
+        The decorated BaseModel class with GraphQL input metadata
+
+    Example:
+        @strawberry.pydantic.input
+        class CreateUserInput(BaseModel):
+            name: str
+            age: int
+
+        # All fields from the Pydantic model will be included in the GraphQL input type
+    """
+
+    def wrap(cls: type[BaseModel]) -> type[BaseModel]:
+        return _process_pydantic_type(
+            cls,
+            name=name,
+            is_input=True,
+            is_interface=False,
+            description=description,
+            directives=directives,
+            include_computed=False,  # Input types don't need computed fields
+        )
+
+    if cls is None:
+        return wrap
+
+    return wrap(cls)
+
+
+@overload
+def interface(
+    cls: type[BaseModel],
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+    include_computed: bool = False,
+) -> type[BaseModel]: ...
+
+
+@overload
+def interface(
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+    include_computed: bool = False,
+) -> Callable[[type[BaseModel]], type[BaseModel]]: ...
+
+
+def interface(
+    cls: Optional[type[BaseModel]] = None,
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    directives: Optional[Sequence[object]] = (),
+    include_computed: bool = False,
+) -> Union[type[BaseModel], Callable[[type[BaseModel]], type[BaseModel]]]:
+    """Decorator to convert a Pydantic BaseModel directly into a GraphQL interface.
+
+    This decorator allows you to use Pydantic models directly as GraphQL interfaces
+    without needing to create a separate wrapper class.
+
+    Args:
+        cls: The Pydantic BaseModel class to convert
+        name: The GraphQL interface name (defaults to class name)
+        description: The GraphQL interface description
+        directives: GraphQL directives to apply to the interface
+        include_computed: Whether to include computed fields
+
+    Returns:
+        The decorated BaseModel class with GraphQL interface metadata
+
+    Example:
+        @strawberry.pydantic.interface
+        class Node(BaseModel):
+            id: str
+    """
+
+    def wrap(cls: type[BaseModel]) -> type[BaseModel]:
+        return _process_pydantic_type(
+            cls,
+            name=name,
+            is_input=False,
+            is_interface=True,
+            description=description,
+            directives=directives,
+            include_computed=include_computed,
+        )
+
+    if cls is None:
+        return wrap
+
+    return wrap(cls)
+
+
+__all__ = ["input", "interface", "type"]

{strawberry_graphql-0.278.0.dist-info → strawberry_graphql-0.279.0.dev1754156227.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strawberry-graphql
-Version: 0.278.0
+Version: 0.279.0.dev1754156227
 Summary: A library for creating GraphQL APIs
 License: MIT
 Keywords: graphql,api,rest,starlette,async

{strawberry_graphql-0.278.0.dist-info → strawberry_graphql-0.279.0.dev1754156227.dist-info}/RECORD

@@ -1,4 +1,4 @@
-strawberry/__init__.py,sha256=tavG4mNFBNHhGBoFR2T7fhiCQ7P-ITHify10nkKBOJE,1544
+strawberry/__init__.py,sha256=55XU2lJuoy_VY9fGdV4T8DiSio1taskJBG4ukn62m44,1570
 strawberry/__main__.py,sha256=3U77Eu21mJ-LY27RG-JEnpbh6Z63wGOom4i-EoLtUcY,59
 strawberry/aiohttp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/aiohttp/test/__init__.py,sha256=4xxdUZtIISSOwjrcnmox7AvT4WWjowCm5bUuPdQneMg,71
@@ -75,14 +75,14 @@ strawberry/exceptions/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 strawberry/exceptions/utils/source_finder.py,sha256=wANz2bsXQW2TPES00XDWzDJsdnuAHcnjtM2_iv3eqsA,22566
 strawberry/experimental/__init__.py,sha256=2HP5XtxL8ZKsPp4EDRAbMCqiP7p2V4Cca278JUGxnt0,102
 strawberry/experimental/pydantic/__init__.py,sha256=UpO8wHNXGpoCYp34YStViInO1tsrGsMyhTVubTpJY7Y,255
-strawberry/experimental/pydantic/_compat.py,sha256=CUc7SmGA-viYoBgD4L8X483yTGyDKaKMjX3WYWkiohg,9710
+strawberry/experimental/pydantic/_compat.py,sha256=b8R_CirkeAuto8-5ZcTLzHonp8LSvuV5IkmQKEC9jzg,9709
 strawberry/experimental/pydantic/conversion.py,sha256=xspWZtbCuhLeStf12X60c5cOrKp4ilVDlnW-tRU0_YY,4242
 strawberry/experimental/pydantic/conversion_types.py,sha256=jf7PR5Q7hgo4J_AuxBK-BVj-8MC6vIg1k1pUfGfGTL8,925
-strawberry/experimental/pydantic/error_type.py,sha256=RdmiUY4V0baXCAk80ST-XtCiZbndZaaUSEajQplDAzw,4557
+strawberry/experimental/pydantic/error_type.py,sha256=yn7F2kx0io1mK5PvQ-iAinR8HrL65voD-YAWGf9IjZY,4556
 strawberry/experimental/pydantic/exceptions.py,sha256=pDMPL94ojuSGHxk8H8mI2pfWReG8BhqZ5T2eSxfOi9w,1486
-strawberry/experimental/pydantic/fields.py,sha256=NcB38JYk29fPwJWtoHkIvwTfqD2Ekf7fJ57GjvvK6mQ,2265
+strawberry/experimental/pydantic/fields.py,sha256=UEuhFfu2XTp2gNto6Di-Um2MZ6imo3e9chyoFobf4sM,2264
 strawberry/experimental/pydantic/object_type.py,sha256=qoTQXO4qdno0M2oQv0sll7lqeyul_WDNmoSZpm5V14s,12863
-strawberry/experimental/pydantic/utils.py,sha256=URSzmcK2KzNGsLv4RyFdFfJnr-ARNLkkM0D4CjijVQU,4035
+strawberry/experimental/pydantic/utils.py,sha256=qlS8VJuS_9sv8o9Wj4LtjT5DhPrMs6bJIcHOvdEaXPI,4034
 strawberry/ext/LICENSE,sha256=_oY0TZg0b_sW0--0T44aMTpy2e2zF1Kiyn8E1qDiivo,1249
 strawberry/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/ext/dataclasses/LICENSE,sha256=WZgm35K_3NJwLqxpEHJJi7CWxVrwTumEz5D3Dtd7WnA,13925
@@ -152,6 +152,10 @@ strawberry/printer/__init__.py,sha256=DmepjmgtkdF5RxK_7yC6qUyRWn56U-9qeZMbkztYB9
 strawberry/printer/ast_from_value.py,sha256=Tkme60qlykbN2m3dNPNMOe65X-wj6EmcDQwgQv7gUkc,4987
 strawberry/printer/printer.py,sha256=5E9w0wDsUv1hvkeXof12277NLMiCVy5MgJ6gSo_NJhQ,19177
 strawberry/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+strawberry/pydantic/__init__.py,sha256=_QAGALzygcRyKE2iiK_rHt4s_d0g3ms0SUP64rEjrYI,592
+strawberry/pydantic/error.py,sha256=EvS2R99CCoe5Oo5Dh3V9Xc6eGcSFpo-r4F5Wq8RjF7U,1271
+strawberry/pydantic/fields.py,sha256=8oBY7Z-sTj6Tt3l9sNl1Wqk2ERxh-Doe2onQYnsGCP4,7188
+strawberry/pydantic/object_type.py,sha256=sxFTE_VSpAcmOm7-EGL-tp0aobjoctOSjVQs34fRcD8,10785
 strawberry/quart/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/quart/views.py,sha256=bl9NKLS8731Vv2FYD1rky0gpKNbgMSTrscgduLh59R4,7514
 strawberry/relay/__init__.py,sha256=Vi4btvA_g6Cj9Tk_F9GCSegapIf2WqkOWV8y3P0cTCs,553
@@ -236,8 +240,8 @@ strawberry/utils/logging.py,sha256=U1cseHGquN09YFhFmRkiphfASKCyK0HUZREImPgVb0c,7
 strawberry/utils/operation.py,sha256=ZgVOw3K2jQuLjNOYUHauF7itJD0QDNoPw9PBi0IYf6k,1234
 strawberry/utils/str_converters.py,sha256=-eH1Cl16IO_wrBlsGM-km4IY0IKsjhjnSNGRGOwQjVM,897
 strawberry/utils/typing.py,sha256=SDvX-Du-9HAV3-XXjqi7Q5f5qPDDFd_gASIITiwBQT4,14073
-strawberry_graphql-0.278.0.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
-strawberry_graphql-0.278.0.dist-info/METADATA,sha256=HI66cOb-CIEHhYh3SOalc50DnguVnVlAnmMQRhi2BF0,7393
-strawberry_graphql-0.278.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-strawberry_graphql-0.278.0.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
-strawberry_graphql-0.278.0.dist-info/RECORD,,
+strawberry_graphql-0.279.0.dev1754156227.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
+strawberry_graphql-0.279.0.dev1754156227.dist-info/METADATA,sha256=eVH1vDqpWl0QgJtrdbBWBLGpevUJJjqwsD8VOezP5cc,7407
+strawberry_graphql-0.279.0.dev1754156227.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+strawberry_graphql-0.279.0.dev1754156227.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
+strawberry_graphql-0.279.0.dev1754156227.dist-info/RECORD,,