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

strawberry/schema_codegen/__init__.py

@@ -7,6 +7,7 @@ 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,
@@ -177,19 +178,6 @@ 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,
@@ -441,11 +429,11 @@ def _get_class_definition(
     | InputObjectTypeDefinitionNode,
     is_apollo_federation: bool,
     imports: set[Import],
-) -> cst.ClassDef:
+) -> Definition:
     decorator = _get_strawberry_decorator(definition, is_apollo_federation, imports)
 
-    bases = (
-        [cst.Arg(cst.Name(interface.name.value)) for interface in definition.interfaces]
+    interfaces = (
+        [interface.name.value for interface in definition.interfaces]
         if isinstance(
             definition, (ObjectTypeDefinitionNode, InterfaceTypeDefinitionNode)
         )
@@ -453,21 +441,24 @@ def _get_class_definition(
         else []
     )
 
-    return cst.ClassDef(
+    class_definition = 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(
@@ -478,7 +469,7 @@ def _get_enum_value(enum_value: EnumValueDefinitionNode) -> cst.SimpleStatementL
     )
 
 
-def _get_enum_definition(definition: EnumTypeDefinitionNode) -> cst.ClassDef:
+def _get_enum_definition(definition: EnumTypeDefinitionNode) -> Definition:
     decorator = cst.Decorator(
         decorator=cst.Attribute(
             value=cst.Name("strawberry"),
@@ -486,7 +477,7 @@ def _get_enum_definition(definition: EnumTypeDefinitionNode) -> cst.ClassDef:
         ),
     )
 
-    return cst.ClassDef(
+    class_definition = cst.ClassDef(
         name=cst.Name(definition.name.value),
         bases=[cst.Arg(cst.Name("Enum"))],
         body=cst.IndentedBlock(
@@ -495,6 +486,12 @@ def _get_enum_definition(definition: EnumTypeDefinitionNode) -> cst.ClassDef:
         decorators=[decorator],
     )
 
+    return Definition(
+        class_definition,
+        [],
+        definition.name.value,
+    )
+
 
 def _get_schema_definition(
     root_query_name: str | None,
@@ -562,38 +559,54 @@ def _get_schema_definition(
     )
 
 
-def _get_union_definition(definition: UnionTypeDefinitionNode) -> cst.Assign:
+@dataclasses.dataclass(frozen=True)
+class Definition:
+    code: cst.CSTNode
+    dependencies: list[str]
+    name: str
+
+
+def _get_union_definition(definition: UnionTypeDefinitionNode) -> Definition:
     name = definition.name.value
 
     types = cst.parse_expression(
         " | ".join([type_.name.value for type_ in definition.types])
     )
 
-    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)],
-                        )
-                    )
+    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 Definition(
+        simple_statement,
+        [],
+        definition.name.value,
     )
 
 
 def _get_scalar_definition(
     definition: ScalarTypeDefinitionNode, imports: set[Import]
-) -> cst.SimpleStatementLine | None:
+) -> Definition | None:
     name = definition.name.value
 
     if name == "Date":
@@ -652,7 +665,7 @@ def _get_scalar_definition(
         ),
     ]
 
