strawberry-graphql 0.257.0__py3-none-any.whl → 0.257.0.dev1735244504__py3-none-any.whl

strawberry/schema/base.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
+from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Optional, Union
 from typing_extensions import Protocol
 
@@ -87,6 +88,7 @@ class BaseSchema(Protocol):
         raise NotImplementedError
 
     @abstractmethod
+    @lru_cache
     def get_directive_by_name(self, graphql_name: str) -> Optional[StrawberryDirective]:
         raise NotImplementedError
 

strawberry/schema/execute.py

@@ -85,7 +85,7 @@ async def _parse_and_validate_async(
     context: ExecutionContext, extensions_runner: SchemaExtensionsRunner
 ) -> Optional[PreExecutionError]:
     if not context.query:
-        raise MissingQueryError
+        raise MissingQueryError()
 
     async with extensions_runner.parsing():
         try:
@@ -96,7 +96,7 @@ async def _parse_and_validate_async(
             context.errors = [error]
             return PreExecutionError(data=None, errors=[error])
 
-        except Exception as error:  # noqa: BLE001
+        except Exception as error:
             error = GraphQLError(str(error), original_error=error)
             context.errors = [error]
             return PreExecutionError(data=None, errors=[error])
@@ -189,9 +189,9 @@ async def execute(
                     # only return a sanitised version to the client.
                     process_errors(result.errors, execution_context)
 
-    except (MissingQueryError, InvalidOperationTypeError):
-        raise
-    except Exception as exc:  # noqa: BLE001
+    except (MissingQueryError, InvalidOperationTypeError) as e:
+        raise e
+    except Exception as exc:
         return await _handle_execution_result(
             execution_context,
             PreExecutionError(data=None, errors=[_coerce_error(exc)]),
@@ -219,7 +219,7 @@ def execute_sync(
             # Note: In graphql-core the schema would be validated here but in
             # Strawberry we are validating it at initialisation time instead
             if not execution_context.query:
-                raise MissingQueryError  # noqa: TRY301
+                raise MissingQueryError()
 
             with extensions_runner.parsing():
                 try:
@@ -238,7 +238,7 @@ def execute_sync(
                     )
 
             if execution_context.operation_type not in allowed_operation_types:
-                raise InvalidOperationTypeError(execution_context.operation_type)  # noqa: TRY301
+                raise InvalidOperationTypeError(execution_context.operation_type)
 
             with extensions_runner.validation():
                 _run_validation(execution_context)
@@ -266,7 +266,7 @@ def execute_sync(
                     if isawaitable(result):
                         result = cast(Awaitable[GraphQLExecutionResult], result)  # type: ignore[redundant-cast]
                         ensure_future(result).cancel()
-                        raise RuntimeError(  # noqa: TRY301
+                        raise RuntimeError(
                             "GraphQL execution failed to complete synchronously."
                         )
 
@@ -282,9 +282,9 @@ def execute_sync(
                         # extension). That way we can log the original errors but
                         # only return a sanitised version to the client.
                         process_errors(result.errors, execution_context)
-    except (MissingQueryError, InvalidOperationTypeError):
-        raise
-    except Exception as exc:  # noqa: BLE001
+    except (MissingQueryError, InvalidOperationTypeError) as e:
+        raise e
+    except Exception as exc:
         errors = [_coerce_error(exc)]
         execution_context.errors = errors
         process_errors(errors, execution_context)

strawberry/schema/name_converter.py

@@ -47,17 +47,18 @@ class NameConverter:
             return self.from_directive(type_)
         if isinstance(type_, EnumDefinition):  # TODO: Replace with StrawberryEnum
             return self.from_enum(type_)
-        if isinstance(type_, StrawberryObjectDefinition):
+        elif isinstance(type_, StrawberryObjectDefinition):
             if type_.is_input:
                 return self.from_input_object(type_)
             if type_.is_interface:
                 return self.from_interface(type_)
             return self.from_object(type_)
-        if isinstance(type_, StrawberryUnion):
+        elif isinstance(type_, StrawberryUnion):
             return self.from_union(type_)
-        if isinstance(type_, ScalarDefinition):  # TODO: Replace with StrawberryScalar
+        elif isinstance(type_, ScalarDefinition):  # TODO: Replace with StrawberryScalar
             return self.from_scalar(type_)
-        return str(type_)
+        else:
+            return str(type_)
 
     def from_argument(self, argument: StrawberryArgument) -> str:
         return self.get_graphql_name(argument)

strawberry/schema/schema.py

@@ -30,7 +30,6 @@ from strawberry.extensions.directives import (
     DirectivesExtensionSync,
 )
 from strawberry.extensions.runner import SchemaExtensionsRunner
-from strawberry.printer import print_schema
 from strawberry.schema.schema_converter import GraphQLCoreConverter
 from strawberry.schema.types.scalar import DEFAULT_SCALAR_REGISTRY
 from strawberry.types import ExecutionContext
@@ -41,6 +40,7 @@ from strawberry.types.base import (
 )
 from strawberry.types.graphql import OperationType
 
+from ..printer import print_schema
 from . import compat
 from .base import BaseSchema
 from .config import StrawberryConfig
@@ -177,11 +177,9 @@ class Schema(BaseSchema):
                     self.schema_converter.from_schema_directive(type_)
                 )
             else:
-                if (
-                    has_object_definition(type_)
-                    and type_.__strawberry_definition__.is_graphql_generic
-                ):
-                    type_ = StrawberryAnnotation(type_).resolve()  # noqa: PLW2901
+                if has_object_definition(type_):
+                    if type_.__strawberry_definition__.is_graphql_generic:
+                        type_ = StrawberryAnnotation(type_).resolve()  # noqa: PLW2901
                 graphql_type = self.schema_converter.from_maybe_optional(type_)
                 if isinstance(graphql_type, GraphQLNonNull):
                     graphql_type = graphql_type.of_type

strawberry/schema/schema_converter.py

@@ -47,7 +47,6 @@ from strawberry.exceptions import (
     ScalarAlreadyRegisteredError,
     UnresolvedFieldTypeError,
 )
-from strawberry.extensions.field_extension import build_field_extension_resolvers
 from strawberry.schema.types.scalar import _make_scalar_type
 from strawberry.types.arguments import StrawberryArgument, convert_arguments
 from strawberry.types.base import (
@@ -58,7 +57,6 @@ from strawberry.types.base import (
     get_object_definition,
     has_object_definition,
 )
-from strawberry.types.cast import get_strawberry_type_cast
 from strawberry.types.enum import EnumDefinition
 from strawberry.types.field import UNRESOLVED
 from strawberry.types.lazy_type import LazyType
@@ -68,6 +66,7 @@ from strawberry.types.union import StrawberryUnion
 from strawberry.types.unset import UNSET
 from strawberry.utils.await_maybe import await_maybe
 
+from ..extensions.field_extension import build_field_extension_resolvers
 from . import compat
 from .types.concrete_type import ConcreteType
 
@@ -92,9 +91,7 @@ if TYPE_CHECKING:
 
 
 FieldType = TypeVar(
-    "FieldType",
-    bound=Union[GraphQLField, GraphQLInputField],
-    covariant=True,
+    "FieldType", bound=Union[GraphQLField, GraphQLInputField], covariant=True
 )
 
 
@@ -377,6 +374,8 @@ class GraphQLCoreConverter:
         # self.from_resolver needs to be called before accessing field.type because
         # in there a field extension might want to change the type during its apply
         resolver = self.from_resolver(field)
+        # TODO: think more about this
+        field._resolver = resolver  # type: ignore
         field_type = cast(
             "GraphQLOutputType",
             self.from_maybe_optional(
@@ -620,9 +619,6 @@ class GraphQLCoreConverter:
             )
 
             def is_type_of(obj: Any, _info: GraphQLResolveInfo) -> bool:
-                if (type_cast := get_strawberry_type_cast(obj)) is not None:
-                    return type_cast in possible_types
-
                 if object_type.concrete_of and (
                     has_object_definition(obj)
                     and obj.__strawberry_definition__.origin
@@ -762,8 +758,9 @@ class GraphQLCoreConverter:
         if field.is_async:
             _async_resolver._is_default = not field.base_resolver  # type: ignore
             return _async_resolver
-        _resolver._is_default = not field.base_resolver  # type: ignore
-        return _resolver
+        else:
+            _resolver._is_default = not field.base_resolver  # type: ignore
+            return _resolver
 
     def from_scalar(self, scalar: type) -> GraphQLScalarType:
         scalar_definition: ScalarDefinition
@@ -813,9 +810,10 @@ class GraphQLCoreConverter:
         NoneType = type(None)
         if type_ is None or type_ is NoneType:
             return self.from_type(type_)
-        if isinstance(type_, StrawberryOptional):
+        elif isinstance(type_, StrawberryOptional):
             return self.from_type(type_.of_type)
-        return GraphQLNonNull(self.from_type(type_))
+        else:
+            return GraphQLNonNull(self.from_type(type_))
 
     def from_type(self, type_: Union[StrawberryType, type]) -> GraphQLNullableType:
         if compat.is_graphql_generic(type_):
@@ -823,27 +821,27 @@ class GraphQLCoreConverter:
 
         if isinstance(type_, EnumDefinition):  # TODO: Replace with StrawberryEnum
             return self.from_enum(type_)
-        if compat.is_input_type(type_):  # TODO: Replace with StrawberryInputObject
+        elif compat.is_input_type(type_):  # TODO: Replace with StrawberryInputObject
             return self.from_input_object(type_)
-        if isinstance(type_, StrawberryList):
+        elif isinstance(type_, StrawberryList):
             return self.from_list(type_)
-        if compat.is_interface_type(type_):  # TODO: Replace with StrawberryInterface
+        elif compat.is_interface_type(type_):  # TODO: Replace with StrawberryInterface
             type_definition: StrawberryObjectDefinition = (
                 type_.__strawberry_definition__  # type: ignore
             )
             return self.from_interface(type_definition)
-        if has_object_definition(type_):
+        elif has_object_definition(type_):
             return self.from_object(type_.__strawberry_definition__)
-        if compat.is_enum(type_):  # TODO: Replace with StrawberryEnum
+        elif compat.is_enum(type_):  # TODO: Replace with StrawberryEnum
             enum_definition: EnumDefinition = type_._enum_definition  # type: ignore
             return self.from_enum(enum_definition)
-        if isinstance(type_, StrawberryObjectDefinition):
+        elif isinstance(type_, StrawberryObjectDefinition):
             return self.from_object(type_)
-        if isinstance(type_, StrawberryUnion):
+        elif isinstance(type_, StrawberryUnion):
             return self.from_union(type_)
-        if isinstance(type_, LazyType):
+        elif isinstance(type_, LazyType):
             return self.from_type(type_.resolve_type())
-        if compat.is_scalar(
+        elif compat.is_scalar(
             type_, self.scalar_registry
         ):  # TODO: Replace with StrawberryScalar
             return self.from_scalar(type_)
@@ -902,9 +900,6 @@ class GraphQLCoreConverter:
         if object_type.interfaces:
 
             def is_type_of(obj: Any, _info: GraphQLResolveInfo) -> bool:
-                if (type_cast := get_strawberry_type_cast(obj)) is not None:
-                    return type_cast is object_type.origin
-
                 if object_type.concrete_of and (
                     has_object_definition(obj)
                     and obj.__strawberry_definition__.origin

strawberry/schema/subscribe.py

@@ -27,7 +27,7 @@ if TYPE_CHECKING:
     from graphql.execution.middleware import MiddlewareManager
     from graphql.type.schema import GraphQLSchema
 
-    from strawberry.extensions.runner import SchemaExtensionsRunner
+    from ..extensions.runner import SchemaExtensionsRunner
 
 SubscriptionResult: TypeAlias = Union[
     PreExecutionError, AsyncGenerator[ExecutionResult, None]
@@ -80,7 +80,7 @@ async def _subscribe(
                     )
                 # graphql-core 3.2 doesn't handle some of the pre-execution errors.
                 # see `test_subscription_immediate_error`
-                except Exception as exc:  # noqa: BLE001
+                except Exception as exc:
                     aiter_or_result = OriginalExecutionResult(
                         data=None, errors=[_coerce_error(exc)]
                     )
@@ -103,7 +103,7 @@ async def _subscribe(
                             process_errors,
                         )
                 # graphql-core doesn't handle exceptions raised while executing.
-                except Exception as exc:  # noqa: BLE001
+                except Exception as exc:
                     yield await _handle_execution_result(
                         execution_context,
                         OriginalExecutionResult(data=None, errors=[_coerce_error(exc)]),
@@ -111,7 +111,7 @@ async def _subscribe(
                         process_errors,
                     )
         # catch exceptions raised in `on_execute` hook.
-        except Exception as exc:  # noqa: BLE001
+        except Exception as exc:
             origin_result = OriginalExecutionResult(
                 data=None, errors=[_coerce_error(exc)]
             )

strawberry/schema/types/base_scalars.py

@@ -15,9 +15,7 @@ def wrap_parser(parser: Callable, type_: str) -> Callable:
         try:
             return parser(value)
         except ValueError as e:
-            raise GraphQLError(  # noqa: B904
-                f'Value cannot represent a {type_}: "{value}". {e}'
-            )
+            raise GraphQLError(f'Value cannot represent a {type_}: "{value}". {e}')
 
     return inner
 
@@ -26,7 +24,7 @@ def parse_decimal(value: object) -> decimal.Decimal:
     try:
         return decimal.Decimal(str(value))
     except decimal.DecimalException:
-        raise GraphQLError(f'Value cannot represent a Decimal: "{value}".')  # noqa: B904
+        raise GraphQLError(f'Value cannot represent a Decimal: "{value}".')
 
 
 isoformat = methodcaller("isoformat")

strawberry/schema/types/scalar.py

@@ -62,7 +62,7 @@ DEFAULT_SCALAR_REGISTRY: dict[object, ScalarDefinition] = {
     datetime.datetime: _get_scalar_definition(base_scalars.DateTime),
     datetime.time: _get_scalar_definition(base_scalars.Time),
     decimal.Decimal: _get_scalar_definition(base_scalars.Decimal),
-    # We can't wrap GlobalID with @scalar because it has custom attributes/methods
+    # We can't wrap GLobalID with @scalar because it has custom attributes/methods
     GlobalID: _get_scalar_definition(
         scalar(
             GlobalID,

strawberry/schema_codegen/__init__.py

@@ -115,7 +115,7 @@ def _get_field_type(
 
     if isinstance(field_type, NonNullTypeNode):
         return _get_field_type(field_type.type, was_non_nullable=True)
-    if isinstance(field_type, ListTypeNode):
+    elif isinstance(field_type, ListTypeNode):
         expr = cst.Subscript(
             value=cst.Name("list"),
             slice=[
@@ -262,13 +262,14 @@ ArgumentValue: TypeAlias = Union[str, bool, list["ArgumentValue"]]
 def _get_argument_value(argument_value: ConstValueNode) -> ArgumentValue:
     if isinstance(argument_value, StringValueNode):
         return argument_value.value
-    if isinstance(argument_value, EnumValueDefinitionNode):
+    elif isinstance(argument_value, EnumValueDefinitionNode):
         return argument_value.name.value
-    if isinstance(argument_value, ListValueNode):
+    elif isinstance(argument_value, ListValueNode):
         return [_get_argument_value(arg) for arg in argument_value.values]
-    if isinstance(argument_value, BooleanValueNode):
+    elif isinstance(argument_value, BooleanValueNode):
         return argument_value.value
-    raise NotImplementedError(f"Unknown argument value {argument_value}")
+    else:
+        raise NotImplementedError(f"Unknown argument value {argument_value}")
 
 
 def _get_directives(

strawberry/subscriptions/protocols/graphql_transport_ws/handlers.py

@@ -122,7 +122,7 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
             self.connection_timed_out = True
             reason = "Connection initialisation timeout"
             await self.websocket.close(code=4408, reason=reason)
-        except Exception as error:  # noqa: BLE001
+        except Exception as error:
             await self.handle_task_exception(error)  # pragma: no cover
         finally:
             # do not clear self.connection_init_timeout_task
@@ -298,7 +298,7 @@ class BaseGraphQLTransportWSHandler(Generic[Context, RootValue]):
                     {"id": operation.id, "type": "complete"}
                 )
 
-        except BaseException:  # pragma: no cover
+        except BaseException as e:  # pragma: no cover
             self.operations.pop(operation.id, None)
             raise
         finally:

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -34,6 +34,9 @@ if TYPE_CHECKING:
 
 
 class BaseGraphQLWSHandler(Generic[Context, RootValue]):
+    context: Context
+    root_value: RootValue
+
     def __init__(
         self,
         view: AsyncBaseHTTPView[Any, Any, Any, Any, Any, Context, RootValue],

strawberry/test/client.py

@@ -188,7 +188,8 @@ class BaseGraphQLTestClient(ABC):
         # Variables can be mixed files and other data, we don't want to map non-files
         # vars so we need to remove them, we can't remove them before
         # because they can be part of a list of files or folder
-        return {k: v for k, v in map.items() if k in files}
+        map_without_vars = {k: v for k, v in map.items() if k in files}
+        return map_without_vars
 
     def _decode(self, response: Any, type: Literal["multipart", "json"]) -> Any:
         if type == "multipart":

strawberry/types/arguments.py

@@ -23,8 +23,8 @@ from strawberry.types.base import (
 )
 from strawberry.types.enum import EnumDefinition
 from strawberry.types.lazy_type import LazyType, StrawberryLazyReference
-from strawberry.types.unset import UNSET as _deprecated_UNSET  # noqa: N811
-from strawberry.types.unset import _deprecated_is_unset  # noqa: F401
+from strawberry.types.unset import UNSET as _deprecated_UNSET
+from strawberry.types.unset import _deprecated_is_unset  # noqa # type: ignore
 
 if TYPE_CHECKING:
     from strawberry.schema.config import StrawberryConfig

strawberry/types/auto.py

@@ -23,8 +23,8 @@ class StrawberryAutoMeta(type):
 
     """
 
-    def __init__(cls, *args: str, **kwargs: Any) -> None:
-        cls._instance: Optional[StrawberryAuto] = None
+    def __init__(self, *args: str, **kwargs: Any) -> None:
+        self._instance: Optional[StrawberryAuto] = None
         super().__init__(*args, **kwargs)
 
     def __call__(cls, *args: str, **kwargs: Any) -> Any:
@@ -34,7 +34,7 @@ class StrawberryAutoMeta(type):
         return cls._instance
 
     def __instancecheck__(
-        cls,
+        self,
         instance: Union[StrawberryAuto, StrawberryAnnotation, StrawberryType, type],
     ) -> bool:
         if isinstance(instance, StrawberryAnnotation):

strawberry/types/base.py

@@ -54,12 +54,12 @@ class StrawberryType(ABC):
             str, Union[StrawberryType, type[WithStrawberryObjectDefinition]]
         ],
     ) -> Union[StrawberryType, type[WithStrawberryObjectDefinition]]:
-        raise NotImplementedError
+        raise NotImplementedError()
 
     @property
     @abstractmethod
     def is_graphql_generic(self) -> bool:
-        raise NotImplementedError
+        raise NotImplementedError()
 
     def has_generic(self, type_var: TypeVar) -> bool:
         return False
@@ -70,15 +70,17 @@ class StrawberryType(ABC):
         if isinstance(other, StrawberryType):
             return self is other
 
-        if isinstance(other, StrawberryAnnotation):
+        elif isinstance(other, StrawberryAnnotation):
             return self == other.resolve()
 
-        # This could be simplified if StrawberryAnnotation.resolve() always returned
-        # a StrawberryType
-        resolved = StrawberryAnnotation(other).resolve()
-        if isinstance(resolved, StrawberryType):
-            return self == resolved
-        return NotImplemented
+        else:
+            # This could be simplified if StrawberryAnnotation.resolve() always returned
+            # a StrawberryType
+            resolved = StrawberryAnnotation(other).resolve()
+            if isinstance(resolved, StrawberryType):
+                return self == resolved
+            else:
+                return NotImplemented
 
     def __hash__(self) -> int:
         # TODO: Is this a bad idea? __eq__ objects are supposed to have the same hash
@@ -98,7 +100,8 @@ class StrawberryContainer(StrawberryType):
         if isinstance(other, StrawberryType):
             if isinstance(other, StrawberryContainer):
                 return self.of_type == other.of_type
-            return False
+            else:
+                return False
 
         return super().__eq__(other)
 
@@ -109,10 +112,11 @@ class StrawberryContainer(StrawberryType):
 
             return list(parameters) if parameters else []
 
-        if isinstance(self.of_type, StrawberryType):
+        elif isinstance(self.of_type, StrawberryType):
             return self.of_type.type_params
 
-        return []
+        else:
+            return []
 
     def copy_with(
         self,

strawberry/types/field.py

@@ -191,21 +191,17 @@ class StrawberryField(dataclasses.Field):
         for argument in resolver.arguments:
             if isinstance(argument.type_annotation.annotation, str):
                 continue
-
-            if isinstance(argument.type, StrawberryUnion):
-                raise InvalidArgumentTypeError(
-                    resolver,
-                    argument,
-                )
-
-            if (
-                has_object_definition(argument.type)
-                and argument.type.__strawberry_definition__.is_interface
-            ):
+            elif isinstance(argument.type, StrawberryUnion):
                 raise InvalidArgumentTypeError(
                     resolver,
                     argument,
                 )
+            elif has_object_definition(argument.type):
+                if argument.type.__strawberry_definition__.is_interface:
+                    raise InvalidArgumentTypeError(
+                        resolver,
+                        argument,
+                    )
 
         self.base_resolver = resolver
 

strawberry/types/fields/resolver.py

@@ -91,7 +91,8 @@ class ReservedNameBoundParameter(NamedTuple):
         if parameters:  # Add compatibility for resolvers with no arguments
             first_parameter = parameters[0]
             return first_parameter if first_parameter.name == self.name else None
-        return None
+        else:
+            return None
 
 
 class ReservedType(NamedTuple):
@@ -144,19 +145,21 @@ class ReservedType(NamedTuple):
             )
             warnings.warn(warning, stacklevel=3)
             return reserved_name
-        return None
+        else:
+            return None
 
     def is_reserved_type(self, other: builtins.type) -> bool:
         origin = cast(type, get_origin(other)) or other
         if origin is Annotated:
             # Handle annotated arguments such as Private[str] and DirectiveValue[str]
             return type_has_annotation(other, self.type)
-        # Handle both concrete and generic types (i.e Info, and Info)
-        return (
-            issubclass(origin, self.type)
-            if isinstance(origin, type)
-            else origin is self.type
-        )
+        else:
+            # Handle both concrete and generic types (i.e Info, and Info)
+            return (
+                issubclass(origin, self.type)
+                if isinstance(origin, type)
+                else origin is self.type
+            )
 
 
 SELF_PARAMSPEC = ReservedNameBoundParameter("self")
@@ -306,20 +309,24 @@ class StrawberryResolver(Generic[T]):
         reserved_names = {p.name for p in reserved_parameters.values() if p is not None}
 
         annotations = self._unbound_wrapped_func.__annotations__
-        return {
+        annotations = {
             name: annotation
             for name, annotation in annotations.items()
             if name not in reserved_names
         }
 
+        return annotations
+
     @cached_property
     def type_annotation(self) -> Optional[StrawberryAnnotation]:
         return_annotation = self.signature.return_annotation
         if return_annotation is inspect.Signature.empty:
             return None
-        return StrawberryAnnotation(
-            annotation=return_annotation, namespace=self._namespace
-        )
+        else:
+            type_annotation = StrawberryAnnotation(
+                annotation=return_annotation, namespace=self._namespace
+            )
+        return type_annotation
 
     @property
     def type(self) -> Optional[Union[StrawberryType, type]]:

strawberry/types/union.py

@@ -54,7 +54,7 @@ class StrawberryUnion(StrawberryType):
     def __init__(
         self,
         name: Optional[str] = None,
-        type_annotations: tuple[StrawberryAnnotation, ...] = (),
+        type_annotations: tuple[StrawberryAnnotation, ...] = tuple(),
         description: Optional[str] = None,
         directives: Iterable[object] = (),
     ) -> None:

strawberry/types/unset.py

@@ -14,7 +14,8 @@ class UnsetType:
             ret = super().__new__(cls)
             cls.__instance = ret
             return ret
-        return cls.__instance
+        else:
+            return cls.__instance
 
     def __str__(self) -> str:
         return ""

strawberry/utils/debug.py

@@ -30,7 +30,7 @@ def pretty_print_graphql_operation(
     if operation_name == "IntrospectionQuery":
         return
 
-    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")  # noqa: DTZ005
+    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
     print(f"[{now}]: {operation_name or 'No operation name'}")  # noqa: T201
     print(highlight(query, GraphQLLexer(), Terminal256Formatter()))  # noqa: T201

strawberry/utils/deprecations.py

@@ -4,7 +4,7 @@ import warnings
 from typing import Any, Optional
 
 
-class DEPRECATION_MESSAGES:  # noqa: N801
+class DEPRECATION_MESSAGES:
     _TYPE_DEFINITION = (
         "_type_definition is deprecated, use __strawberry_definition__ instead"
     )

strawberry/utils/graphql_lexer.py

@@ -1,5 +1,3 @@
-from typing import Any, ClassVar
-
 from pygments import token
 from pygments.lexer import RegexLexer
 
@@ -8,11 +6,11 @@ class GraphQLLexer(RegexLexer):
     """GraphQL Lexer for Pygments, used by the debug server."""
 
     name = "GraphQL"
-    aliases: ClassVar[list[str]] = ["graphql", "gql"]
-    filenames: ClassVar[list[str]] = ["*.graphql", "*.gql"]
-    mimetypes: ClassVar[list[str]] = ["application/graphql"]
+    aliases = ["graphql", "gql"]
+    filenames = ["*.graphql", "*.gql"]
+    mimetypes = ["application/graphql"]
 
-    tokens: ClassVar[dict[str, list[tuple[str, Any]]]] = {
+    tokens = {
         "root": [
             (r"#.*", token.Comment.Singline),
             (r"\.\.\.", token.Operator),