strawberry-graphql 0.227.0__py3-none-any.whl → 0.227.0.dev1713475585__py3-none-any.whl

strawberry/ext/mypy_plugin.py

@@ -11,7 +11,6 @@ from typing import (
     List,
     Optional,
     Set,
-    Tuple,
     Union,
     cast,
 )
@@ -60,16 +59,11 @@ try:
 except ImportError:
     TypeVarDef = TypeVarType
 
-PYDANTIC_VERSION: Optional[Tuple[int, ...]] = None
-
 # To be compatible with user who don't use pydantic
 try:
-    import pydantic
     from pydantic.mypy import METADATA_KEY as PYDANTIC_METADATA_KEY
     from pydantic.mypy import PydanticModelField
 
-    PYDANTIC_VERSION = tuple(map(int, pydantic.__version__.split(".")))
-
     from strawberry.experimental.pydantic._compat import IS_PYDANTIC_V1
 except ImportError:
     PYDANTIC_METADATA_KEY = ""
@@ -470,11 +464,6 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
                     return_type=model_type,
                 )
             else:
-                extra = {}
-
-                if PYDANTIC_VERSION and PYDANTIC_VERSION >= (2, 7, 0):
-                    extra["api"] = ctx.api
-
                 add_method(
                     ctx,
                     "to_pydantic",
@@ -485,7 +474,6 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
                             typed=True,
                             force_optional=False,
                             use_alias=True,
-                            **extra,
                         )
                         for f in missing_pydantic_fields
                     ],
@@ -499,23 +487,12 @@ def strawberry_pydantic_class_callback(ctx: ClassDefContext) -> None:
             initializer=None,
             kind=ARG_OPT,
         )
-        extra_type = ctx.api.named_type(
-            "builtins.dict",
-            [ctx.api.named_type("builtins.str"), AnyType(TypeOfAny.explicit)],
-        )
-
-        extra_argument = Argument(
-            variable=Var(name="extra", type=UnionType([NoneType(), extra_type])),
-            type_annotation=UnionType([NoneType(), extra_type]),
-            initializer=None,
-            kind=ARG_OPT,
-        )
 
         add_static_method_to_class(
             ctx.api,
             ctx.cls,
             name="from_pydantic",
-            args=[model_argument, extra_argument],
+            args=[model_argument],
             return_type=fill_typevars(ctx.cls.info),
         )
 

strawberry/federation/object_type.py