-    return cst.SimpleStatementLine(
+    statement_definition = cst.SimpleStatementLine(
         body=[
             cst.Assign(
                 targets=[cst.AssignTarget(cst.Name(name))],
@@ -677,12 +690,13 @@ def _get_scalar_definition(
             )
         ]
     )
+    return Definition(statement_definition, [], name=definition.name.value)
 
 
 def codegen(schema: str) -> str:
     document = parse(schema)
 
-    definitions: list[cst.CSTNode] = []
+    definitions: dict[str, Definition] = {}
 
     root_query_name: str | None = None
     root_mutation_name: str | None = None
@@ -692,17 +706,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 definition in document.definitions:
+    for graphql_definition in document.definitions:
+        definition: Definition | None = None
+
         if isinstance(
-            definition,
+            graphql_definition,
             (
                 ObjectTypeDefinitionNode,
                 InterfaceTypeDefinitionNode,
@@ -710,23 +724,17 @@ def codegen(schema: str) -> str:
                 ObjectTypeExtensionNode,
             ),
         ):
-            class_definition = _get_class_definition(
-                definition, is_apollo_federation, imports
+            definition = _get_class_definition(
+                graphql_definition, is_apollo_federation, imports
             )
 
-            object_types[definition.name.value] = class_definition
-
-            definitions.append(cst.EmptyLine())
-            definitions.append(class_definition)
-
-        elif isinstance(definition, EnumTypeDefinitionNode):
+        elif isinstance(graphql_definition, EnumTypeDefinitionNode):
             imports.add(Import(module="enum", imports=("Enum",)))
 
-            definitions.append(cst.EmptyLine())
-            definitions.append(_get_enum_definition(definition))
+            definition = _get_enum_definition(graphql_definition)
 
-        elif isinstance(definition, SchemaDefinitionNode):
-            for operation_type_definition in definition.operation_types:
+        elif isinstance(graphql_definition, SchemaDefinitionNode):
+            for operation_type_definition in graphql_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:
@@ -737,36 +745,33 @@ def codegen(schema: str) -> str:
                     raise NotImplementedError(
                         f"Unknown operation {operation_type_definition.operation}"
                     )
-        elif isinstance(definition, UnionTypeDefinitionNode):
+        elif isinstance(graphql_definition, UnionTypeDefinitionNode):
             imports.add(Import(module="typing", imports=("Annotated",)))
 
-            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):
+            definition = _get_union_definition(graphql_definition)
+        elif isinstance(graphql_definition, ScalarTypeDefinitionNode):
+            definition = _get_scalar_definition(graphql_definition, imports)
+
+        elif isinstance(graphql_definition, SchemaExtensionNode):
             is_apollo_federation = any(
                 _is_federation_link_directive(directive)
-                for directive in definition.directives
+                for directive in graphql_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 object_types else None
+        root_query_name = "Query" if "Query" in definitions else None
 
     if root_mutation_name is None:
-        root_mutation_name = "Mutation" if "Mutation" in object_types else None
+        root_mutation_name = "Mutation" if "Mutation" in definitions else None
 
     if root_subscription_name is None:
         root_subscription_name = (
-            "Subscription" if "Subscription" in object_types else None
+            "Subscription" if "Subscription" in definitions else None
         )
 
     schema_definition = _get_schema_definition(
@@ -777,19 +782,23 @@ def codegen(schema: str) -> str:
     )
 
     if schema_definition:
-        definitions.append(cst.EmptyLine())
-        definitions.append(schema_definition)
+        definitions["Schema"] = Definition(schema_definition, [], "schema")
 
-    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
-        ]
-    )
+    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)
+
+    module = cst.Module(body=body)  # type: ignore
 
     return module.code

strawberry/schema_directive.py

@@ -54,7 +54,7 @@ def schema_directive(
 ) -> Callable[..., T]:
     def _wrap(cls: T) -> T:
         cls = _wrap_dataclass(cls)
