strawberry-graphql 0.254.1__py3-none-any.whl → 0.256.0__py3-none-any.whl

strawberry/http/ides.py

@@ -22,4 +22,4 @@ def get_graphql_ide_html(
     return template
 
 
-__all__ = ["get_graphql_ide_html", "GraphQL_IDE"]
+__all__ = ["GraphQL_IDE", "get_graphql_ide_html"]

strawberry/http/parse_content_type.py

@@ -1,8 +1,7 @@
 from email.message import Message
-from typing import Dict, Tuple
 
 
-def parse_content_type(content_type: str) -> Tuple[str, Dict[str, str]]:
+def parse_content_type(content_type: str) -> tuple[str, dict[str, str]]:
     """Parse a content type header into a mime-type and a dictionary of parameters."""
     email = Message()
     email["content-type"] = content_type

strawberry/http/sync_base_view.py

@@ -1,12 +1,10 @@
 import abc
 import json
+from collections.abc import Mapping
 from typing import (
     Any,
     Callable,
-    Dict,
     Generic,
-    List,
-    Mapping,
     Optional,
     Union,
 )
@@ -126,7 +124,7 @@ class SyncBaseHTTPView(
             allowed_operation_types=allowed_operation_types,
         )
 
-    def parse_multipart(self, request: SyncHTTPRequestAdapter) -> Dict[str, str]:
+    def parse_multipart(self, request: SyncHTTPRequestAdapter) -> dict[str, str]:
         operations = self.parse_json(request.post_data.get("operations", "{}"))
         files_map = self.parse_json(request.post_data.get("map", "{}"))
 
@@ -159,7 +157,7 @@ class SyncBaseHTTPView(
         )
 
     def _handle_errors(
-        self, errors: List[GraphQLError], response_data: GraphQLHTTPResponse
+        self, errors: list[GraphQLError], response_data: GraphQLHTTPResponse
     ) -> None:
         """Hook to allow custom handling of errors, used by the Sentry Integration."""
 

strawberry/http/temporal_response.py

@@ -1,11 +1,10 @@
 from dataclasses import dataclass, field
-from typing import Dict
 
 
 @dataclass
 class TemporalResponse:
     status_code: int = 200
-    headers: Dict[str, str] = field(default_factory=dict)
+    headers: dict[str, str] = field(default_factory=dict)
 
 
 __all__ = ["TemporalResponse"]

strawberry/http/types.py

@@ -1,4 +1,5 @@
-from typing import Any, Mapping, Optional
+from collections.abc import Mapping
+from typing import Any, Optional
 from typing_extensions import Literal, TypedDict
 
 HTTPMethod = Literal[
@@ -13,4 +14,4 @@ class FormData(TypedDict):
     form: Mapping[str, Any]
 
 
-__all__ = ["HTTPMethod", "QueryParams", "FormData"]
+__all__ = ["FormData", "HTTPMethod", "QueryParams"]

strawberry/litestar/controller.py

@@ -8,14 +8,8 @@ from datetime import timedelta
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncGenerator,
-    AsyncIterator,
     Callable,
-    Dict,
-    FrozenSet,
     Optional,
-    Tuple,
-    Type,
     TypedDict,
     Union,
     cast,
@@ -60,7 +54,7 @@ from strawberry.http.typevars import Context, RootValue
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
+    from collections.abc import AsyncGenerator, AsyncIterator, Mapping
 
     from litestar.types import AnyCallable, Dependencies
     from strawberry.http import GraphQLHTTPResponse
@@ -97,7 +91,7 @@ class WebSocketContextDict(TypedDict):
 
 
 MergedContext = Union[
-    BaseContext, WebSocketContextDict, HTTPContextDict, Dict[str, Any]
+    BaseContext, WebSocketContextDict, HTTPContextDict, dict[str, Any]
 ]
 
 
@@ -254,11 +248,11 @@ class GraphQLController(
     websocket_adapter_class = LitestarWebSocketAdapter
 
     allow_queries_via_get: bool = True
-    graphiql_allowed_accept: FrozenSet[str] = frozenset({"text/html", "*/*"})
+    graphiql_allowed_accept: frozenset[str] = frozenset({"text/html", "*/*"})
     graphql_ide: Optional[GraphQL_IDE] = "graphiql"
     debug: bool = False
     connection_init_wait_timeout: timedelta = timedelta(minutes=1)
-    protocols: Tuple[str, ...] = (
+    protocols: tuple[str, ...] = (
         GRAPHQL_TRANSPORT_WS_PROTOCOL,
         GRAPHQL_WS_PROTOCOL,
     )
@@ -329,7 +323,7 @@ class GraphQLController(
         request: Request,
         stream: Callable[[], AsyncIterator[str]],
         sub_response: Response,
-        headers: Dict[str, str],
+        headers: dict[str, str],
     ) -> Response:
         return Stream(
             stream(),
@@ -416,13 +410,13 @@ def make_graphql_controller(
     root_value_getter: Optional[AnyCallable] = None,
     # TODO: context typevar
     context_getter: Optional[AnyCallable] = None,
-    subscription_protocols: Tuple[str, ...] = (
+    subscription_protocols: tuple[str, ...] = (
         GRAPHQL_TRANSPORT_WS_PROTOCOL,
         GRAPHQL_WS_PROTOCOL,
     ),
     connection_init_wait_timeout: timedelta = timedelta(minutes=1),
     multipart_uploads_enabled: bool = False,
-) -> Type[GraphQLController]:  # sourcery skip: move-assign
+) -> type[GraphQLController]:  # sourcery skip: move-assign
     if context_getter is None:
         custom_context_getter_ = _none_custom_context_getter
     else:
@@ -474,6 +468,6 @@ def make_graphql_controller(
 
 
 __all__ = [
-    "make_graphql_controller",
     "GraphQLController",
+    "make_graphql_controller",
 ]

strawberry/parent.py

@@ -1,5 +1,4 @@
-from typing import TypeVar
-from typing_extensions import Annotated
+from typing import Annotated, TypeVar
 
 
 class StrawberryParent: ...

strawberry/permission.py

@@ -7,11 +7,7 @@ from inspect import iscoroutinefunction
 from typing import (
     TYPE_CHECKING,
     Any,
-    Awaitable,
-    Dict,
-    List,
     Optional,
-    Type,
     Union,
 )
 
@@ -25,6 +21,8 @@ from strawberry.types.base import StrawberryList, StrawberryOptional
 from strawberry.utils.await_maybe import await_maybe
 
 if TYPE_CHECKING:
+    from collections.abc import Awaitable
+
     from graphql import GraphQLError, GraphQLErrorExtensions
 
     from strawberry.extensions.field_extension import (
@@ -56,7 +54,7 @@ class BasePermission(abc.ABC):
 
     error_extensions: Optional[GraphQLErrorExtensions] = None
 
-    error_class: Type[GraphQLError] = StrawberryGraphQLError
+    error_class: type[GraphQLError] = StrawberryGraphQLError
 
     _schema_directive: Optional[object] = None
 
@@ -138,7 +136,7 @@ class PermissionExtension(FieldExtension):
 
     def __init__(
         self,
-        permissions: List[BasePermission],
+        permissions: list[BasePermission],
         use_directives: bool = True,
         fail_silently: bool = False,
     ) -> None:
@@ -189,7 +187,7 @@ class PermissionExtension(FieldExtension):
         next_: SyncExtensionResolver,
         source: Any,
         info: Info,
-        **kwargs: Dict[str, Any],
+        **kwargs: dict[str, Any],
     ) -> Any:
         """Checks if the permission should be accepted and raises an exception if not."""
         for permission in self.permissions:
@@ -202,7 +200,7 @@ class PermissionExtension(FieldExtension):
         next_: AsyncExtensionResolver,
         source: Any,
         info: Info,
-        **kwargs: Dict[str, Any],
+        **kwargs: dict[str, Any],
     ) -> Any:
         for permission in self.permissions:
             has_permission = await await_maybe(

strawberry/printer/ast_from_value.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import re
+from collections.abc import Mapping
 from math import isfinite
-from typing import TYPE_CHECKING, Any, Mapping, Optional, cast
+from typing import TYPE_CHECKING, Any, Optional, cast
 
 from graphql.language import (
     BooleanValueNode,

strawberry/printer/printer.py

@@ -5,19 +5,14 @@ from itertools import chain
 from typing import (
     TYPE_CHECKING,
     Any,
-    Dict,
-    List,
     Optional,
-    Set,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     cast,
     overload,
 )
 
-from graphql import is_union_type
+from graphql import GraphQLObjectType, GraphQLSchema, is_union_type
 from graphql.language.printer import print_ast
 from graphql.type import (
     is_enum_type,
@@ -38,7 +33,11 @@ from graphql.utilities.print_schema import (
 from graphql.utilities.print_schema import print_type as original_print_type
 
 from strawberry.schema_directive import Location, StrawberrySchemaDirective
-from strawberry.types.base import StrawberryContainer, has_object_definition
+from strawberry.types.base import (
+    StrawberryContainer,
+    StrawberryObjectDefinition,
+    has_object_definition,
+)
 from strawberry.types.enum import EnumDefinition
 from strawberry.types.scalar import ScalarWrapper
 from strawberry.types.unset import UNSET
@@ -64,18 +63,18 @@ _T = TypeVar("_T")
 
 @dataclasses.dataclass
 class PrintExtras:
-    directives: Set[str] = dataclasses.field(default_factory=set)
-    types: Set[type] = dataclasses.field(default_factory=set)
+    directives: set[str] = dataclasses.field(default_factory=set)
+    types: set[type] = dataclasses.field(default_factory=set)
 
 
 @overload
-def _serialize_dataclasses(value: Dict[_T, object]) -> Dict[_T, object]: ...
+def _serialize_dataclasses(value: dict[_T, object]) -> dict[_T, object]: ...
 
 
 @overload
 def _serialize_dataclasses(
-    value: Union[List[object], Tuple[object]],
-) -> List[object]: ...
+    value: Union[list[object], tuple[object]],
+) -> list[object]: ...
 
 
 @overload
@@ -94,7 +93,7 @@ def _serialize_dataclasses(value):
 
 
 def print_schema_directive_params(
-    directive: GraphQLDirective, values: Dict[str, Any]
+    directive: GraphQLDirective, values: dict[str, Any]
 ) -> str:
     params = []
     for name, arg in directive.args.items():
@@ -189,7 +188,7 @@ def print_argument_directives(
 
 
 def print_args(
-    args: Dict[str, GraphQLArgument],
+    args: dict[str, GraphQLArgument],
     indentation: str = "",
     *,
     schema: BaseSchema,
@@ -225,7 +224,12 @@ def print_args(
     )
 
 
-def print_fields(type_: Type, schema: BaseSchema, *, extras: PrintExtras) -> str:
+def print_fields(
+    type_: GraphQLObjectType,
+    schema: BaseSchema,
+    *,
+    extras: PrintExtras,
+) -> str:
     from strawberry.schema.schema_converter import GraphQLCoreConverter
 
     fields = []
@@ -320,11 +324,13 @@ def print_enum(
     )
 
 
-def print_extends(type_: Type, schema: BaseSchema) -> str:
+def print_extends(type_: GraphQLObjectType, schema: BaseSchema) -> str:
     from strawberry.schema.schema_converter import GraphQLCoreConverter
 
-    strawberry_type = type_.extensions and type_.extensions.get(
-        GraphQLCoreConverter.DEFINITION_BACKREF
+    strawberry_type = cast(
+        Optional[StrawberryObjectDefinition],
+        type_.extensions
+        and type_.extensions.get(GraphQLCoreConverter.DEFINITION_BACKREF),
     )
 
     if strawberry_type and strawberry_type.extend:
@@ -334,12 +340,14 @@ def print_extends(type_: Type, schema: BaseSchema) -> str:
 
 
 def print_type_directives(
-    type_: Type, schema: BaseSchema, *, extras: PrintExtras
+    type_: GraphQLObjectType, schema: BaseSchema, *, extras: PrintExtras
 ) -> str:
     from strawberry.schema.schema_converter import GraphQLCoreConverter
 
-    strawberry_type = type_.extensions and type_.extensions.get(
-        GraphQLCoreConverter.DEFINITION_BACKREF
+    strawberry_type = cast(
+        Optional[StrawberryObjectDefinition],
+        type_.extensions
+        and type_.extensions.get(GraphQLCoreConverter.DEFINITION_BACKREF),
     )
 
     if not strawberry_type:
@@ -354,7 +362,7 @@ def print_type_directives(
         for directive in strawberry_type.directives or []
         if any(
             location in allowed_locations
-            for location in directive.__strawberry_directive__.locations
+            for location in directive.__strawberry_directive__.locations  # type: ignore[attr-defined]
         )
     )
 
@@ -550,21 +558,33 @@ def is_builtin_directive(directive: GraphQLDirective) -> bool:
 
 
 def print_schema(schema: BaseSchema) -> str:
-    graphql_core_schema = schema._schema  # type: ignore
+    graphql_core_schema = cast(
+        GraphQLSchema,
+        schema._schema,  # type: ignore
+    )
     extras = PrintExtras()
 
-    directives = filter(
-        lambda n: not is_builtin_directive(n), graphql_core_schema.directives
-    )
+    filtered_directives = [
+        directive
+        for directive in graphql_core_schema.directives
+        if not is_builtin_directive(directive)
+    ]
+
     type_map = graphql_core_schema.type_map
-    types = filter(is_defined_type, map(type_map.get, sorted(type_map)))
+    types = [
+        type_
+        for type_name in sorted(type_map)
+        if is_defined_type(type_ := type_map[type_name])
+    ]
 
     types_printed = [_print_type(type_, schema, extras=extras) for type_ in types]
     schema_definition = print_schema_definition(schema, extras=extras)
 
-    directives = filter(
-        None, [print_directive(directive, schema=schema) for directive in directives]
-    )
+    directives = [
+        printed_directive
+        for directive in filtered_directives
+        if (printed_directive := print_directive(directive, schema=schema)) is not None
+    ]
 
     def _name_getter(type_: Any) -> str:
         if hasattr(type_, "name"):

strawberry/quart/views.py

@@ -1,6 +1,6 @@
 import warnings
-from collections.abc import Mapping
-from typing import TYPE_CHECKING, AsyncGenerator, Callable, Dict, Optional, cast
+from collections.abc import AsyncGenerator, Mapping
+from typing import TYPE_CHECKING, Callable, Optional, cast
 from typing_extensions import TypeGuard
 
 from quart import Request, Response, request
@@ -111,7 +111,7 @@ class GraphQLView(
         request: Request,
         stream: Callable[[], AsyncGenerator[str, None]],
         sub_response: Response,
-        headers: Dict[str, str],
+        headers: dict[str, str],
     ) -> Response:
         return (
             stream(),

strawberry/relay/exceptions.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable
 from functools import cached_property
-from typing import TYPE_CHECKING, Optional, Type, cast
+from typing import TYPE_CHECKING, Optional, cast
 
 from strawberry.exceptions.exception import StrawberryException
 from strawberry.exceptions.utils.source_finder import SourceFinder
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 
 
 class NodeIDAnnotationError(StrawberryException):
-    def __init__(self, message: str, cls: Type) -> None:
+    def __init__(self, message: str, cls: type) -> None:
         self.cls = cls
 
         self.message = message
@@ -41,7 +41,7 @@ class NodeIDAnnotationError(StrawberryException):
 
 
 class RelayWrongAnnotationError(StrawberryException):
-    def __init__(self, field_name: str, cls: Type) -> None:
+    def __init__(self, field_name: str, cls: type) -> None:
         self.cls = cls
         self.field_name = field_name
 
@@ -85,7 +85,7 @@ class RelayWrongResolverAnnotationError(StrawberryException):
         )
         self.suggestion = (
             "To fix this error you can annootate your resolver to return "
-            "one of the following options: `List[<NodeType>]`, "
+            "one of the following options: `list[<NodeType>]`, "
             "`Iterator[<NodeType>]`, `Iterable[<NodeType>]`, "
             "`AsyncIterator[<NodeType>]`, `AsyncIterable[<NodeType>]`, "
             "`Generator[<NodeType>, Any, Any]` and "

strawberry/relay/fields.py

@@ -4,29 +4,26 @@ import asyncio
 import dataclasses
 import inspect
 from collections import defaultdict
-from collections.abc import AsyncIterable
-from typing import (
-    TYPE_CHECKING,
-    Any,
+from collections.abc import (
+    AsyncIterable,
     AsyncIterator,
     Awaitable,
-    Callable,
-    DefaultDict,
-    Dict,
-    ForwardRef,
     Iterable,
     Iterator,
-    List,
     Mapping,
-    Optional,
     Sequence,
-    Tuple,
-    Type,
+)
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Callable,
+    ForwardRef,
+    Optional,
     Union,
     cast,
-    overload,
 )
-from typing_extensions import Annotated, get_origin
+from typing_extensions import get_args, get_origin
 
 from strawberry.annotation import StrawberryAnnotation
 from strawberry.extensions.field_extension import (
@@ -44,9 +41,9 @@ from strawberry.types.field import _RESOLVER_TYPE, StrawberryField, field
 from strawberry.types.fields.resolver import StrawberryResolver
 from strawberry.types.lazy_type import LazyType
 from strawberry.utils.aio import asyncgen_to_list
-from strawberry.utils.typing import eval_type, is_generic_alias
+from strawberry.utils.typing import eval_type, is_generic_alias, is_optional, is_union
 
-from .types import Connection, GlobalID, Node, NodeIterableType, NodeType
+from .types import Connection, GlobalID, Node
 
 if TYPE_CHECKING:
     from typing_extensions import Literal
@@ -101,7 +98,7 @@ class NodeExtension(FieldExtension):
 
     def get_node_list_resolver(
         self, field: StrawberryField
-    ) -> Callable[[Info, List[GlobalID]], Union[List[Node], Awaitable[List[Node]]]]:
+    ) -> Callable[[Info, list[GlobalID]], Union[list[Node], Awaitable[list[Node]]]]:
         type_ = field.type
         assert isinstance(type_, StrawberryList)
         is_optional = isinstance(type_.of_type, StrawberryOptional)
@@ -109,14 +106,14 @@ class NodeExtension(FieldExtension):
         def resolver(
             info: Info,
             ids: Annotated[
-                List[GlobalID], argument(description="The IDs of the objects.")
+                list[GlobalID], argument(description="The IDs of the objects.")
             ],
-        ) -> Union[List[Node], Awaitable[List[Node]]]:
-            nodes_map: DefaultDict[Type[Node], List[str]] = defaultdict(list)
+        ) -> Union[list[Node], Awaitable[list[Node]]]:
+            nodes_map: defaultdict[type[Node], list[str]] = defaultdict(list)
             # Store the index of the node in the list of nodes of the same type
             # so that we can return them in the same order while also supporting
             # different types
-            index_map: Dict[GlobalID, Tuple[Type[Node], int]] = {}
+            index_map: dict[GlobalID, tuple[type[Node], int]] = {}
             for gid in ids:
                 node_t = gid.resolve_type(info)
                 nodes_map[node_t].append(gid.node_id)
@@ -144,7 +141,7 @@ class NodeExtension(FieldExtension):
 
             if awaitable_nodes or asyncgen_nodes:
 
-                async def resolve(resolved: Any = resolved_nodes) -> List[Node]:
+                async def resolve(resolved: Any = resolved_nodes) -> list[Node]:
                     resolved.update(
                         zip(
                             [
@@ -183,7 +180,7 @@ class NodeExtension(FieldExtension):
 
 
 class ConnectionExtension(FieldExtension):
-    connection_type: Type[Connection[Node]]
+    connection_type: type[Connection[Node]]
 
     def apply(self, field: StrawberryField) -> None:
         field.arguments = [
@@ -233,7 +230,11 @@ class ConnectionExtension(FieldExtension):
             f_type = f_type.resolve_type()
             field.type = f_type
 
+        if isinstance(f_type, StrawberryOptional):
+            f_type = f_type.of_type
+
         type_origin = get_origin(f_type) if is_generic_alias(f_type) else f_type
+
         if not isinstance(type_origin, type) or not issubclass(type_origin, Connection):
             raise RelayWrongAnnotationError(field.name, cast(type, field.origin))
 
@@ -253,13 +254,19 @@ class ConnectionExtension(FieldExtension):
                 None,
             )
 
+        if is_union(resolver_type):
+            assert is_optional(resolver_type)
+
+            resolver_type = get_args(resolver_type)[0]
+
         origin = get_origin(resolver_type)
+
         if origin is None or not issubclass(
             origin, (Iterator, Iterable, AsyncIterator, AsyncIterable)
         ):
             raise RelayWrongResolverAnnotationError(field.name, field.base_resolver)
 
-        self.connection_type = cast(Type[Connection[Node]], field.type)
+        self.connection_type = cast(type[Connection[Node]], f_type)
 
     def resolve(
         self,
@@ -327,59 +334,32 @@ else:
         return field(*args, **kwargs)
 
 
-@overload
-def connection(
-    graphql_type: Optional[Type[Connection[NodeType]]] = None,
-    *,
-    resolver: Optional[_RESOLVER_TYPE[NodeIterableType[Any]]] = None,
-    name: Optional[str] = None,
-    is_subscription: bool = False,
-    description: Optional[str] = None,
-    init: Literal[True] = True,
-    permission_classes: Optional[List[Type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
-    default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: List[FieldExtension] = (),  # type: ignore
-) -> Any: ...
-
-
-@overload
-def connection(
-    graphql_type: Optional[Type[Connection[NodeType]]] = None,
-    *,
-    name: Optional[str] = None,
-    is_subscription: bool = False,
-    description: Optional[str] = None,
-    permission_classes: Optional[List[Type[BasePermission]]] = None,
-    deprecation_reason: Optional[str] = None,
-    default: Any = dataclasses.MISSING,
-    default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
-    metadata: Optional[Mapping[Any, Any]] = None,
-    directives: Optional[Sequence[object]] = (),
-    extensions: List[FieldExtension] = (),  # type: ignore
-) -> StrawberryField: ...
+# we used to have `Type[Connection[NodeType]]` here, but that when we added
+# support for making the Connection type optional, we had to change it to
+# `Any` because otherwise it wouldn't be type check since `Optional[Connection[Something]]`
+# is not a `Type`, but a special form, see https://discuss.python.org/t/is-annotated-compatible-with-type-t/43898/46
+# for more information, and also https://peps.python.org/pep-0747/, which is currently
+# in draft status (and no type checker supports it yet)
+ConnectionGraphQLType = Any
 
 
 def connection(
-    graphql_type: Optional[Type[Connection[NodeType]]] = None,
+    graphql_type: Optional[ConnectionGraphQLType] = None,
     *,
     resolver: Optional[_RESOLVER_TYPE[Any]] = None,
     name: Optional[str] = None,
     is_subscription: bool = False,
     description: Optional[str] = None,
-    permission_classes: Optional[List[Type[BasePermission]]] = None,
+    permission_classes: Optional[list[type[BasePermission]]] = None,
     deprecation_reason: Optional[str] = None,
     default: Any = dataclasses.MISSING,
     default_factory: Union[Callable[..., object], object] = dataclasses.MISSING,
     metadata: Optional[Mapping[Any, Any]] = None,
     directives: Optional[Sequence[object]] = (),
-    extensions: List[FieldExtension] = (),  # type: ignore
+    extensions: list[FieldExtension] = (),  # type: ignore
     # This init parameter is used by pyright to determine whether this field
     # is added in the constructor or not. It is not used to change
-    # any behavior at the moment.
+    # any behaviour at the moment.
     init: Literal[True, False, None] = None,
 ) -> Any:
     """Annotate a property or a method to create a relay connection field.
@@ -478,4 +458,4 @@ def connection(
     return f
 
 
-__all__ = ["node", "connection"]
+__all__ = ["connection", "node"]