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

strawberry/relay/types.py

@@ -758,7 +758,7 @@ class ListConnection(Connection[NodeType]):
     )
 
     @classmethod
-    def resolve_connection(
+    def resolve_connection(  # noqa: PLR0915
         cls,
         nodes: NodeIterableType[NodeType],
         *,

strawberry/schema/base.py

@@ -1,7 +1,6 @@
 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
 
@@ -88,7 +87,6 @@ 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:
+        except Exception as error:  # noqa: BLE001
             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) as e:
-        raise e
-    except Exception as exc:
+    except (MissingQueryError, InvalidOperationTypeError):
+        raise
+    except Exception as exc:  # noqa: BLE001
         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()
+                raise MissingQueryError  # noqa: TRY301
 
             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)
+                raise InvalidOperationTypeError(execution_context.operation_type)  # noqa: TRY301
 
             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(
+                        raise RuntimeError(  # noqa: TRY301
                             "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) as e:
-        raise e
-    except Exception as exc:
+    except (MissingQueryError, InvalidOperationTypeError):
+        raise
+    except Exception as exc:  # noqa: BLE001
         errors = [_coerce_error(exc)]
         execution_context.errors = errors
         process_errors(errors, execution_context)

strawberry/schema/name_converter.py

@@ -47,18 +47,17 @@ class NameConverter:
             return self.from_directive(type_)
         if isinstance(type_, EnumDefinition):  # TODO: Replace with StrawberryEnum
             return self.from_enum(type_)
-        elif isinstance(type_, StrawberryObjectDefinition):
+        if 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_)
-        elif isinstance(type_, StrawberryUnion):
+        if isinstance(type_, StrawberryUnion):
             return self.from_union(type_)
-        elif isinstance(type_, ScalarDefinition):  # TODO: Replace with StrawberryScalar
+        if isinstance(type_, ScalarDefinition):  # TODO: Replace with StrawberryScalar
             return self.from_scalar(type_)
-        else:
-            return str(type_)
+        return str(type_)
 
     def from_argument(self, argument: StrawberryArgument) -> str:
         return self.get_graphql_name(argument)

strawberry/schema/schema.py

@@ -30,6 +30,7 @@ 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
@@ -40,7 +41,6 @@ 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,9 +177,11 @@ class Schema(BaseSchema):
                     self.schema_converter.from_schema_directive(type_)
                 )
             else:
-                if has_object_definition(type_):
-                    if type_.__strawberry_definition__.is_graphql_generic:
-                        type_ = StrawberryAnnotation(type_).resolve()  # noqa: PLW2901
+                if (
+                    has_object_definition(type_)
+                    and 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,6 +47,7 @@ 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 (
@@ -57,6 +58,7 @@ 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
@@ -66,7 +68,6 @@ 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
 
@@ -91,7 +92,9 @@ if TYPE_CHECKING:
 
 
 FieldType = TypeVar(
-    "FieldType", bound=Union[GraphQLField, GraphQLInputField], covariant=True
+    "FieldType",
+    bound=Union[GraphQLField, GraphQLInputField],
+    covariant=True,
 )
 
 
@@ -617,6 +620,9 @@ 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
@@ -756,9 +762,8 @@ class GraphQLCoreConverter:
         if field.is_async:
             _async_resolver._is_default = not field.base_resolver  # type: ignore
             return _async_resolver
-        else:
-            _resolver._is_default = not field.base_resolver  # type: ignore
-            return _resolver
+        _resolver._is_default = not field.base_resolver  # type: ignore
+        return _resolver
 
     def from_scalar(self, scalar: type) -> GraphQLScalarType:
         scalar_definition: ScalarDefinition
@@ -808,10 +813,9 @@ class GraphQLCoreConverter:
         NoneType = type(None)
         if type_ is None or type_ is NoneType:
             return self.from_type(type_)
-        elif isinstance(type_, StrawberryOptional):
+        if isinstance(type_, StrawberryOptional):
             return self.from_type(type_.of_type)
-        else:
-            return GraphQLNonNull(self.from_type(type_))
+        return GraphQLNonNull(self.from_type(type_))
 
     def from_type(self, type_: Union[StrawberryType, type]) -> GraphQLNullableType:
         if compat.is_graphql_generic(type_):
@@ -819,27 +823,27 @@ class GraphQLCoreConverter:
 
         if isinstance(type_, EnumDefinition):  # TODO: Replace with StrawberryEnum
             return self.from_enum(type_)
-        elif compat.is_input_type(type_):  # TODO: Replace with StrawberryInputObject
+        if compat.is_input_type(type_):  # TODO: Replace with StrawberryInputObject
             return self.from_input_object(type_)
-        elif isinstance(type_, StrawberryList):
+        if isinstance(type_, StrawberryList):
             return self.from_list(type_)
-        elif compat.is_interface_type(type_):  # TODO: Replace with StrawberryInterface
+        if compat.is_interface_type(type_):  # TODO: Replace with StrawberryInterface
             type_definition: StrawberryObjectDefinition = (
                 type_.__strawberry_definition__  # type: ignore
             )
             return self.from_interface(type_definition)
-        elif has_object_definition(type_):
+        if has_object_definition(type_):
             return self.from_object(type_.__strawberry_definition__)
-        elif compat.is_enum(type_):  # TODO: Replace with StrawberryEnum
+        if compat.is_enum(type_):  # TODO: Replace with StrawberryEnum
             enum_definition: EnumDefinition = type_._enum_definition  # type: ignore
             return self.from_enum(enum_definition)
-        elif isinstance(type_, StrawberryObjectDefinition):
+        if isinstance(type_, StrawberryObjectDefinition):
             return self.from_object(type_)
-        elif isinstance(type_, StrawberryUnion):
+        if isinstance(type_, StrawberryUnion):
             return self.from_union(type_)
-        elif isinstance(type_, LazyType):
+        if isinstance(type_, LazyType):
             return self.from_type(type_.resolve_type())
-        elif compat.is_scalar(
+        if compat.is_scalar(
             type_, self.scalar_registry
         ):  # TODO: Replace with StrawberryScalar
             return self.from_scalar(type_)
@@ -898,6 +902,9 @@ 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 ..extensions.runner import SchemaExtensionsRunner
+    from strawberry.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:
+                except Exception as exc:  # noqa: BLE001
                     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:
+                except Exception as exc:  # noqa: BLE001
                     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:
+        except Exception as exc:  # noqa: BLE001
             origin_result = OriginalExecutionResult(
                 data=None, errors=[_coerce_error(exc)]
             )

strawberry/schema/types/base_scalars.py

@@ -15,7 +15,9 @@ def wrap_parser(parser: Callable, type_: str) -> Callable:
         try:
             return parser(value)
         except ValueError as e:
-            raise GraphQLError(f'Value cannot represent a {type_}: "{value}". {e}')
+            raise GraphQLError(  # noqa: B904
+                f'Value cannot represent a {type_}: "{value}". {e}'
+            )
 
     return inner
 
@@ -24,7 +26,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}".')
+        raise GraphQLError(f'Value cannot represent a Decimal: "{value}".')  # noqa: B904
 
 
 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)
-    elif isinstance(field_type, ListTypeNode):
+    if isinstance(field_type, ListTypeNode):
         expr = cst.Subscript(
             value=cst.Name("list"),
             slice=[
@@ -262,14 +262,13 @@ ArgumentValue: TypeAlias = Union[str, bool, list["ArgumentValue"]]
 def _get_argument_value(argument_value: ConstValueNode) -> ArgumentValue:
     if isinstance(argument_value, StringValueNode):
         return argument_value.value
-    elif isinstance(argument_value, EnumValueDefinitionNode):
+    if isinstance(argument_value, EnumValueDefinitionNode):
         return argument_value.name.value
-    elif isinstance(argument_value, ListValueNode):
+    if isinstance(argument_value, ListValueNode):
         return [_get_argument_value(arg) for arg in argument_value.values]
-    elif isinstance(argument_value, BooleanValueNode):
+    if isinstance(argument_value, BooleanValueNode):
         return argument_value.value
-    else:
-        raise NotImplementedError(f"Unknown argument value {argument_value}")
+    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:
+        except Exception as error:  # noqa: BLE001
             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 as e:  # pragma: no cover
+        except BaseException:  # pragma: no cover
             self.operations.pop(operation.id, None)
             raise
         finally:

strawberry/subscriptions/protocols/graphql_ws/handlers.py

@@ -34,9 +34,6 @@ 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,8 +188,7 @@ 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
-        map_without_vars = {k: v for k, v in map.items() if k in files}
-        return map_without_vars
+        return {k: v for k, v in map.items() if k in files}
 
     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
-from strawberry.types.unset import _deprecated_is_unset  # noqa # type: ignore
+from strawberry.types.unset import UNSET as _deprecated_UNSET  # noqa: N811
+from strawberry.types.unset import _deprecated_is_unset  # noqa: F401
 
 if TYPE_CHECKING:
     from strawberry.schema.config import StrawberryConfig

strawberry/types/auto.py

@@ -23,8 +23,8 @@ class StrawberryAutoMeta(type):
 
     """
 
-    def __init__(self, *args: str, **kwargs: Any) -> None:
-        self._instance: Optional[StrawberryAuto] = None
+    def __init__(cls, *args: str, **kwargs: Any) -> None:
+        cls._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__(
-        self,
+        cls,
         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,17 +70,15 @@ class StrawberryType(ABC):
         if isinstance(other, StrawberryType):
             return self is other
 
-        elif isinstance(other, StrawberryAnnotation):
+        if isinstance(other, StrawberryAnnotation):
             return self == other.resolve()
 
-        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
+        # This could be simplified if StrawberryAnnotation.resolve() always returned
+        # a StrawberryType
+        resolved = StrawberryAnnotation(other).resolve()
+        if isinstance(resolved, StrawberryType):
+            return self == resolved
+        return NotImplemented
 
     def __hash__(self) -> int:
         # TODO: Is this a bad idea? __eq__ objects are supposed to have the same hash
@@ -100,8 +98,7 @@ class StrawberryContainer(StrawberryType):
         if isinstance(other, StrawberryType):
             if isinstance(other, StrawberryContainer):
                 return self.of_type == other.of_type
-            else:
-                return False
+            return False
 
         return super().__eq__(other)
 
@@ -112,11 +109,10 @@ class StrawberryContainer(StrawberryType):
 
             return list(parameters) if parameters else []
 
-        elif isinstance(self.of_type, StrawberryType):
+        if isinstance(self.of_type, StrawberryType):
             return self.of_type.type_params
 
-        else:
-            return []
+        return []
 
     def copy_with(
         self,

strawberry/types/cast.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Any, TypeVar, overload
+
+_T = TypeVar("_T", bound=object)
+
+TYPE_CAST_ATTRIBUTE = "__as_strawberry_type__"
+
+
+@overload
+def cast(type_: type, obj: None) -> None: ...
+
+
+@overload
+def cast(type_: type, obj: _T) -> _T: ...
+
+
+def cast(type_: type, obj: _T | None) -> _T | None:
+    """Cast an object to given type.
+
+    This is used to mark an object as a cast object, so that the type can be
+    picked up when resolving unions/interfaces in case of ambiguity, which can
+    happen when returning an alike object instead of an instance of the type
+    (e.g. returning a Django, Pydantic or SQLAlchemy object)
+    """
+    if obj is None:
+        return None
+
+    setattr(obj, TYPE_CAST_ATTRIBUTE, type_)
+    return obj
+
+
+def get_strawberry_type_cast(obj: Any) -> type | None:
+    """Get the type of a cast object."""
+    return getattr(obj, TYPE_CAST_ATTRIBUTE, None)

strawberry/types/field.py

@@ -191,17 +191,21 @@ class StrawberryField(dataclasses.Field):
         for argument in resolver.arguments:
             if isinstance(argument.type_annotation.annotation, str):
                 continue
-            elif isinstance(argument.type, StrawberryUnion):
+
+            if isinstance(argument.type, StrawberryUnion):
+                raise InvalidArgumentTypeError(
+                    resolver,
+                    argument,
+                )
+
+            if (
+                has_object_definition(argument.type)
+                and argument.type.__strawberry_definition__.is_interface
+            ):
                 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,8 +91,7 @@ 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
-        else:
-            return None
+        return None
 
 
 class ReservedType(NamedTuple):
@@ -145,21 +144,19 @@ class ReservedType(NamedTuple):
             )
             warnings.warn(warning, stacklevel=3)
             return reserved_name
-        else:
-            return None
+        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)
-        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
-            )
+        # 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")
@@ -309,24 +306,20 @@ 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__
-        annotations = {
+        return {
             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
-        else:
-            type_annotation = StrawberryAnnotation(
-                annotation=return_annotation, namespace=self._namespace
-            )
-        return type_annotation
+        return StrawberryAnnotation(
+            annotation=return_annotation, namespace=self._namespace
+        )
 
     @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, ...] = tuple(),
+        type_annotations: tuple[StrawberryAnnotation, ...] = (),
         description: Optional[str] = None,
         directives: Iterable[object] = (),
     ) -> None:

strawberry/types/unset.py

@@ -14,8 +14,7 @@ class UnsetType:
             ret = super().__new__(cls)
             cls.__instance = ret
             return ret
-        else:
-            return cls.__instance
+        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")
+    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")  # noqa: DTZ005
 
     print(f"[{now}]: {operation_name or 'No operation name'}")  # noqa: T201
     print(highlight(query, GraphQLLexer(), Terminal256Formatter()))  # noqa: T201