@@ -31,6 +31,7 @@ def _impl_type(
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
+    one_of: Optional[bool] = None,
     directives: Iterable[object] = (),
     authenticated: bool = False,
     keys: Iterable[Union["Key", str]] = (),
@@ -54,6 +55,7 @@ def _impl_type(
         Shareable,
         Tag,
     )
+    from strawberry.schema_directives import OneOf
 
     directives = list(directives)
 
@@ -83,6 +85,9 @@ def _impl_type(
     if is_interface_object:
         directives.append(InterfaceObject())
 
+    if one_of:
+        directives.append(OneOf())
+
     return base_type(  # type: ignore
         cls,
         name=name,
@@ -182,6 +187,7 @@ def input(
     cls: T,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
@@ -200,6 +206,7 @@ def input(
     *,
     name: Optional[str] = None,
     description: Optional[str] = None,
+    one_of: Optional[bool] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
     tags: Iterable[str] = (),
@@ -211,6 +218,7 @@ def input(
     cls: Optional[T] = None,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Sequence[object] = (),
     inaccessible: bool = UNSET,
@@ -223,6 +231,7 @@ def input(
         directives=directives,
         inaccessible=inaccessible,
         is_input=True,
+        one_of=one_of,
         tags=tags,
     )
 

strawberry/object_type.py

@@ -272,6 +272,7 @@ def input(
     cls: T,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ) -> T:
@@ -285,6 +286,7 @@ def input(
 def input(
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ) -> Callable[[T], T]:
@@ -295,6 +297,7 @@ def input(
     cls: Optional[T] = None,
     *,
     name: Optional[str] = None,
+    one_of: Optional[bool] = None,
     description: Optional[str] = None,
     directives: Optional[Sequence[object]] = (),
 ):
@@ -305,6 +308,11 @@ def input(
     >>>     field_abc: str = "ABC"
     """
 
+    from strawberry.schema_directives import OneOf
+
+    if one_of:
+        directives = (*(directives or ()), OneOf())
+
     return type(  # type: ignore # not sure why mypy complains here
         cls,
         name=name,

strawberry/schema/execute.py

@@ -23,6 +23,7 @@ from graphql.validation import validate
 
 from strawberry.exceptions import MissingQueryError
 from strawberry.extensions.runner import SchemaExtensionsRunner
+from strawberry.schema.validation_rules.one_of import OneOfInputValidationRule
 from strawberry.types import ExecutionResult
 
 from .exceptions import InvalidOperationTypeError
@@ -55,6 +56,10 @@ def validate_document(
     document: DocumentNode,
     validation_rules: Tuple[Type[ASTValidationRule], ...],
 ) -> List[GraphQLError]:
+    validation_rules = (
+        *validation_rules,
+        OneOfInputValidationRule,
+    )
     return validate(
         schema,
         document,

strawberry/schema/schema.py

@@ -16,6 +16,8 @@ from typing import (
 )
 
 from graphql import (
+    GraphQLBoolean,
+    GraphQLField,
     GraphQLNamedType,
     GraphQLNonNull,
     GraphQLSchema,
@@ -168,6 +170,7 @@ class Schema(BaseSchema):
 
         self._warn_for_federation_directives()
         self._resolve_node_ids()
+        self._extend_introspection()
 
         # Validate schema early because we want developers to know about
         # possible issues as soon as possible
@@ -375,6 +378,14 @@ class Schema(BaseSchema):
                 stacklevel=3,
             )
 
+    def _extend_introspection(self):
+        def _resolve_is_one_of(obj: Any, info: Any) -> bool:
+            return obj.extensions["strawberry-definition"].is_one_of
+
+        instrospection_type = self._schema.type_map["__Type"]
+        instrospection_type.fields["isOneOf"] = GraphQLField(GraphQLBoolean)  # type: ignore[attr-defined]
+        instrospection_type.fields["isOneOf"].resolve = _resolve_is_one_of  # type: ignore[attr-defined]
+
     def as_str(self) -> str:
         return print_schema(self)
 

strawberry/schema/schema_converter.py

@@ -26,6 +26,7 @@ from graphql import (
     GraphQLDirective,
     GraphQLEnumType,
     GraphQLEnumValue,
+    GraphQLError,
     GraphQLField,
     GraphQLInputField,
     GraphQLInputObjectType,
@@ -410,6 +411,37 @@ class GraphQLCoreConverter:
             assert isinstance(graphql_object_type, GraphQLInputObjectType)  # For mypy
             return graphql_object_type
 
+        def check_one_of(value: dict[str, Any]) -> dict[str, Any]:
+            if len(value) != 1:
+                raise GraphQLError(
+                    f"OneOf Input Object '{type_name}' must specify exactly one key."
+                )
+
+            first_key, first_value = next(iter(value.items()))
+
+            if first_value is None or first_value is UNSET:
+                raise GraphQLError(
+                    f"Value for member field '{first_key}' must be non-null"
+                )
+
+            # We are populating all missing keys with `None`, so users
+            # don't have to set an explicit default for the input type
+            # The alternative is to tell them to use `UNSET`, but it looks
+            # a bit unfriendly to use
+
+            for field in type_definition.fields:
+                name = self.config.name_converter.from_field(field)
+                if name not in value:
+                    value[name] = None
+
+            return value
+
+        out_type = (
+            check_one_of
+            if type_definition.is_input and type_definition.is_one_of
+            else None
+        )
+
         graphql_object_type = GraphQLInputObjectType(
             name=type_name,
             fields=lambda: self.get_graphql_input_fields(type_definition),
@@ -417,6 +449,7 @@ class GraphQLCoreConverter:
             extensions={
                 GraphQLCoreConverter.DEFINITION_BACKREF: type_definition,
             },
+            out_type=out_type,
         )
 
         self.type_map[type_name] = ConcreteType(

strawberry/schema/validation_rules/one_of.py

@@ -0,0 +1,80 @@
+from typing import Any
+
+from graphql import (
+    ExecutableDefinitionNode,
+    GraphQLError,
+    GraphQLNamedType,
+    ObjectValueNode,
+    ValidationContext,
+    ValidationRule,
+    VariableDefinitionNode,
+    get_named_type,
+)
+
+
+class OneOfInputValidationRule(ValidationRule):
+    def __init__(self, validation_context: ValidationContext) -> None:
+        super().__init__(validation_context)
+
+    def enter_operation_definition(
+        self, node: ExecutableDefinitionNode, *_args: Any
+    ) -> None:
+        self.variable_definitions: dict[str, VariableDefinitionNode] = {}
+
+    def enter_variable_definition(
+        self, node: VariableDefinitionNode, *_args: Any
+    ) -> None:
+        self.variable_definitions[node.variable.name.value] = node
+
+    def enter_object_value(self, node: ObjectValueNode, *_args: Any) -> None:
+        type_ = get_named_type(self.context.get_input_type())
+
+        if not type_:
+            return
+
+        strawberry_type = type_.extensions.get("strawberry-definition")
+
+        if strawberry_type and strawberry_type.is_one_of:
+            self.validate_one_of(node, type_)
+
+    def validate_one_of(self, node: ObjectValueNode, type: GraphQLNamedType) -> None:
+        field_node_map = {field.name.value: field for field in node.fields}
+        keys = list(field_node_map.keys())
+        is_not_exactly_one_field = len(keys) != 1
+
+        if is_not_exactly_one_field:
+            self.report_error(
+                GraphQLError(
+                    f"OneOf Input Object '{type.name}' must specify exactly one key.",
+                    nodes=[node],
+                )
+            )
+
+            return
+
+        value = field_node_map[keys[0]].value
+        is_null_literal = not value or value.kind == "null_value"
+        is_variable = value.kind == "variable"
+
+        if is_null_literal:
+            self.report_error(
+                GraphQLError(
+                    f"Field '{type.name}.{keys[0]}' must be non-null.",
+                    nodes=[node],
+                )
+            )
+
+            return
+
+        if is_variable:
+            variable_name = value.name.value  # type: ignore
+            definition = self.variable_definitions[variable_name]
+            is_nullable_variable = definition.type.kind != "non_null_type"
+
+            if is_nullable_variable:
+                self.report_error(
+                    GraphQLError(
+                        f"Variable '{variable_name}' must be non-nullable to be used for OneOf Input Object '{type.name}'.",
+                        nodes=[node],
+                    )
+                )

strawberry/schema_codegen/__init__.py

@@ -7,7 +7,6 @@ from typing import TYPE_CHECKING, List, Tuple, Union
 from typing_extensions import Protocol, TypeAlias
 
 import libcst as cst
-from graphlib import TopologicalSorter
 from graphql import (
     EnumTypeDefinitionNode,
     EnumValueDefinitionNode,
@@ -178,6 +177,19 @@ def _get_argument(name: str, value: ArgumentValue) -> cst.Arg:
     )
 
 
+# TODO: this might be removed now
+def _get_argument_list(name: str, values: list[ArgumentValue]) -> cst.Arg:
+    value = cst.List(
+        elements=[cst.Element(value=_sanitize_argument(value)) for value in values],
+    )
+
+    return cst.Arg(
+        value=value,
+        keyword=cst.Name(name),
+        equal=cst.AssignEqual(cst.SimpleWhitespace(""), cst.SimpleWhitespace("")),
+    )
+
+
 def _get_field_value(
     field: FieldDefinitionNode | InputValueDefinitionNode,
     alias: str | None,
@@ -429,11 +441,11 @@ def _get_class_definition(
     | InputObjectTypeDefinitionNode,
     is_apollo_federation: bool,
     imports: set[Import],
-) -> Definition:
+) -> cst.ClassDef:
     decorator = _get_strawberry_decorator(definition, is_apollo_federation, imports)
 
-    interfaces = (
-        [interface.name.value for interface in definition.interfaces]
+    bases = (
+        [cst.Arg(cst.Name(interface.name.value)) for interface in definition.interfaces]
         if isinstance(
             definition, (ObjectTypeDefinitionNode, InterfaceTypeDefinitionNode)
         )
@@ -441,24 +453,21 @@ def _get_class_definition(
         else []
     )
 
-    class_definition = cst.ClassDef(
+    return cst.ClassDef(
         name=cst.Name(definition.name.value),
+        bases=bases,
         body=cst.IndentedBlock(
             body=[
                 _get_field(field, is_apollo_federation, imports)
                 for field in definition.fields
             ]
         ),
-        bases=[cst.Arg(cst.Name(interface)) for interface in interfaces],
         decorators=[decorator],
     )
 
-    return Definition(class_definition, interfaces, definition.name.value)
-
 
 def _get_enum_value(enum_value: EnumValueDefinitionNode) -> cst.SimpleStatementLine:
     name = enum_value.name.value
-
     return cst.SimpleStatementLine(
         body=[
             cst.Assign(
@@ -469,7 +478,7 @@ def _get_enum_value(enum_value: EnumValueDefinitionNode) -> cst.SimpleStatementL
     )
 
 
-def _get_enum_definition(definition: EnumTypeDefinitionNode) -> Definition:
+def _get_enum_definition(definition: EnumTypeDefinitionNode) -> cst.ClassDef:
     decorator = cst.Decorator(
         decorator=cst.Attribute(
             value=cst.Name("strawberry"),
@@ -477,7 +486,7 @@ def _get_enum_definition(definition: EnumTypeDefinitionNode) -> Definition:
         ),
     )
 
-    class_definition = cst.ClassDef(
+    return cst.ClassDef(
         name=cst.Name(definition.name.value),
         bases=[cst.Arg(cst.Name("Enum"))],
         body=cst.IndentedBlock(
@@ -486,12 +495,6 @@ def _get_enum_definition(definition: EnumTypeDefinitionNode) -> Definition:
         decorators=[decorator],
     )
 
-    return Definition(
-        class_definition,
-        [],
-        definition.name.value,
-    )
-
 
 def _get_schema_definition(
     root_query_name: str | None,
@@ -559,54 +562,38 @@ def _get_schema_definition(
     )
 
 
-@dataclasses.dataclass(frozen=True)
-class Definition:
-    code: cst.CSTNode
-    dependencies: list[str]
-    name: str
-
-
-def _get_union_definition(definition: UnionTypeDefinitionNode) -> Definition:
+def _get_union_definition(definition: UnionTypeDefinitionNode) -> cst.Assign:
     name = definition.name.value
 
     types = cst.parse_expression(
         " | ".join([type_.name.value for type_ in definition.types])
     )
 
-    simple_statement = cst.SimpleStatementLine(
-        body=[
-            cst.Assign(
-                targets=[cst.AssignTarget(cst.Name(name))],
-                value=cst.Subscript(
-                    value=cst.Name("Annotated"),
-                    slice=[
-                        cst.SubscriptElement(slice=cst.Index(types)),
-                        cst.SubscriptElement(
-                            slice=cst.Index(
-                                cst.Call(
-                                    cst.Attribute(
-                                        value=cst.Name("strawberry"),
-                                        attr=cst.Name("union"),
-                                    ),
-                                    args=[_get_argument("name", name)],
-                                )
-                            )
-                        ),
-                    ],
+    return cst.Assign(
+        targets=[cst.AssignTarget(cst.Name(name))],
+        value=cst.Subscript(
+            value=cst.Name("Annotated"),
+            slice=[
+                cst.SubscriptElement(slice=cst.Index(types)),
+                cst.SubscriptElement(
+                    slice=cst.Index(
+                        cst.Call(
+                            cst.Attribute(
+                                value=cst.Name("strawberry"),
+                                attr=cst.Name("union"),
+                            ),
+                            args=[_get_argument("name", name)],
+                        )
+                    )
                 ),
-            )
-        ]
-    )
-    return Definition(
-        simple_statement,
-        [],
-        definition.name.value,
+            ],
+        ),
     )
 
 
 def _get_scalar_definition(
     definition: ScalarTypeDefinitionNode, imports: set[Import]
-) -> Definition | None:
+) -> cst.SimpleStatementLine | None:
     name = definition.name.value
 
     if name == "Date":
@@ -665,7 +652,7 @@ def _get_scalar_definition(
         ),
     ]
 
-    statement_definition = cst.SimpleStatementLine(
+    return cst.SimpleStatementLine(
         body=[
             cst.Assign(
                 targets=[cst.AssignTarget(cst.Name(name))],
@@ -690,13 +677,12 @@ def _get_scalar_definition(
             )
         ]
     )
-    return Definition(statement_definition, [], name=definition.name.value)
 
 
 def codegen(schema: str) -> str:
     document = parse(schema)
 
-    definitions: dict[str, Definition] = {}
+    definitions: list[cst.CSTNode] = []
 
     root_query_name: str | None = None
     root_mutation_name: str | None = None
@@ -706,17 +692,17 @@ def codegen(schema: str) -> str:
         Import(module=None, imports=("strawberry",)),
     }
 
+    object_types: dict[str, cst.ClassDef] = {}
+
     # when we encounter a extend schema @link ..., we check if is an apollo federation schema
     # and we use this variable to keep track of it, but at the moment the assumption is that
     # the schema extension is always done at the top, this might not be the case all the
     # time
     is_apollo_federation = False
 
-    for graphql_definition in document.definitions:
-        definition: Definition | None = None
-
+    for definition in document.definitions:
         if isinstance(
-            graphql_definition,
+            definition,
             (
                 ObjectTypeDefinitionNode,
                 InterfaceTypeDefinitionNode,
@@ -724,17 +710,23 @@ def codegen(schema: str) -> str:
                 ObjectTypeExtensionNode,
             ),
         ):
-            definition = _get_class_definition(
-                graphql_definition, is_apollo_federation, imports
+            class_definition = _get_class_definition(
+                definition, is_apollo_federation, imports
             )
 
-        elif isinstance(graphql_definition, EnumTypeDefinitionNode):
+            object_types[definition.name.value] = class_definition
+
+            definitions.append(cst.EmptyLine())
+            definitions.append(class_definition)
+
+        elif isinstance(definition, EnumTypeDefinitionNode):
             imports.add(Import(module="enum", imports=("Enum",)))
 
-            definition = _get_enum_definition(graphql_definition)
+            definitions.append(cst.EmptyLine())
+            definitions.append(_get_enum_definition(definition))
 
-        elif isinstance(graphql_definition, SchemaDefinitionNode):
-            for operation_type_definition in graphql_definition.operation_types:
+        elif isinstance(definition, SchemaDefinitionNode):
+            for operation_type_definition in definition.operation_types:
                 if operation_type_definition.operation == OperationType.QUERY:
                     root_query_name = operation_type_definition.type.name.value
                 elif operation_type_definition.operation == OperationType.MUTATION:
@@ -745,33 +737,36 @@ def codegen(schema: str) -> str:
                     raise NotImplementedError(
                         f"Unknown operation {operation_type_definition.operation}"
                     )
-        elif isinstance(graphql_definition, UnionTypeDefinitionNode):
+        elif isinstance(definition, UnionTypeDefinitionNode):
             imports.add(Import(module="typing", imports=("Annotated",)))
 
-            definition = _get_union_definition(graphql_definition)
-        elif isinstance(graphql_definition, ScalarTypeDefinitionNode):
-            definition = _get_scalar_definition(graphql_definition, imports)
-
-        elif isinstance(graphql_definition, SchemaExtensionNode):
+            definitions.append(cst.EmptyLine())
+            definitions.append(_get_union_definition(definition))
+            definitions.append(cst.EmptyLine())
+        elif isinstance(definition, ScalarTypeDefinitionNode):
+            scalar_definition = _get_scalar_definition(definition, imports)
+
+            if scalar_definition is not None:
+                definitions.append(cst.EmptyLine())
+                definitions.append(scalar_definition)
+                definitions.append(cst.EmptyLine())
+        elif isinstance(definition, SchemaExtensionNode):
             is_apollo_federation = any(
                 _is_federation_link_directive(directive)
-                for directive in graphql_definition.directives
+                for directive in definition.directives
             )
         else:
             raise NotImplementedError(f"Unknown definition {definition}")
 
-        if definition is not None:
-            definitions[definition.name] = definition
-
     if root_query_name is None:
-        root_query_name = "Query" if "Query" in definitions else None
+        root_query_name = "Query" if "Query" in object_types else None
 
     if root_mutation_name is None:
-        root_mutation_name = "Mutation" if "Mutation" in definitions else None
+        root_mutation_name = "Mutation" if "Mutation" in object_types else None
 
     if root_subscription_name is None:
         root_subscription_name = (
-            "Subscription" if "Subscription" in definitions else None
+            "Subscription" if "Subscription" in object_types else None
         )
 
     schema_definition = _get_schema_definition(
@@ -782,23 +777,19 @@ def codegen(schema: str) -> str:
     )
 
     if schema_definition:
-        definitions["Schema"] = Definition(schema_definition, [], "schema")
-
-    body: list[cst.CSTNode] = [
-        cst.SimpleStatementLine(body=[import_.to_cst()])
-        for import_ in sorted(imports, key=lambda i: (i.module or "", i.imports))
-    ]
-
-    # DAG to sort definitions based on dependencies
-    graph = {name: definition.dependencies for name, definition in definitions.items()}
-    ts = TopologicalSorter(graph)
-
-    for definition_name in tuple(ts.static_order()):
-        definition = definitions[definition_name]
-
-        body.append(cst.EmptyLine())
-        body.append(definition.code)
+        definitions.append(cst.EmptyLine())
+        definitions.append(schema_definition)
 
-    module = cst.Module(body=body)  # type: ignore
+    module = cst.Module(
+        body=[
+            *[
+                cst.SimpleStatementLine(body=[import_.to_cst()])
+                for import_ in sorted(
+                    imports, key=lambda i: (i.module or "", i.imports)
+                )
+            ],
+            *definitions,  # type: ignore
+        ]
+    )
 
     return module.code

strawberry/schema_directives.py

@@ -0,0 +1,9 @@
+from strawberry.schema_directive import Location, schema_directive
+
+
+@schema_directive(locations=[Location.INPUT_OBJECT], name="oneOf")
+class OneOf:
+    ...
+
+
+__all__ = ["OneOf"]

strawberry/type.py

@@ -37,6 +37,10 @@ class StrawberryType(ABC):
     def type_params(self) -> List[TypeVar]:
         return []
 
+    @property
+    def is_one_of(self) -> bool:
+        return False
+
     @abstractmethod
     def copy_with(
         self,

strawberry/types/types.py

@@ -197,6 +197,17 @@ class StrawberryObjectDefinition(StrawberryType):
         # All field mappings succeeded. This is a match
         return True
 
+    @property
+    def is_one_of(self) -> bool:
+        from strawberry.schema_directives import OneOf
+
+        if not self.is_input or not self.directives:
+            return False
+
+        return any(
+            directive for directive in self.directives if isinstance(directive, OneOf)
+        )
+
 
 # TODO: remove when deprecating _type_definition
 if TYPE_CHECKING:

{strawberry_graphql-0.227.0.dist-info → strawberry_graphql-0.227.0.dev1713475585.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.227.0
+Version: 0.227.0.dev1713475585
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT
@@ -44,7 +44,6 @@ Requires-Dist: chalice (>=1.22,<2.0) ; extra == "chalice"
 Requires-Dist: channels (>=3.0.5) ; extra == "channels"
 Requires-Dist: fastapi (>=0.65.2) ; extra == "fastapi"
 Requires-Dist: flask (>=1.1) ; extra == "flask"
-Requires-Dist: graphlib_backport ; (python_version < "3.9") and (extra == "cli")
 Requires-Dist: graphql-core (>=3.2.0,<3.3.0)
 Requires-Dist: libcst (>=0.4.7) ; extra == "debug" or extra == "debug-server" or extra == "cli"
 Requires-Dist: litestar (>=2) ; (python_version >= "3.8") and (extra == "litestar")

{strawberry_graphql-0.227.0.dist-info → strawberry_graphql-0.227.0.dev1713475585.dist-info}/RECORD

@@ -96,7 +96,7 @@ strawberry/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/ext/dataclasses/LICENSE,sha256=WZgm35K_3NJwLqxpEHJJi7CWxVrwTumEz5D3Dtd7WnA,13925
 strawberry/ext/dataclasses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 strawberry/ext/dataclasses/dataclasses.py,sha256=Le32f96qmahuenVsMW5xjIr-EPnO7WKljbOPLpU800Q,2254
-strawberry/ext/mypy_plugin.py,sha256=iqqRtJk3YRt1-rxDDl7aa9QtxZ0QYcu9-o6OWaczkqo,19716
+strawberry/ext/mypy_plugin.py,sha256=AGWu3xTguWMetqQP7bnaLRJBdLplPOtZ_eRGYt0Gfg8,18956
 strawberry/extensions/__init__.py,sha256=SZ-YEMnxAzoDZFo-uHXMHOaY_PPkYm1muPpK4ccJ3Xk,1248
 strawberry/extensions/add_validation_rules.py,sha256=l1cCl6VGQ8c2EELK3cIjmn6RftonHD1jKoWQ5-hMTf0,1366
 strawberry/extensions/base_extension.py,sha256=XvYKIsSaxfTCVWdphOFll-Fo0wJd5Ib4QdKuYule6S0,2000
@@ -130,7 +130,7 @@ strawberry/federation/argument.py,sha256=5qyJYlQGEZd6iXWseQ7dnnejCYj5HyglfK10jOC
 strawberry/federation/enum.py,sha256=wpM1z2NOkoBCqTVyD6vJJXoNlcnrNIERt2YpB4R9ybU,2977
 strawberry/federation/field.py,sha256=HHOs8FL52_jxuYxPiR2EwJsXtk7LyapJeBUPqvJ6pCg,6184
 strawberry/federation/mutation.py,sha256=0lV5HJwgw4HYR_59pwxWqnPs342HwakTNMc98w5Hb-c,43
-strawberry/federation/object_type.py,sha256=nQLFbuS6KvAnGCGie_KXxjmtJC6gnQZFh5FAwFHTH-c,9037
+strawberry/federation/object_type.py,sha256=moxIUYxs7n0WdjtEWhoTesmZ63ymIr_U1qIuaiNrvhY,9302
 strawberry/federation/scalar.py,sha256=jrSvaqfGEnj_Vl7b-LYMdq_NDMwfdu0t5Pfzlw5WAmU,3807
 strawberry/federation/schema.py,sha256=9g7jp6eUTTP3atW81dLMtaqeY0tQB4YGdR8beKZ-JX8,13715
 strawberry/federation/schema_directive.py,sha256=TpqoVeN3-iE-acndIRAVyU4LIXh6FTHz-Pv2kI8zGu0,1719
@@ -160,7 +160,7 @@ strawberry/litestar/controller.py,sha256=CPVnXA36O3OQb9NnHdD3ycox21rarjrS-I2HiOO
 strawberry/litestar/handlers/graphql_transport_ws_handler.py,sha256=q_erlgzPsxarohRQXGp1yK0mjKyS8vsWntMYEmrQx4s,2008
 strawberry/litestar/handlers/graphql_ws_handler.py,sha256=vVpjd5rJOldF8aQWEGjmmNd60WE1p6q6hFmB_DtCzDU,2250
 strawberry/mutation.py,sha256=NROPvHJU1BBxZB7Wj4Okxw4hDIYM59MCpukAGEmSNYA,255
-strawberry/object_type.py,sha256=PLCGcSkibQVU3Kb47OnysAKHWbzBTPgeIiKmiwmkUa4,11398
+strawberry/object_type.py,sha256=90KgHnOnAY_rlbqMs_89gurmLQmRH9X7PIuh12z6YGs,11623
 strawberry/parent.py,sha256=mCnJcLBQKwtokXcGxkm5HqGg7Wkst97rn61ViuaotrM,829
 strawberry/permission.py,sha256=dcKx4Zlg4ZhcxEDBOSWzz0CUN4WPkcc_kJUVuvLLs6w,5925
 strawberry/printer/__init__.py,sha256=DmepjmgtkdF5RxK_7yC6qUyRWn56U-9qeZMbkztYB9w,62
@@ -186,16 +186,19 @@ strawberry/schema/base.py,sha256=lQBJyzG2ZhKc544oLbXEbpYOPOjaXBop3lxp68h_lfI,297
 strawberry/schema/compat.py,sha256=n0r3UPUcGemMqK8vklgtCkkuCA1p6tWAYbc6Vl4iNOw,1684
 strawberry/schema/config.py,sha256=XkWwmxEsmecscH29o4qU0iSe-hgwJJ2X0DPBVlka2OE,640
 strawberry/schema/exceptions.py,sha256=T-DsvBtjx9svkegIm1YrVPGPswpVEpMTFc0_7flLEkM,542
-strawberry/schema/execute.py,sha256=6OE7_5v4G3t_wxp1_mfwu8TTiIkTJNBQaeGCVAljUYw,10982
+strawberry/schema/execute.py,sha256=dwxMrJrR2Qdd1nPGcIS9-Viq7h5qtPfsD6qdujALoMw,11153
 strawberry/schema/name_converter.py,sha256=UdNyd-QtqF2HsDCQK-nsOcLGxDTj4hJwYFNvMtZnpq4,6533
-strawberry/schema/schema.py,sha256=MOC8k6NHolFGrCyqrungv0ciCImLdXTlbmo7y7rLRas,13734
-strawberry/schema/schema_converter.py,sha256=DT6HWJeTdaFuEoVzlVGeEIXeg_vdaiJ4YGSakXaRTlQ,34785
+strawberry/schema/schema.py,sha256=bfQdLmFXR_BQd80IGO8qa0431cQMUDr22XLNnBL7Tu0,14252
+strawberry/schema/schema_converter.py,sha256=_DfYbWLhbtjBR-w596O5xUwTd3OvHS0P7e5G52JaKXI,35956
 strawberry/schema/types/__init__.py,sha256=oHO3COWhL3L1KLYCJNY1XFf5xt2GGtHiMC-UaYbFfnA,68
 strawberry/schema/types/base_scalars.py,sha256=Z_BmgwLicNexLipGyw6MmZ7OBnkGJU3ySgaY9SwBWrw,1837
 strawberry/schema/types/concrete_type.py,sha256=HB30G1hMUuuvjAvfSe6ADS35iI_T_wKO-EprVOWTMSs,746
 strawberry/schema/types/scalar.py,sha256=SVJ8HiKncCvOw2xwABI5xYaHcC7KkGHG-tx2WDtSoCA,2802
-strawberry/schema_codegen/__init__.py,sha256=PcCVXjS0Y5Buxadm07YAZOVunkQ_DmmwsBrgsH1T4ds,24375
+strawberry/schema/validation_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+strawberry/schema/validation_rules/one_of.py,sha256=hO0Re1fQQWT9zIqo_7BHLM2bdSsmNJDbKia8AUTSXQQ,2588
+strawberry/schema_codegen/__init__.py,sha256=eHHr59CLzIlqb9b5h4PLK6RNPPvUHIJCQ0sAJa2l4aw,24059
 strawberry/schema_directive.py,sha256=GxiOedFB-RJAflpQNUZv00C5Z6gavR-AYdsvoCA_0jc,1963
+strawberry/schema_directives.py,sha256=ZcaTeFfxBp5RsmVu2NDPP_hOL2WpPomQIQSmNp9BO3s,179
 strawberry/starlite/__init__.py,sha256=v209swT8H9MljVL-npvANhEO1zz3__PSfxb_Ix-NoeE,134
 strawberry/starlite/controller.py,sha256=oyGkcdhIKvY5BCxVqPhS-pn7Ae8SZKXnI5W5fk4p0zw,11916
 strawberry/starlite/handlers/graphql_transport_ws_handler.py,sha256=WhfFVWdjRSk4A48MaBLGWqZdi2OnHajxdQlA_Gc4XBE,1981
@@ -216,7 +219,7 @@ strawberry/test/client.py,sha256=N_AkxLp-kWVTgQDcL8FkruJpAd6NpkChIDptzneu_uM,575
 strawberry/tools/__init__.py,sha256=pdGpZx8wpq03VfUZJyF9JtYxZhGqzzxCiipsalWxJX4,127
 strawberry/tools/create_type.py,sha256=QxLRT9-DrSgo6vsu_L818wtlbO3wRtI0dOos0gmn1xk,1593
 strawberry/tools/merge_types.py,sha256=YZ2GSMoDD82bfuvCT0COpN6SLFVRZpTXFFm9LHUyi10,1014
-strawberry/type.py,sha256=10Pv74x4Yn2woztdlKe0YLnm46FfHN9c2v7Hq2cRlAA,6534
+strawberry/type.py,sha256=jQh75TjgaKx1mP-AF6VjWacDAqbHABQuW06vrnsArnM,6603
 strawberry/types/__init__.py,sha256=APb1Cjy6bxqFxIfDfempP6eb9NE3LYDwQ3gX7r07lXI,139
 strawberry/types/execution.py,sha256=Dz4Y_M1ysKz3UxnBK_-h103DjvP6NwLElXXOEpQCkgw,2783
 strawberry/types/fields/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -225,7 +228,7 @@ strawberry/types/graphql.py,sha256=3SWZEsa0Zy1eVW6vy75BnB7t9_lJVi6TBV3_1j3RNBs,6
 strawberry/types/info.py,sha256=b1ZWW_wUop6XrGNcGHKBQeUYjlX-y8u3s2Wm_XhKPYI,3412
 strawberry/types/nodes.py,sha256=5tTYmxGpVDshbydicHTTBWEiUe8A7p7mdiaSV8Ry80Y,5027
 strawberry/types/type_resolver.py,sha256=F0z_geS4VEun8EhD571LaTgI8ypjCeLfp910gF0Q3MY,6280
-strawberry/types/types.py,sha256=3zKJLPv4KW-BL4WspK-ik4acnLMR0bCPLoy1QHSSAvA,7147
+strawberry/types/types.py,sha256=2iUj5ohnpXYTIEvwk1i-4LVasO0IuLv9GUJgd_jp7GM,7447
 strawberry/union.py,sha256=IyC1emthtgoEGDOrEOpicC7QyQ0sUexXMx4BT6tFIF8,9951
 strawberry/unset.py,sha256=4zYRN8vUD7lHQLLpulBFqEPfyvzpx8fl7ZDBUyfMqqk,1112
 strawberry/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -241,8 +244,8 @@ strawberry/utils/logging.py,sha256=flS7hV0JiIOEdXcrIjda4WyIWix86cpHHFNJL8gl1y4,7
 strawberry/utils/operation.py,sha256=Um-tBCPl3_bVFN2Ph7o1mnrxfxBes4HFCj6T0x4kZxE,1135
 strawberry/utils/str_converters.py,sha256=avIgPVLg98vZH9mA2lhzVdyyjqzLsK2NdBw9mJQ02Xk,813
 strawberry/utils/typing.py,sha256=Qxz1LwyVsNGV7LQW1dFsaUbsswj5LHBOdKLMom5eyEA,13491
-strawberry_graphql-0.227.0.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
-strawberry_graphql-0.227.0.dist-info/METADATA,sha256=grpZvkO1P_V-BSe8ZOhiSD-ILvdwVDrzlsHJKoDDqn8,7821
-strawberry_graphql-0.227.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-strawberry_graphql-0.227.0.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
-strawberry_graphql-0.227.0.dist-info/RECORD,,
+strawberry_graphql-0.227.0.dev1713475585.dist-info/LICENSE,sha256=m-XnIVUKqlG_AWnfi9NReh9JfKhYOB-gJfKE45WM1W8,1072
+strawberry_graphql-0.227.0.dev1713475585.dist-info/METADATA,sha256=Hl3n4V8EBrYh2QrTGqWT7F08HZDuWGKUZNB7JchFx_s,7754
+strawberry_graphql-0.227.0.dev1713475585.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+strawberry_graphql-0.227.0.dev1713475585.dist-info/entry_points.txt,sha256=Nk7-aT3_uEwCgyqtHESV9H6Mc31cK-VAvhnQNTzTb4k,49
+strawberry_graphql-0.227.0.dev1713475585.dist-info/RECORD,,