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

strawberry/__init__.py

@@ -13,7 +13,6 @@ from .schema import Schema
 from .schema_directive import schema_directive
 from .types.arguments import argument
 from .types.auto import auto
-from .types.cast import cast
 from .types.enum import enum, enum_value
 from .types.field import field
 from .types.info import Info
@@ -37,7 +36,6 @@ __all__ = [
     "argument",
     "asdict",
     "auto",
-    "cast",
     "directive",
     "directive_field",
     "enum",

strawberry/aiohttp/test/client.py

@@ -57,11 +57,13 @@ class GraphQLTestClient(BaseGraphQLTestClient):
         headers: Optional[dict[str, object]] = None,
         files: Optional[dict[str, object]] = None,
     ) -> Any:
-        return await self._client.post(
+        response = await self._client.post(
             self.url,
             json=body if not files else None,
             data=body if files else None,
         )
 
+        return response
+
 
 __all__ = ["GraphQLTestClient"]

strawberry/aiohttp/views.py

@@ -99,12 +99,12 @@ class AioHTTPWebSocketAdapter(AsyncWebSocketAdapter):
             if ws_message.type == http.WSMsgType.TEXT:
                 try:
                     yield self.view.decode_json(ws_message.data)
-                except JSONDecodeError as e:
+                except JSONDecodeError:
                     if not ignore_parsing_errors:
-                        raise NonJsonMessageReceived from e
+                        raise NonJsonMessageReceived()
 
             elif ws_message.type == http.WSMsgType.BINARY:
-                raise NonTextMessageReceived
+                raise NonTextMessageReceived()
 
     async def send_json(self, message: Mapping[str, object]) -> None:
         try:

strawberry/annotation.py

@@ -107,7 +107,9 @@ class StrawberryAnnotation:
         if isinstance(annotation, str):
             annotation = ForwardRef(annotation)
 
-        return eval_type(annotation, self.namespace, None)
+        evaled_type = eval_type(annotation, self.namespace, None)
+
+        return evaled_type
 
     def _get_type_with_args(
         self, evaled_type: type[Any]
@@ -153,13 +155,13 @@ class StrawberryAnnotation:
         # a StrawberryType
         if self._is_enum(evaled_type):
             return self.create_enum(evaled_type)
-        if self._is_optional(evaled_type, args):
+        elif self._is_optional(evaled_type, args):
             return self.create_optional(evaled_type)
-        if self._is_union(evaled_type, args):
+        elif self._is_union(evaled_type, args):
             return self.create_union(evaled_type, args)
-        if is_type_var(evaled_type) or evaled_type is Self:
+        elif is_type_var(evaled_type) or evaled_type is Self:
             return self.create_type_var(cast(TypeVar, evaled_type))
-        if self._is_strawberry_type(evaled_type):
+        elif self._is_strawberry_type(evaled_type):
             # Simply return objects that are already StrawberryTypes
             return evaled_type
 

strawberry/asgi/__init__.py

@@ -97,11 +97,11 @@ class ASGIWebSocketAdapter(AsyncWebSocketAdapter):
                 try:
                     text = await self.ws.receive_text()
                     yield self.view.decode_json(text)
-                except JSONDecodeError as e:  # noqa: PERF203
+                except JSONDecodeError:  # noqa: PERF203
                     if not ignore_parsing_errors:
-                        raise NonJsonMessageReceived from e
-        except KeyError as e:
-            raise NonTextMessageReceived from e
+                        raise NonJsonMessageReceived()
+        except KeyError:
+            raise NonTextMessageReceived()
         except WebSocketDisconnect:  # pragma: no cover
             pass
 

strawberry/channels/handlers/ws_handler.py

@@ -45,13 +45,13 @@ class ChannelsWebSocketAdapter(AsyncWebSocketAdapter):
                 break
 
             if message["message"] is None:
-                raise NonTextMessageReceived
+                raise NonTextMessageReceived()
 
             try:
                 yield self.view.decode_json(message["message"])
-            except json.JSONDecodeError as e:
+            except json.JSONDecodeError:
                 if not ignore_parsing_errors:
-                    raise NonJsonMessageReceived from e
+                    raise NonJsonMessageReceived()
 
     async def send_json(self, message: Mapping[str, object]) -> None:
         serialized_message = self.view.encode_json(message)

strawberry/channels/testing.py

@@ -55,7 +55,7 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         path: str,
         headers: Optional[list[tuple[bytes, bytes]]] = None,
         protocol: str = GRAPHQL_TRANSPORT_WS_PROTOCOL,
-        connection_params: dict | None = None,
+        connection_params: dict = {},
         **kwargs: Any,
     ) -> None:
         """Create a new communicator.
@@ -69,8 +69,6 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
             subprotocols: an ordered list of preferred subprotocols to be sent to the server.
             **kwargs: additional arguments to be passed to the `WebsocketCommunicator` constructor.
         """
-        if connection_params is None:
-            connection_params = {}
         self.protocol = protocol
         subprotocols = kwargs.get("subprotocols", [])
         subprotocols.append(protocol)

strawberry/cli/__init__.py

@@ -1,12 +1,10 @@
 try:
     from .app import app
-    from .commands.codegen import codegen as codegen  # noqa: PLC0414
-    from .commands.export_schema import export_schema as export_schema  # noqa: PLC0414
-    from .commands.schema_codegen import (
-        schema_codegen as schema_codegen,  # noqa: PLC0414
-    )
-    from .commands.server import server as server  # noqa: PLC0414
-    from .commands.upgrade import upgrade as upgrade  # noqa: PLC0414
+    from .commands.codegen import codegen as codegen  # noqa
+    from .commands.export_schema import export_schema as export_schema  # noqa
+    from .commands.schema_codegen import schema_codegen as schema_codegen  # noqa
+    from .commands.server import server as server  # noqa
+    from .commands.upgrade import upgrade as upgrade  # noqa
 
     def run() -> None:
         app()

strawberry/cli/commands/codegen.py

@@ -39,21 +39,23 @@ def _import_plugin(plugin: str) -> Optional[type[QueryCodegenPlugin]]:
 
         assert _is_codegen_plugin(obj)
         return obj
-
-    symbols = {
-        key: value for key, value in module.__dict__.items() if not key.startswith("__")
-    }
-
-    if "__all__" in module.__dict__:
+    else:
         symbols = {
-            name: symbol
-            for name, symbol in symbols.items()
-            if name in module.__dict__["__all__"]
+            key: value
+            for key, value in module.__dict__.items()
+            if not key.startswith("__")
         }
 
-    for obj in symbols.values():
-        if _is_codegen_plugin(obj):
-            return obj
+        if "__all__" in module.__dict__:
+            symbols = {
+                name: symbol
+                for name, symbol in symbols.items()
+                if name in module.__dict__["__all__"]
+            }
+
+        for obj in symbols.values():
+            if _is_codegen_plugin(obj):
+                return obj
 
     return None
 

strawberry/cli/commands/server.py

@@ -25,7 +25,7 @@ class LogLevel(str, Enum):
 @app.command(help="Starts debug server")
 def server(
     schema: str,
-    host: str = typer.Option("0.0.0.0", "-h", "--host", show_default=True),  # noqa: S104
+    host: str = typer.Option("0.0.0.0", "-h", "--host", show_default=True),
     port: int = typer.Option(8000, "-p", "--port", show_default=True),
     log_level: LogLevel = typer.Option(
         "error",
@@ -60,7 +60,7 @@ def server(
             "install them by running:\n"
             r"pip install 'strawberry-graphql\[debug-server]'"
         )
-        raise typer.Exit(1)  # noqa: B904
+        raise typer.Exit(1)
 
     load_schema(schema, app_dir=app_dir)
 

strawberry/cli/commands/upgrade/_run_codemod.py

@@ -41,8 +41,9 @@ def _execute_transform_wrap(
         additional_kwargs["scratch"] = {}
 
     # TODO: maybe capture warnings?
-    with open(os.devnull, "w") as null, contextlib.redirect_stderr(null):  # noqa: PTH123
-        return _execute_transform(**job, **additional_kwargs)
+    with open(os.devnull, "w") as null:  # noqa: PTH123
+        with contextlib.redirect_stderr(null):
+            return _execute_transform(**job, **additional_kwargs)
 
 
 def _get_progress_and_pool(

strawberry/cli/utils/__init__.py

@@ -16,7 +16,7 @@ def load_schema(schema: str, app_dir: str) -> Schema:
         message = str(exc)
 
         rich.print(f"[red]Error: {message}")
-        raise typer.Exit(2)  # noqa: B904
+        raise typer.Exit(2)
 
     if not isinstance(schema_symbol, Schema):
         message = "The `schema` must be an instance of strawberry.Schema"

strawberry/codegen/plugins/python.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import textwrap
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, ClassVar, Optional
+from typing import TYPE_CHECKING, Optional
 
 from strawberry.codegen import CodegenFile, QueryCodegenPlugin
 from strawberry.codegen.types import (
@@ -35,7 +35,7 @@ class PythonType:
 
 
 class PythonPlugin(QueryCodegenPlugin):
-    SCALARS_TO_PYTHON_TYPES: ClassVar[dict[str, PythonType]] = {
+    SCALARS_TO_PYTHON_TYPES: dict[str, PythonType] = {
         "ID": PythonType("str"),
         "Int": PythonType("int"),
         "String": PythonType("str"),
@@ -128,7 +128,7 @@ class PythonPlugin(QueryCodegenPlugin):
                     + ", ".join(self._print_argument_value(v) for v in argval.values)
                     + "]"
                 )
-            if isinstance(argval.values, dict):
+            elif isinstance(argval.values, dict):
                 return (
                     "{"
                     + ", ".join(
@@ -137,7 +137,8 @@ class PythonPlugin(QueryCodegenPlugin):
                     )
                     + "}"
                 )
-            raise TypeError(f"Unrecognized values type: {argval}")
+            else:
+                raise TypeError(f"Unrecognized values type: {argval}")
         if isinstance(argval, GraphQLEnumValue):
             # This is an enum.  It needs the namespace alongside the name.
             if argval.enum_type is None:

strawberry/codegen/plugins/typescript.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import textwrap
-from typing import TYPE_CHECKING, ClassVar
+from typing import TYPE_CHECKING
 
 from strawberry.codegen import CodegenFile, QueryCodegenPlugin
 from strawberry.codegen.types import (
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 
 
 class TypeScriptPlugin(QueryCodegenPlugin):
-    SCALARS_TO_TS_TYPE: ClassVar[dict[str | type, str]] = {
+    SCALARS_TO_TS_TYPE = {
         "ID": "string",
         "Int": "number",
         "String": "string",
@@ -102,7 +102,6 @@ class TypeScriptPlugin(QueryCodegenPlugin):
         if type_.name in self.SCALARS_TO_TS_TYPE:
             return ""
 
-        assert type_.python_type is not None
         return f"type {type_.name} = {self.SCALARS_TO_TS_TYPE[type_.python_type]}"
 
     def _print_union_type(self, type_: GraphQLUnion) -> str:

strawberry/codegen/query_codegen.py

@@ -202,7 +202,7 @@ def _get_deps(t: GraphQLType) -> Iterable[GraphQLType]:
             yield from _get_deps(gql_type)
     else:
         # Want to make sure that all types are covered.
-        raise ValueError(f"Unknown GraphQLType: {t}")  # noqa: TRY004
+        raise ValueError(f"Unknown GraphQLType: {t}")
 
 
 _TYPE_TO_GRAPHQL_TYPE = {
@@ -249,15 +249,14 @@ class QueryCodegenPluginManager:
         def type_cmp(t1: GraphQLType, t2: GraphQLType) -> int:
             """Compare the types."""
             if t1 is t2:
-                retval = 0
-            elif t1 in _get_deps(t2):
-                retval = -1
+                return 0
+
+            if t1 in _get_deps(t2):
+                return -1
             elif t2 in _get_deps(t1):
-                retval = 1
+                return 1
             else:
-                retval = 0
-
-            return retval
+                return 0
 
         return sorted(types, key=cmp_to_key(type_cmp))
 
@@ -312,15 +311,15 @@ class QueryCodegen:
         operations = self._get_operations(ast)
 
         if not operations:
-            raise NoOperationProvidedError
+            raise NoOperationProvidedError()
 
         if len(operations) > 1:
-            raise MultipleOperationsProvidedError
+            raise MultipleOperationsProvidedError()
 
         operation = operations[0]
 
         if operation.name is None:
-            raise NoOperationNameProvidedError
+            raise NoOperationNameProvidedError()
 
         # Look for any free-floating fragments and create types out of them
         # These types can then be referenced and included later via the
@@ -551,7 +550,7 @@ class QueryCodegen:
         if isinstance(field_type, ScalarDefinition):
             return self._collect_scalar(field_type, None)
 
-        if isinstance(field_type, EnumDefinition):
+        elif isinstance(field_type, EnumDefinition):
             return self._collect_enum(field_type)
 
         raise ValueError(f"Unsupported type: {field_type}")  # pragma: no cover

strawberry/codemods/annotated_unions.py

@@ -50,7 +50,7 @@ class ConvertUnionToAnnotatedUnion(VisitorBasedCodemodCommand):
 
         super().__init__(context)
 
-    def visit_Module(self, node: cst.Module) -> Optional[bool]:  # noqa: N802
+    def visit_Module(self, node: cst.Module) -> Optional[bool]:
         self._is_using_named_import = False
 
         return super().visit_Module(node)

strawberry/codemods/update_imports.py

@@ -126,9 +126,11 @@ class UpdateImportsCodemod(VisitorBasedCodemodCommand):
 
         return updated_node
 
-    def leave_ImportFrom(  # noqa: N802
+    def leave_ImportFrom(
         self, node: cst.ImportFrom, updated_node: cst.ImportFrom
     ) -> cst.ImportFrom:
         updated_node = self._update_imports(updated_node, updated_node)
         updated_node = self._update_types_types_imports(updated_node, updated_node)
-        return self._update_strawberry_type_imports(updated_node, updated_node)
+        updated_node = self._update_strawberry_type_imports(updated_node, updated_node)
+
+        return updated_node

strawberry/dataloader.py

@@ -240,7 +240,7 @@ async def dispatch_batch(loader: DataLoader, batch: Batch) -> None:
         values = list(values)
 
         if len(values) != len(batch):
-            raise WrongNumberOfResultsReturned(  # noqa: TRY301
+            raise WrongNumberOfResultsReturned(
                 expected=len(batch), received=len(values)
             )
 
@@ -254,7 +254,7 @@ async def dispatch_batch(loader: DataLoader, batch: Batch) -> None:
                 task.future.set_exception(value)
             else:
                 task.future.set_result(value)
-    except Exception as e:  # noqa: BLE001
+    except Exception as e:
         for task in batch.tasks:
             task.future.set_exception(e)
 

strawberry/django/__init__.py

@@ -12,9 +12,9 @@ except ModuleNotFoundError:
         import_symbol = f"{__name__}.{name}"
         try:
             return importlib.import_module(import_symbol)
-        except ModuleNotFoundError as e:
+        except ModuleNotFoundError:
             raise AttributeError(
                 f"Attempted import of {import_symbol} failed. Make sure to install the"
                 "'strawberry-graphql-django' package to use the Strawberry Django "
                 "extension API."
-            ) from e
+            )

strawberry/django/views.py

@@ -45,7 +45,8 @@ if TYPE_CHECKING:
 
     from strawberry.http import GraphQLHTTPResponse
     from strawberry.http.ides import GraphQL_IDE
-    from strawberry.schema import BaseSchema
+
+    from ..schema import BaseSchema
 
 
 # TODO: remove this and unify temporal responses
@@ -265,7 +266,7 @@ class AsyncGraphQLView(
     request_adapter_class = AsyncDjangoHTTPRequestAdapter
 
     @classonlymethod  # pyright: ignore[reportIncompatibleMethodOverride]
-    def as_view(cls, **initkwargs: Any) -> Callable[..., HttpResponse]:  # noqa: N805
+    def as_view(cls, **initkwargs: Any) -> Callable[..., HttpResponse]:
         # This code tells django that this view is async, see docs here:
         # https://docs.djangoproject.com/en/3.1/topics/async/#async-views
 

strawberry/exceptions/__init__.py

@@ -50,7 +50,7 @@ class UnallowedReturnTypeForUnion(Exception):
     def __init__(
         self, field_name: str, result_type: str, allowed_types: set[GraphQLObjectType]
     ) -> None:
-        formatted_allowed_types = sorted(type_.name for type_ in allowed_types)
+        formatted_allowed_types = list(sorted(type_.name for type_ in allowed_types))
 
         message = (
             f'The type "{result_type}" of the field "{field_name}" '
@@ -160,9 +160,7 @@ class StrawberryGraphQLError(GraphQLError):
 class ConnectionRejectionError(Exception):
     """Use it when you want to reject a WebSocket connection."""
 
-    def __init__(self, payload: dict[str, object] | None = None) -> None:
-        if payload is None:
-            payload = {}
+    def __init__(self, payload: dict[str, object] = {}) -> None:
         self.payload = payload
 
 

strawberry/exceptions/exception.py

@@ -67,7 +67,7 @@ class StrawberryException(Exception, ABC):
         from rich.panel import Panel
 
         if self.exception_source is None:
-            raise UnableToFindExceptionSource from self
+            raise UnableToFindExceptionSource() from self
 
         content = (
             self.__rich_header__,

strawberry/exceptions/permission_fail_silently_requires_optional.py

@@ -7,8 +7,7 @@ from .exception import StrawberryException
 from .utils.source_finder import SourceFinder
 
 if TYPE_CHECKING:
-    from strawberry.field import StrawberryField
-
+    from ..field import StrawberryField
     from .exception_source import ExceptionSource
 
 

strawberry/exceptions/utils/source_finder.py

@@ -8,7 +8,7 @@ from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Optional, cast
 
-from strawberry.exceptions.exception_source import ExceptionSource
+from ..exception_source import ExceptionSource
 
 if TYPE_CHECKING:
     from collections.abc import Sequence

strawberry/experimental/pydantic/_compat.py

@@ -119,7 +119,7 @@ def get_fields_map_for_v2() -> dict[Any, Any]:
 
 class PydanticV2Compat:
     @property
-    def PYDANTIC_MISSING_TYPE(self) -> Any:  # noqa: N802
+    def PYDANTIC_MISSING_TYPE(self) -> Any:
         from pydantic_core import PydanticUndefined
 
         return PydanticUndefined
@@ -155,7 +155,7 @@ class PydanticV2Compat:
             type_ = self.fields_map[type_]
 
             if type_ is None:
-                raise UnsupportedTypeError
+                raise UnsupportedTypeError()
 
         if is_new_type(type_):
             return new_type_supertype(type_)
@@ -168,7 +168,7 @@ class PydanticV2Compat:
 
 class PydanticV1Compat:
     @property
-    def PYDANTIC_MISSING_TYPE(self) -> Any:  # noqa: N802
+    def PYDANTIC_MISSING_TYPE(self) -> Any:
         return dataclasses.MISSING
 
     def get_model_fields(self, model: type[BaseModel]) -> dict[str, CompatModelField]:
@@ -231,7 +231,7 @@ class PydanticV1Compat:
             type_ = self.fields_map[type_]
 
             if type_ is None:
-                raise UnsupportedTypeError
+                raise UnsupportedTypeError()
 
         if is_new_type(type_):
             return new_type_supertype(type_)

strawberry/experimental/pydantic/conversion.py

@@ -101,17 +101,17 @@ def convert_pydantic_model_to_strawberry_class(
 def convert_strawberry_class_to_pydantic_model(obj: type) -> Any:
     if hasattr(obj, "to_pydantic"):
         return obj.to_pydantic()
-    if dataclasses.is_dataclass(obj):
+    elif dataclasses.is_dataclass(obj):
         result = []
         for f in dataclasses.fields(obj):
             value = convert_strawberry_class_to_pydantic_model(getattr(obj, f.name))
             result.append((f.name, value))
         return dict(result)
-    if isinstance(obj, (list, tuple)):
+    elif isinstance(obj, (list, tuple)):
         # Assume we can create an object of this type by passing in a
         # generator (which is not true for namedtuples, not supported).
         return type(obj)(convert_strawberry_class_to_pydantic_model(v) for v in obj)
-    if isinstance(obj, dict):
+    elif isinstance(obj, dict):
         return type(obj)(
             (
                 convert_strawberry_class_to_pydantic_model(k),
@@ -119,4 +119,5 @@ def convert_strawberry_class_to_pydantic_model(obj: type) -> Any:
             )
             for k, v in obj.items()
         )
-    return copy.deepcopy(obj)
+    else:
+        return copy.deepcopy(obj)

strawberry/experimental/pydantic/fields.py

@@ -32,7 +32,8 @@ def replace_pydantic_types(type_: Any, is_input: bool) -> Any:
         attr = "_strawberry_input_type" if is_input else "_strawberry_type"
         if hasattr(type_, attr):
             return getattr(type_, attr)
-        raise UnregisteredTypeException(type_)
+        else:
+            raise UnregisteredTypeException(type_)
     return type_
 
 

strawberry/experimental/pydantic/object_type.py

@@ -29,7 +29,6 @@ from strawberry.experimental.pydantic.utils import (
     get_private_fields,
 )
 from strawberry.types.auto import StrawberryAuto
-from strawberry.types.cast import get_strawberry_type_cast
 from strawberry.types.field import StrawberryField
 from strawberry.types.object_type import _process_type, _wrap_dataclass
 from strawberry.types.type_resolver import _get_fields
@@ -116,7 +115,7 @@ if TYPE_CHECKING:
     )
 
 
-def type(  # noqa: PLR0915
+def type(
     model: builtins.type[PydanticModel],
     *,
     fields: Optional[list[str]] = None,
@@ -128,7 +127,7 @@ def type(  # noqa: PLR0915
     all_fields: bool = False,
     use_pydantic_alias: bool = True,
 ) -> Callable[..., builtins.type[StrawberryTypeFromPydantic[PydanticModel]]]:
-    def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:  # noqa: PLR0915
+    def wrap(cls: Any) -> builtins.type[StrawberryTypeFromPydantic[PydanticModel]]:
         compat = PydanticCompat.from_model(model)
         model_fields = compat.get_model_fields(model)
         original_fields_set = set(fields) if fields else set()
@@ -208,9 +207,6 @@ def type(  # noqa: PLR0915
         # pydantic objects (not the corresponding strawberry type)
         @classmethod  # type: ignore
         def is_type_of(cls: builtins.type, obj: Any, _info: GraphQLResolveInfo) -> bool:
-            if (type_cast := get_strawberry_type_cast(obj)) is not None:
-                return type_cast is cls
-
             return isinstance(obj, (cls, model))
 
         namespace = {"is_type_of": is_type_of}

strawberry/experimental/pydantic/utils.py

@@ -47,7 +47,8 @@ def normalize_type(type_: type) -> Any:
 def get_strawberry_type_from_model(type_: Any) -> Any:
     if hasattr(type_, "_strawberry_type"):
         return type_._strawberry_type
-    raise UnregisteredTypeException(type_)
+    else:
+        raise UnregisteredTypeException(type_)
 
 
 def get_private_fields(cls: type) -> list[dataclasses.Field]:
@@ -96,7 +97,9 @@ def get_default_factory_for_field(
     # if we have a default_factory, we should return it
 
     if has_factory:
-        return cast("NoArgAnyCallable", default_factory)
+        default_factory = cast("NoArgAnyCallable", default_factory)
+
+        return default_factory
 
     # if we have a default, we should return it
     if has_default:
@@ -105,7 +108,8 @@ def get_default_factory_for_field(
         # printing the value.
         if isinstance(default, BaseModel):
             return lambda: compat.model_dump(default)
-        return lambda: smart_deepcopy(default)
+        else:
+            return lambda: smart_deepcopy(default)
 
     # if we don't have default or default_factory, but the field is not required,
     # we should return a factory that returns None
@@ -127,3 +131,5 @@ def ensure_all_auto_fields_in_pydantic(
         raise AutoFieldsNotInBaseModelError(
             fields=non_existing_fields, cls_name=cls_name, model=model
         )
+    else:
+        return