strawberry-graphql 0.255.0__py3-none-any.whl → 0.256.1__py3-none-any.whl

strawberry/schema/schema_converter.py

@@ -6,14 +6,9 @@ from functools import partial, reduce
 from typing import (
     TYPE_CHECKING,
     Any,
-    Awaitable,
     Callable,
-    Dict,
     Generic,
-    List,
     Optional,
-    Tuple,
-    Type,
     TypeVar,
     Union,
     cast,
@@ -76,6 +71,8 @@ from . import compat
 from .types.concrete_type import ConcreteType
 
 if TYPE_CHECKING:
+    from collections.abc import Awaitable
+
     from graphql import (
         GraphQLInputType,
         GraphQLNullableType,
@@ -111,8 +108,8 @@ def _get_thunk_mapping(
     type_definition: StrawberryObjectDefinition,
     name_converter: Callable[[StrawberryField], str],
     field_converter: FieldConverterProtocol[FieldType],
-    get_fields: Callable[[StrawberryObjectDefinition], List[StrawberryField]],
-) -> Dict[str, FieldType]:
+    get_fields: Callable[[StrawberryObjectDefinition], list[StrawberryField]],
+) -> dict[str, FieldType]:
     """Create a GraphQL core `ThunkMapping` mapping of field names to field types.
 
     This method filters out remaining `strawberry.Private` annotated fields that
@@ -124,7 +121,7 @@ def _get_thunk_mapping(
     Raises:
         TypeError: If the type of a field in ``fields`` is `UNRESOLVED`
     """
-    thunk_mapping: Dict[str, FieldType] = {}
+    thunk_mapping: dict[str, FieldType] = {}
 
     fields = get_fields(type_definition)
 
@@ -173,7 +170,7 @@ class CustomGraphQLEnumType(GraphQLEnumType):
         return self.wrapped_cls(super().parse_value(input_value))
 
     def parse_literal(
-        self, value_node: ValueNode, _variables: Optional[Dict[str, Any]] = None
+        self, value_node: ValueNode, _variables: Optional[dict[str, Any]] = None
     ) -> Any:
         return self.wrapped_cls(super().parse_literal(value_node, _variables))
 
@@ -185,8 +182,8 @@ def get_arguments(
     info: Info,
     kwargs: Any,
     config: StrawberryConfig,
-    scalar_registry: Dict[object, Union[ScalarWrapper, ScalarDefinition]],
-) -> Tuple[List[Any], Dict[str, Any]]:
+    scalar_registry: dict[object, Union[ScalarWrapper, ScalarDefinition]],
+) -> tuple[list[Any], dict[str, Any]]:
     # TODO: An extension might have changed the resolver arguments,
     # but we need them here since we are calling it.
     # This is a bit of a hack, but it's the easiest way to get the arguments
@@ -242,10 +239,10 @@ class GraphQLCoreConverter:
     def __init__(
         self,
         config: StrawberryConfig,
-        scalar_registry: Dict[object, Union[ScalarWrapper, ScalarDefinition]],
-        get_fields: Callable[[StrawberryObjectDefinition], List[StrawberryField]],
+        scalar_registry: dict[object, Union[ScalarWrapper, ScalarDefinition]],
+        get_fields: Callable[[StrawberryObjectDefinition], list[StrawberryField]],
     ) -> None:
-        self.type_map: Dict[str, ConcreteType] = {}
+        self.type_map: dict[str, ConcreteType] = {}
         self.config = config
         self.scalar_registry = scalar_registry
         self.get_fields = get_fields
@@ -329,13 +326,14 @@ class GraphQLCoreConverter:
             },
         )
 
-    def from_schema_directive(self, cls: Type) -> GraphQLDirective:
+    def from_schema_directive(self, cls: type) -> GraphQLDirective:
         strawberry_directive = cast(
-            "StrawberrySchemaDirective", cls.__strawberry_directive__
+            "StrawberrySchemaDirective",
+            cls.__strawberry_directive__,  # type: ignore[attr-defined]
         )
         module = sys.modules[cls.__module__]
 