-        fields = _get_fields(cls)
+        fields = _get_fields(cls, {})
 
         cls.__strawberry_directive__ = StrawberrySchemaDirective(
             python_name=cls.__name__,

strawberry/starlite/controller.py

@@ -222,9 +222,9 @@ def make_graphql_controller(
             "response": Provide(response_getter),
         }
         graphql_ws_handler_class: Type[GraphQLWSHandler] = GraphQLWSHandler
-        graphql_transport_ws_handler_class: Type[
+        graphql_transport_ws_handler_class: Type[GraphQLTransportWSHandler] = (
             GraphQLTransportWSHandler
-        ] = GraphQLTransportWSHandler
+        )
 
         _keep_alive: bool = keep_alive
         _keep_alive_interval: float = keep_alive_interval

strawberry/type.py

@@ -37,10 +37,6 @@ class StrawberryType(ABC):
     def type_params(self) -> List[TypeVar]:
         return []
 
-    @property
-    def is_one_of(self) -> bool:
-        return False
-
     @abstractmethod
     def copy_with(
         self,
@@ -147,12 +143,10 @@ class StrawberryContainer(StrawberryType):
         return False
 
 
-class StrawberryList(StrawberryContainer):
-    ...
+class StrawberryList(StrawberryContainer): ...
 
 
-class StrawberryOptional(StrawberryContainer):
-    ...
+class StrawberryOptional(StrawberryContainer): ...
 
 
 class StrawberryTypeVar(StrawberryType):
@@ -212,8 +206,7 @@ def get_object_definition(
     obj: Any,
     *,
     strict: Literal[True],
-) -> StrawberryObjectDefinition:
-    ...
+) -> StrawberryObjectDefinition: ...
 
 
 @overload
@@ -221,8 +214,7 @@ def get_object_definition(
     obj: Any,
     *,
     strict: bool = False,
-) -> Optional[StrawberryObjectDefinition]:
-    ...
+) -> Optional[StrawberryObjectDefinition]: ...
 
 
 def get_object_definition(

strawberry/types/type_resolver.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 import sys
-from typing import Dict, List, Type
+from typing import Any, Dict, List, Type
 
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.exceptions import (
@@ -16,7 +16,9 @@ from strawberry.type import has_object_definition
 from strawberry.unset import UNSET
 
 
-def _get_fields(cls: Type) -> List[StrawberryField]:
+def _get_fields(
+    cls: Type[Any], original_type_annotations: Dict[str, Type[Any]]
+) -> List[StrawberryField]:
     """Get all the strawberry fields off a strawberry.type cls
 
     This function returns a list of StrawberryFields (one for each field item), while
@@ -49,6 +51,7 @@ def _get_fields(cls: Type) -> List[StrawberryField]:
     passing a named function (i.e. not an anonymous lambda) to strawberry.field
     (typically as a decorator).
     """
+
     fields: Dict[str, StrawberryField] = {}
 
     # before trying to find any fields, let's first add the fields defined in
@@ -152,6 +155,10 @@ def _get_fields(cls: Type) -> List[StrawberryField]:
         assert_message = "Field must have a name by the time the schema is generated"
         assert field_name is not None, assert_message
 
+        if field.name in original_type_annotations:
+            field.type = original_type_annotations[field.name]
+            field.type_annotation = StrawberryAnnotation(annotation=field.type)
+
         # TODO: Raise exception if field_name already in fields
         fields[field_name] = field
 

strawberry/types/types.py

@@ -197,24 +197,12 @@ 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:
 
     @deprecated("Use StrawberryObjectDefinition instead")
-    class TypeDefinition(StrawberryObjectDefinition):
-        ...
+    class TypeDefinition(StrawberryObjectDefinition): ...
 
 else:
     TypeDefinition = StrawberryObjectDefinition

strawberry/utils/aio.py

@@ -24,7 +24,7 @@ async def aenumerate(
     i = 0
     async for element in iterable:
         yield i, element
-        i += 1  # noqa: SIM113
+        i += 1
 
 
 async def aislice(

strawberry/utils/typing.py

@@ -204,13 +204,11 @@ def get_parameters(annotation: Type) -> Union[Tuple[object], Tuple[()]]:
 
 
 @overload
-def _ast_replace_union_operation(expr: ast.expr) -> ast.expr:
-    ...
+def _ast_replace_union_operation(expr: ast.expr) -> ast.expr: ...
 
 
 @overload
-def _ast_replace_union_operation(expr: ast.Expr) -> ast.Expr:
-    ...
+def _ast_replace_union_operation(expr: ast.Expr) -> ast.Expr: ...
 
 
 def _ast_replace_union_operation(

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.227.0.dev1713475585
+Version: 0.227.2
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT
@@ -44,6 +44,7 @@ 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")