-        args: Dict[str, GraphQLArgument] = {}
+        args: dict[str, GraphQLArgument] = {}
         for field in strawberry_directive.fields:
             default = field.default
             if default == dataclasses.MISSING:
@@ -436,7 +434,7 @@ class GraphQLCoreConverter:
 
     def get_graphql_fields(
         self, type_definition: StrawberryObjectDefinition
-    ) -> Dict[str, GraphQLField]:
+    ) -> dict[str, GraphQLField]:
         return _get_thunk_mapping(
             type_definition=type_definition,
             name_converter=self.config.name_converter.from_field,
@@ -446,7 +444,7 @@ class GraphQLCoreConverter:
 
     def get_graphql_input_fields(
         self, type_definition: StrawberryObjectDefinition
-    ) -> Dict[str, GraphQLInputField]:
+    ) -> dict[str, GraphQLInputField]:
         return _get_thunk_mapping(
             type_definition=type_definition,
             name_converter=self.config.name_converter.from_field,
@@ -672,8 +670,8 @@ class GraphQLCoreConverter:
         def _get_result(
             _source: Any,
             info: Info,
-            field_args: List[Any],
-            field_kwargs: Dict[str, Any],
+            field_args: list[Any],
+            field_kwargs: dict[str, Any],
         ) -> Any:
             return field.get_result(
                 _source, info=info, args=field_args, kwargs=field_kwargs
@@ -762,7 +760,7 @@ class GraphQLCoreConverter:
             _resolver._is_default = not field.base_resolver  # type: ignore
             return _resolver
 
-    def from_scalar(self, scalar: Type) -> GraphQLScalarType:
+    def from_scalar(self, scalar: type) -> GraphQLScalarType:
         scalar_definition: ScalarDefinition
 
         if scalar in self.scalar_registry:
@@ -773,7 +771,7 @@ class GraphQLCoreConverter:
             else:
                 scalar_definition = _scalar_definition
         else:
-            scalar_definition = scalar._scalar_definition
+            scalar_definition = scalar._scalar_definition  # type: ignore[attr-defined]
 
         scalar_name = self.config.name_converter.from_type(scalar_definition)
 
@@ -864,7 +862,7 @@ class GraphQLCoreConverter:
             assert isinstance(graphql_union, GraphQLUnionType)  # For mypy
             return graphql_union
 
-        graphql_types: List[GraphQLObjectType] = []
+        graphql_types: list[GraphQLObjectType] = []
         for type_ in union.types:
             graphql_type = self.from_type(type_)
 

strawberry/schema/subscribe.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, AsyncGenerator, AsyncIterator, Optional, Type, Union
+from collections.abc import AsyncGenerator, AsyncIterator
+from typing import TYPE_CHECKING, Optional, Union
 
 from graphql import (
     ExecutionResult as OriginalExecutionResult,
@@ -44,7 +45,7 @@ async def _subscribe(
     extensions_runner: SchemaExtensionsRunner,
     process_errors: ProcessErrors,
     middleware_manager: MiddlewareManager,
-    execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
+    execution_context_class: Optional[type[GraphQLExecutionContext]] = None,
 ) -> AsyncGenerator[Union[PreExecutionError, ExecutionResult], None]:
     async with extensions_runner.operation():
         if initial_error := await _parse_and_validate_async(
@@ -128,7 +129,7 @@ async def subscribe(
     extensions_runner: SchemaExtensionsRunner,
     process_errors: ProcessErrors,
     middleware_manager: MiddlewareManager,
-    execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
+    execution_context_class: Optional[type[GraphQLExecutionContext]] = None,
 ) -> SubscriptionResult:
     asyncgen = _subscribe(
         schema,

strawberry/schema/types/base_scalars.py

@@ -81,4 +81,4 @@ Void = scalar(
     description="Represents NULL values",
 )
 
-__all__ = ["Date", "DateTime", "Time", "Decimal", "UUID", "Void"]
+__all__ = ["UUID", "Date", "DateTime", "Decimal", "Time", "Void"]

strawberry/schema/types/concrete_type.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import dataclasses
-from typing import TYPE_CHECKING, Dict, Union
+from typing import TYPE_CHECKING, Union
 
 from graphql import GraphQLField, GraphQLInputField, GraphQLType
 
@@ -22,7 +22,7 @@ class ConcreteType:
     implementation: GraphQLType
 
 
-TypeMap = Dict[str, ConcreteType]
+TypeMap = dict[str, ConcreteType]
 
 
 __all__ = ["ConcreteType", "Field", "GraphQLType", "TypeMap"]

strawberry/schema/types/scalar.py

@@ -1,6 +1,5 @@
 import datetime
 import decimal
-from typing import Dict, Type
 from uuid import UUID
 
 from graphql import (
@@ -45,11 +44,11 @@ def _make_scalar_definition(scalar_type: GraphQLScalarType) -> ScalarDefinition:
     )
 
 
-def _get_scalar_definition(scalar: Type) -> ScalarDefinition:
-    return scalar._scalar_definition
+def _get_scalar_definition(scalar: type) -> ScalarDefinition:
+    return scalar._scalar_definition  # type: ignore[attr-defined]
 
 
-DEFAULT_SCALAR_REGISTRY: Dict[object, ScalarDefinition] = {
+DEFAULT_SCALAR_REGISTRY: dict[object, ScalarDefinition] = {
     type(None): _get_scalar_definition(base_scalars.Void),
     None: _get_scalar_definition(base_scalars.Void),
     str: _make_scalar_definition(GraphQLString),

strawberry/schema_codegen/__init__.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import dataclasses
 import keyword
 from collections import defaultdict
-from typing import TYPE_CHECKING, List, Tuple, Union
+from graphlib import TopologicalSorter
+from typing import TYPE_CHECKING, Union
 from typing_extensions import Protocol, TypeAlias
 
 import libcst as cst
-from graphlib import TopologicalSorter
 from graphql import (
     EnumTypeDefinitionNode,
     EnumValueDefinitionNode,
@@ -42,7 +42,7 @@ if TYPE_CHECKING:
 
 
 class HasDirectives(Protocol):
-    directives: Tuple[ConstDirectiveNode, ...]
+    directives: tuple[ConstDirectiveNode, ...]
 
 
 _SCALAR_MAP = {
@@ -256,7 +256,7 @@ def _get_field(
     )
 
 
-ArgumentValue: TypeAlias = Union[str, bool, List["ArgumentValue"]]
+ArgumentValue: TypeAlias = Union[str, bool, list["ArgumentValue"]]
 
 
 def _get_argument_value(argument_value: ConstValueNode) -> ArgumentValue:

strawberry/schema_directive.py

@@ -1,6 +1,6 @@
 import dataclasses
 from enum import Enum
-from typing import Callable, List, Optional, Type, TypeVar
+from typing import Callable, Optional, TypeVar
 from typing_extensions import dataclass_transform
 
 from strawberry.types.field import StrawberryField, field
@@ -28,15 +28,15 @@ class Location(Enum):
 class StrawberrySchemaDirective:
     python_name: str
     graphql_name: Optional[str]
-    locations: List[Location]
-    fields: List["StrawberryField"]
+    locations: list[Location]
+    fields: list["StrawberryField"]
     description: Optional[str] = None
     repeatable: bool = False
     print_definition: bool = True
-    origin: Optional[Type] = None
+    origin: Optional[type] = None
 
 
-T = TypeVar("T", bound=Type)
+T = TypeVar("T", bound=type)
 
 
 @dataclass_transform(
@@ -46,17 +46,17 @@ T = TypeVar("T", bound=Type)
 )
 def schema_directive(
     *,
-    locations: List[Location],
+    locations: list[Location],
     description: Optional[str] = None,
     name: Optional[str] = None,
     repeatable: bool = False,
     print_definition: bool = True,
-) -> Callable[..., T]:
+) -> Callable[[T], T]:
     def _wrap(cls: T) -> T:
         cls = _wrap_dataclass(cls)  # type: ignore
         fields = _get_fields(cls, {})
 
-        cls.__strawberry_directive__ = StrawberrySchemaDirective(
+        cls.__strawberry_directive__ = StrawberrySchemaDirective(  # type: ignore[attr-defined]
             python_name=cls.__name__,
             graphql_name=name,
             locations=locations,

strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -2,14 +2,12 @@ from __future__ import annotations
 
 import asyncio
 import logging
+from collections.abc import Awaitable
 from contextlib import suppress
 from typing import (
     TYPE_CHECKING,
     Any,
-    Awaitable,
-    Dict,
     Generic,
-    List,
     Optional,
     cast,
 )
@@ -40,6 +38,7 @@ from strawberry.utils.debug import pretty_print_graphql_operation
 from strawberry.utils.operation import get_operation_type
 
 if TYPE_CHECKING:
+    from collections.abc import Awaitable
     from datetime import timedelta
 
     from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncWebSocketAdapter
@@ -71,8 +70,8 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
         self.connection_init_received = False
         self.connection_acknowledged = False
         self.connection_timed_out = False
-        self.operations: Dict[str, Operation[Context, RootValue]] = {}
-        self.completed_tasks: List[asyncio.Task] = []
+        self.operations: dict[str, Operation[Context, RootValue]] = {}
+        self.completed_tasks: list[asyncio.Task] = []
 
     async def handle(self) -> None:
         self.on_request_accepted()
@@ -343,14 +342,14 @@ class Operation(Generic[Context, RootValue]):
     """A class encapsulating a single operation with its id. Helps enforce protocol state transition."""
 
     __slots__ = [
+        "completed",
         "handler",
         "id",
+        "operation_name",
         "operation_type",
         "query",
-        "variables",
-        "operation_name",
-        "completed",
         "task",
+        "variables",
     ]
 
     def __init__(
@@ -359,7 +358,7 @@ class Operation(Generic[Context, RootValue]):
         id: str,
         operation_type: OperationType,
         query: str,
-        variables: Optional[Dict[str, object]],
+        variables: Optional[dict[str, object]],
         operation_name: Optional[str],
     ) -> None:
         self.handler = handler

strawberry/subscriptions/protocols/graphql_transport_ws/types.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, TypedDict, Union
+from typing import TypedDict, Union
 from typing_extensions import Literal, NotRequired
 
 from graphql import GraphQLFormattedError
@@ -8,35 +8,35 @@ class ConnectionInitMessage(TypedDict):
     """Direction: Client -> Server."""
 
     type: Literal["connection_init"]
-    payload: NotRequired[Union[Dict[str, object], None]]
+    payload: NotRequired[Union[dict[str, object], None]]
 
 
 class ConnectionAckMessage(TypedDict):
     """Direction: Server -> Client."""
 
     type: Literal["connection_ack"]
-    payload: NotRequired[Union[Dict[str, object], None]]
+    payload: NotRequired[Union[dict[str, object], None]]
 
 
 class PingMessage(TypedDict):
     """Direction: bidirectional."""
 
     type: Literal["ping"]
-    payload: NotRequired[Union[Dict[str, object], None]]
+    payload: NotRequired[Union[dict[str, object], None]]
 
 
 class PongMessage(TypedDict):
     """Direction: bidirectional."""
 
     type: Literal["pong"]
-    payload: NotRequired[Union[Dict[str, object], None]]
+    payload: NotRequired[Union[dict[str, object], None]]
 
 
 class SubscribeMessagePayload(TypedDict):
     operationName: NotRequired[Union[str, None]]
     query: str
-    variables: NotRequired[Union[Dict[str, object], None]]
-    extensions: NotRequired[Union[Dict[str, object], None]]
+    variables: NotRequired[Union[dict[str, object], None]]
+    extensions: NotRequired[Union[dict[str, object], None]]
 
 
 class SubscribeMessage(TypedDict):
@@ -48,9 +48,9 @@ class SubscribeMessage(TypedDict):
 
 
 class NextMessagePayload(TypedDict):
-    errors: NotRequired[List[GraphQLFormattedError]]
-    data: NotRequired[Union[Dict[str, object], None]]
-    extensions: NotRequired[Dict[str, object]]
+    errors: NotRequired[list[GraphQLFormattedError]]
+    data: NotRequired[Union[dict[str, object], None]]
+    extensions: NotRequired[dict[str, object]]
 
 
 class NextMessage(TypedDict):
@@ -66,7 +66,7 @@ class ErrorMessage(TypedDict):
 
     id: str
     type: Literal["error"]
-    payload: List[GraphQLFormattedError]
+    payload: list[GraphQLFormattedError]
 
 
 class CompleteMessage(TypedDict):
@@ -89,13 +89,13 @@ Message = Union[
 
 
 __all__ = [
-    "ConnectionInitMessage",
+    "CompleteMessage",
     "ConnectionAckMessage",
+    "ConnectionInitMessage",
+    "ErrorMessage",
+    "Message",
+    "NextMessage",
     "PingMessage",
     "PongMessage",
     "SubscribeMessage",
-    "NextMessage",
-    "ErrorMessage",
-    "CompleteMessage",
-    "Message",
 ]

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -1,12 +1,11 @@
 from __future__ import annotations
 
 import asyncio
+from collections.abc import AsyncGenerator
 from contextlib import suppress
 from typing import (
     TYPE_CHECKING,
     Any,
-    AsyncGenerator,
-    Dict,
     Generic,
     Optional,
     cast,
@@ -28,6 +27,8 @@ from strawberry.types.unset import UnsetType
 from strawberry.utils.debug import pretty_print_graphql_operation
 
 if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator
+
     from strawberry.http.async_base_view import AsyncBaseHTTPView, AsyncWebSocketAdapter
     from strawberry.schema import BaseSchema
 
@@ -56,8 +57,8 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
         self.keep_alive = keep_alive
         self.keep_alive_interval = keep_alive_interval
         self.keep_alive_task: Optional[asyncio.Task] = None
-        self.subscriptions: Dict[str, AsyncGenerator] = {}
-        self.tasks: Dict[str, asyncio.Task] = {}
+        self.subscriptions: dict[str, AsyncGenerator] = {}
+        self.tasks: dict[str, asyncio.Task] = {}
 
     async def handle(self) -> None:
         try:
@@ -164,7 +165,7 @@ class BaseGraphQLWSHandler(Generic[Context, RootValue]):
         operation_id: str,
         query: str,
         operation_name: Optional[str],
-        variables: Optional[Dict[str, object]],
+        variables: Optional[dict[str, object]],
     ) -> None:
         try:
             agen_or_err = await self.schema.subscribe(

strawberry/subscriptions/protocols/graphql_ws/types.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, TypedDict, Union
+from typing import TypedDict, Union
 from typing_extensions import Literal, NotRequired
 
 from graphql import GraphQLFormattedError
@@ -6,12 +6,12 @@ from graphql import GraphQLFormattedError
 
 class ConnectionInitMessage(TypedDict):
     type: Literal["connection_init"]
-    payload: NotRequired[Dict[str, object]]
+    payload: NotRequired[dict[str, object]]
 
 
 class StartMessagePayload(TypedDict):
     query: str
-    variables: NotRequired[Dict[str, object]]
+    variables: NotRequired[dict[str, object]]
     operationName: NotRequired[str]
 
 
@@ -32,20 +32,20 @@ class ConnectionTerminateMessage(TypedDict):
 
 class ConnectionErrorMessage(TypedDict):
     type: Literal["connection_error"]
-    payload: NotRequired[Dict[str, object]]
+    payload: NotRequired[dict[str, object]]
 
 
 class ConnectionAckMessage(TypedDict):
     type: Literal["connection_ack"]
-    payload: NotRequired[Dict[str, object]]
+    payload: NotRequired[dict[str, object]]
 
 
 class DataMessagePayload(TypedDict):
     data: object
-    errors: NotRequired[List[GraphQLFormattedError]]
+    errors: NotRequired[list[GraphQLFormattedError]]
 
     # Non-standard field:
-    extensions: NotRequired[Dict[str, object]]
+    extensions: NotRequired[dict[str, object]]
 
 
 class DataMessage(TypedDict):
@@ -84,15 +84,15 @@ OperationMessage = Union[
 
 
 __all__ = [
+    "CompleteMessage",
+    "ConnectionAckMessage",
+    "ConnectionErrorMessage",
     "ConnectionInitMessage",
-    "StartMessage",
-    "StopMessage",
+    "ConnectionKeepAliveMessage",
     "ConnectionTerminateMessage",
-    "ConnectionErrorMessage",
-    "ConnectionAckMessage",
     "DataMessage",
     "ErrorMessage",
-    "CompleteMessage",
-    "ConnectionKeepAliveMessage",
     "OperationMessage",
+    "StartMessage",
+    "StopMessage",
 ]

strawberry/test/__init__.py

@@ -1,3 +1,3 @@
 from .client import BaseGraphQLTestClient, Body, Response
 
-__all__ = ["Body", "Response", "BaseGraphQLTestClient"]
+__all__ = ["BaseGraphQLTestClient", "Body", "Response"]

strawberry/test/client.py

@@ -4,23 +4,25 @@ import json
 import warnings
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Coroutine, Dict, List, Mapping, Optional, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 from typing_extensions import Literal, TypedDict
 
 if TYPE_CHECKING:
+    from collections.abc import Coroutine, Mapping
+
     from graphql import GraphQLFormattedError
 
 
 @dataclass
 class Response:
-    errors: Optional[List[GraphQLFormattedError]]
-    data: Optional[Dict[str, object]]
-    extensions: Optional[Dict[str, object]]
+    errors: Optional[list[GraphQLFormattedError]]
+    data: Optional[dict[str, object]]
+    extensions: Optional[dict[str, object]]
 
 
 class Body(TypedDict, total=False):
     query: str
-    variables: Optional[Dict[str, object]]
+    variables: Optional[dict[str, object]]
 
 
 class BaseGraphQLTestClient(ABC):
@@ -35,10 +37,10 @@ class BaseGraphQLTestClient(ABC):
     def query(
         self,
         query: str,
-        variables: Optional[Dict[str, Mapping]] = None,
-        headers: Optional[Dict[str, object]] = None,
+        variables: Optional[dict[str, Mapping]] = None,
+        headers: Optional[dict[str, object]] = None,
         asserts_errors: Optional[bool] = None,
-        files: Optional[Dict[str, object]] = None,
+        files: Optional[dict[str, object]] = None,
         assert_no_errors: Optional[bool] = True,
     ) -> Union[Coroutine[Any, Any, Response], Response]:
         body = self._build_body(query, variables, files)
@@ -71,19 +73,19 @@ class BaseGraphQLTestClient(ABC):
     @abstractmethod
     def request(
         self,
-        body: Dict[str, object],
-        headers: Optional[Dict[str, object]] = None,
-        files: Optional[Dict[str, object]] = None,
+        body: dict[str, object],
+        headers: Optional[dict[str, object]] = None,
+        files: Optional[dict[str, object]] = None,
     ) -> Any:
         raise NotImplementedError
 
     def _build_body(
         self,
         query: str,
-        variables: Optional[Dict[str, Mapping]] = None,
-        files: Optional[Dict[str, object]] = None,
-    ) -> Dict[str, object]:
-        body: Dict[str, object] = {"query": query}
+        variables: Optional[dict[str, Mapping]] = None,
+        files: Optional[dict[str, object]] = None,
+    ) -> dict[str, object]:
+        body: dict[str, object] = {"query": query}
 
         if variables:
             body["variables"] = variables
@@ -103,8 +105,8 @@ class BaseGraphQLTestClient(ABC):
 
     @staticmethod
     def _build_multipart_file_map(
-        variables: Dict[str, Mapping], files: Dict[str, object]
-    ) -> Dict[str, List[str]]:
+        variables: dict[str, Mapping], files: dict[str, object]
+    ) -> dict[str, list[str]]:
         """Creates the file mapping between the variables and the files objects passed as key arguments.
 
         Args:
@@ -158,7 +160,7 @@ class BaseGraphQLTestClient(ABC):
         # }
         ```
         """
-        map: Dict[str, List[str]] = {}
+        map: dict[str, list[str]] = {}
         for key, values in variables.items():
             reference = key
             variable_values = values
@@ -195,4 +197,4 @@ class BaseGraphQLTestClient(ABC):
         return response.json()
 
 
-__all__ = ["BaseGraphQLTestClient", "Response", "Body"]
+__all__ = ["BaseGraphQLTestClient", "Body", "Response"]