strawberry-graphql 0.220.0.dev1709543239__tar.gz → 0.221.0__tar.gz

{strawberry_graphql-0.220.0.dev1709543239 → strawberry_graphql-0.221.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.220.0.dev1709543239
+Version: 0.221.0
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.220.0.dev1709543239 → strawberry_graphql-0.221.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.220.0.dev.1709543239"
+version = "0.221.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
@@ -97,7 +97,7 @@ types-toml = "^0.10.8"
 types-typed-ast = "^1.5.8"
 types-ujson = "^5.6.0"
 types-protobuf = "^4.23.0.1"
-mypy = "1.8.0"
+mypy = "1.9.0"
 pytest-mypy-plugins = ">=1.10,<4.0"
 poetry-plugin-export = "^1.6.0"
 # another bug in poetry

{strawberry_graphql-0.220.0.dev1709543239 → strawberry_graphql-0.221.0}/strawberry/__init__.py

@@ -14,6 +14,7 @@ from .private import Private
 from .scalars import ID
 from .schema import Schema
 from .schema_directive import schema_directive
+from .types.info import Info
 from .union import union
 from .unset import UNSET
 
@@ -21,6 +22,7 @@ __all__ = [
     "BasePermission",
     "experimental",
     "ID",
+    "Info",
     "UNSET",
     "lazy",
     "LazyType",

{strawberry_graphql-0.220.0.dev1709543239 → strawberry_graphql-0.221.0}/strawberry/channels/testing.py

@@ -69,6 +69,7 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         path: str,
         headers: Optional[List[Tuple[bytes, bytes]]] = None,
         protocol: str = GRAPHQL_TRANSPORT_WS_PROTOCOL,
+        connection_params: dict = {},
         **kwargs: Any,
     ):
         """
@@ -81,6 +82,7 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         self.protocol = protocol
         subprotocols = kwargs.get("subprotocols", [])
         subprotocols.append(protocol)
+        self.connection_params = connection_params
         super().__init__(application, path, headers, subprotocols=subprotocols)
 
     async def __aenter__(self) -> Self:
@@ -99,7 +101,9 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
         res = await self.connect()
         if self.protocol == GRAPHQL_TRANSPORT_WS_PROTOCOL:
             assert res == (True, GRAPHQL_TRANSPORT_WS_PROTOCOL)
-            await self.send_json_to(ConnectionInitMessage().as_dict())
+            await self.send_json_to(
+                ConnectionInitMessage(payload=self.connection_params).as_dict()
+            )
             response = await self.receive_json_from()
             assert response == ConnectionAckMessage().as_dict()
         else:

{strawberry_graphql-0.220.0.dev1709543239 → strawberry_graphql-0.221.0}/strawberry/field_extensions/input_mutation.py

@@ -65,7 +65,7 @@ class InputMutationExtension(FieldExtension):
         self,
         next_: SyncExtensionResolver,
         source: Any,
-        info: Info[Any, Any],
+        info: Info,
         **kwargs: Any,
     ) -> Any:
         input_args = kwargs.pop("input")

strawberry_graphql-0.221.0/strawberry/schema/execute.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+from asyncio import ensure_future
+from inspect import isawaitable
+from typing import (
+    TYPE_CHECKING,
+    Awaitable,
+    Callable,
+    Iterable,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Type,
+    TypedDict,
+    Union,
+    cast,
+)
+
+from graphql import GraphQLError, parse
+from graphql import execute as original_execute
+from graphql.validation import validate
+
+from strawberry.exceptions import MissingQueryError
+from strawberry.extensions.runner import SchemaExtensionsRunner
+from strawberry.types import ExecutionResult
+
+from .exceptions import InvalidOperationTypeError
+
+if TYPE_CHECKING:
+    from typing_extensions import NotRequired, Unpack
+
+    from graphql import ExecutionContext as GraphQLExecutionContext
+    from graphql import ExecutionResult as GraphQLExecutionResult
+    from graphql import GraphQLSchema
+    from graphql.language import DocumentNode
+    from graphql.validation import ASTValidationRule
+
+    from strawberry.extensions import SchemaExtension
+    from strawberry.types import ExecutionContext
+    from strawberry.types.graphql import OperationType
+
+
+# duplicated because of https://github.com/mkdocstrings/griffe-typingdoc/issues/7
+class ParseOptions(TypedDict):
+    max_tokens: NotRequired[int]
+
+
+def parse_document(query: str, **kwargs: Unpack[ParseOptions]) -> DocumentNode:
+    return parse(query, **kwargs)
+
+
+def validate_document(
+    schema: GraphQLSchema,
+    document: DocumentNode,
+    validation_rules: Tuple[Type[ASTValidationRule], ...],
+) -> List[GraphQLError]:
+    return validate(
+        schema,
+        document,
+        validation_rules,
+    )
+
+
+def _run_validation(execution_context: ExecutionContext) -> None:
+    # Check if there are any validation rules or if validation has
+    # already been run by an extension
+    if len(execution_context.validation_rules) > 0 and execution_context.errors is None:
+        assert execution_context.graphql_document
+        execution_context.errors = validate_document(
+            execution_context.schema._schema,
+            execution_context.graphql_document,
+            execution_context.validation_rules,
+        )
+
+
+async def execute(
+    schema: GraphQLSchema,
+    *,
+    allowed_operation_types: Iterable[OperationType],
+    extensions: Sequence[Union[Type[SchemaExtension], SchemaExtension]],
+    execution_context: ExecutionContext,
+    execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
+    process_errors: Callable[[List[GraphQLError], Optional[ExecutionContext]], None],
+) -> ExecutionResult:
+    extensions_runner = SchemaExtensionsRunner(
+        execution_context=execution_context,
+        extensions=list(extensions),
+    )
+
+    async with extensions_runner.operation():
+        # 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()
+
+        async with extensions_runner.parsing():
+            try:
+                if not execution_context.graphql_document:
+                    execution_context.graphql_document = parse_document(
+                        execution_context.query, **execution_context.parse_options
+                    )
+
+            except GraphQLError as error:
+                execution_context.errors = [error]
+                process_errors([error], execution_context)
+                return ExecutionResult(
+                    data=None,
+                    errors=[error],
+                    extensions=await extensions_runner.get_extensions_results(),
+                )
+
+            except Exception as error:  # pragma: no cover
+                error = GraphQLError(str(error), original_error=error)
+
+                execution_context.errors = [error]
+                process_errors([error], execution_context)
+
+                return ExecutionResult(
+                    data=None,
+                    errors=[error],
+                    extensions=await extensions_runner.get_extensions_results(),
+                )
+
+        if execution_context.operation_type not in allowed_operation_types:
+            raise InvalidOperationTypeError(execution_context.operation_type)
+
+        async with extensions_runner.validation():
+            _run_validation(execution_context)
+            if execution_context.errors:
+                process_errors(execution_context.errors, execution_context)
+                return ExecutionResult(data=None, errors=execution_context.errors)
+
+        async with extensions_runner.executing():
+            if not execution_context.result:
+                result = original_execute(
+                    schema,
+                    execution_context.graphql_document,
+                    root_value=execution_context.root_value,
+                    middleware=extensions_runner.as_middleware_manager(),
+                    variable_values=execution_context.variables,
+                    operation_name=execution_context.operation_name,
+                    context_value=execution_context.context,
+                    execution_context_class=execution_context_class,
+                )
+
+                if isawaitable(result):
+                    result = await cast(Awaitable["GraphQLExecutionResult"], result)
+
+                result = cast("GraphQLExecutionResult", result)
+                execution_context.result = result
+                # Also set errors on the execution_context so that it's easier
+                # to access in extensions
+                if result.errors:
+                    execution_context.errors = result.errors
+
+                    # Run the `Schema.process_errors` function here before
+                    # extensions have a chance to modify them (see the MaskErrors
+                    # extension). That way we can log the original errors but
+                    # only return a sanitised version to the client.
+                    process_errors(result.errors, execution_context)
+
+    return ExecutionResult(
+        data=execution_context.result.data,
+        errors=execution_context.result.errors,
+        extensions=await extensions_runner.get_extensions_results(),
+    )
+
+
+def execute_sync(
+    schema: GraphQLSchema,
+    *,
+    allowed_operation_types: Iterable[OperationType],
+    extensions: Sequence[Union[Type[SchemaExtension], SchemaExtension]],
+    execution_context: ExecutionContext,
+    execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
+    process_errors: Callable[[List[GraphQLError], Optional[ExecutionContext]], None],
+) -> ExecutionResult:
+    extensions_runner = SchemaExtensionsRunner(
+        execution_context=execution_context,
+        extensions=list(extensions),
+    )
+
+    with extensions_runner.operation():
+        # 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()
+
+        with extensions_runner.parsing():
+            try:
+                if not execution_context.graphql_document:
+                    execution_context.graphql_document = parse_document(
+                        execution_context.query, **execution_context.parse_options
+                    )
+
+            except GraphQLError as error:
+                execution_context.errors = [error]
+                process_errors([error], execution_context)
+                return ExecutionResult(
+                    data=None,
+                    errors=[error],
+                    extensions=extensions_runner.get_extensions_results_sync(),
+                )
+
+            except Exception as error:  # pragma: no cover
+                error = GraphQLError(str(error), original_error=error)
+
+                execution_context.errors = [error]
+                process_errors([error], execution_context)
+                return ExecutionResult(
+                    data=None,
+                    errors=[error],
+                    extensions=extensions_runner.get_extensions_results_sync(),
+                )
+
+        if execution_context.operation_type not in allowed_operation_types:
+            raise InvalidOperationTypeError(execution_context.operation_type)
+
+        with extensions_runner.validation():
+            _run_validation(execution_context)
+            if execution_context.errors:
+                process_errors(execution_context.errors, execution_context)
+                return ExecutionResult(data=None, errors=execution_context.errors)
+
+        with extensions_runner.executing():
+            if not execution_context.result:
+                result = original_execute(
+                    schema,
+                    execution_context.graphql_document,
+                    root_value=execution_context.root_value,
+                    middleware=extensions_runner.as_middleware_manager(),
+                    variable_values=execution_context.variables,
+                    operation_name=execution_context.operation_name,
+                    context_value=execution_context.context,
+                    execution_context_class=execution_context_class,
+                )
+
+                if isawaitable(result):
+                    result = cast(Awaitable["GraphQLExecutionResult"], result)
+                    ensure_future(result).cancel()
+                    raise RuntimeError(
+                        "GraphQL execution failed to complete synchronously."
+                    )
+
+                result = cast("GraphQLExecutionResult", result)
+                execution_context.result = result
+                # Also set errors on the execution_context so that it's easier
+                # to access in extensions
+                if result.errors:
+                    execution_context.errors = result.errors
+
+                    # Run the `Schema.process_errors` function here before
+                    # extensions have a chance to modify them (see the MaskErrors
+                    # extension). That way we can log the original errors but
+                    # only return a sanitised version to the client.
+                    process_errors(result.errors, execution_context)
+
+    return ExecutionResult(
+        data=execution_context.result.data,
+        errors=execution_context.result.errors,
+        extensions=extensions_runner.get_extensions_results_sync(),
+    )

{strawberry_graphql-0.220.0.dev1709543239 → strawberry_graphql-0.221.0}/strawberry/types/fields/resolver.py

@@ -155,7 +155,7 @@ class ReservedType(NamedTuple):
             # 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[Any, Any])
+            # Handle both concrete and generic types (i.e Info, and Info)
             return (
                 issubclass(origin, self.type)
                 if isinstance(origin, type)

{strawberry_graphql-0.220.0.dev1709543239 → strawberry_graphql-0.221.0}/strawberry/types/info.py

@@ -11,9 +11,9 @@ from typing import (
     List,
     Optional,
     Type,
-    TypeVar,
     Union,
 )
+from typing_extensions import TypeVar
 
 from .nodes import convert_selections
 
@@ -29,8 +29,8 @@ if TYPE_CHECKING:
 
     from .nodes import Selection
 
-ContextType = TypeVar("ContextType")
-RootValueType = TypeVar("RootValueType")
+ContextType = TypeVar("ContextType", default=Any)
+RootValueType = TypeVar("RootValueType", default=Any)
 
 
 @dataclasses.dataclass

strawberry_graphql-0.220.0.dev1709543239/strawberry/schema/execute.py

@@ -1,274 +0,0 @@
-from __future__ import annotations
-
-from asyncio import ensure_future
-from inspect import isawaitable
-from typing import (
-    TYPE_CHECKING,
-    Awaitable,
-    Callable,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypedDict,
-    Union,
-    cast,
-)
-
-from graphql import GraphQLError, parse
-from graphql import execute as original_execute
-from graphql.validation import validate
-
-from strawberry.exceptions import MissingQueryError
-from strawberry.extensions.runner import SchemaExtensionsRunner
-from strawberry.types import ExecutionResult
-
-from .exceptions import InvalidOperationTypeError
-
-if TYPE_CHECKING:
-    from typing_extensions import NotRequired, Unpack
-
-    from graphql import ExecutionContext as GraphQLExecutionContext
-    from graphql import ExecutionResult as GraphQLExecutionResult
-    from graphql import GraphQLSchema
-    from graphql.language import DocumentNode
-    from graphql.validation import ASTValidationRule
-
-    from strawberry.extensions import SchemaExtension
-    from strawberry.types import ExecutionContext
-    from strawberry.types.graphql import OperationType
-
-
-# duplicated because of https://github.com/mkdocstrings/griffe-typingdoc/issues/7
-class ParseOptions(TypedDict):
-    max_tokens: NotRequired[int]
-
-
-def parse_document(query: str, **kwargs: Unpack[ParseOptions]) -> DocumentNode:
-    return parse(query, **kwargs)
-
-
-def validate_document(
-    schema: GraphQLSchema,
-    document: DocumentNode,
-    validation_rules: Tuple[Type[ASTValidationRule], ...],
-) -> List[GraphQLError]:
-    return validate(
-        schema,
-        document,
-        validation_rules,
-    )
-
-
-def _run_validation(execution_context: ExecutionContext) -> None:
-    # Check if there are any validation rules or if validation has
-    # already been run by an extension
-    if len(execution_context.validation_rules) > 0 and execution_context.errors is None:
-        assert execution_context.graphql_document
-        execution_context.errors = validate_document(
-            execution_context.schema._schema,
-            execution_context.graphql_document,
-            execution_context.validation_rules,
-        )
-
-
-async def execute(
-    schema: GraphQLSchema,
-    *,
-    allowed_operation_types: Iterable[OperationType],
-    extensions: Sequence[Union[Type[SchemaExtension], SchemaExtension]],
-    execution_context: ExecutionContext,
-    execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
-    process_errors: Callable[[List[GraphQLError], Optional[ExecutionContext]], None],
-) -> ExecutionResult:
-    extensions_runner = SchemaExtensionsRunner(
-        execution_context=execution_context,
-        extensions=list(extensions),
-    )
-
-    try:
-        async with extensions_runner.operation():
-            # 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()
-
-            async with extensions_runner.parsing():
-                try:
-                    if not execution_context.graphql_document:
-                        execution_context.graphql_document = parse_document(
-                            execution_context.query, **execution_context.parse_options
-                        )
-
-                except GraphQLError as exc:
-                    execution_context.errors = [exc]
-                    process_errors([exc], execution_context)
-                    return ExecutionResult(
-                        data=None,
-                        errors=[exc],
-                        extensions=await extensions_runner.get_extensions_results(),
-                    )
-
-            if execution_context.operation_type not in allowed_operation_types:
-                raise InvalidOperationTypeError(execution_context.operation_type)
-
-            async with extensions_runner.validation():
-                _run_validation(execution_context)
-                if execution_context.errors:
-                    process_errors(execution_context.errors, execution_context)
-                    return ExecutionResult(data=None, errors=execution_context.errors)
-
-            async with extensions_runner.executing():
-                if not execution_context.result:
-                    result = original_execute(
-                        schema,
-                        execution_context.graphql_document,
-                        root_value=execution_context.root_value,
-                        middleware=extensions_runner.as_middleware_manager(),
-                        variable_values=execution_context.variables,
-                        operation_name=execution_context.operation_name,
-                        context_value=execution_context.context,
-                        execution_context_class=execution_context_class,
-                    )
-
-                    if isawaitable(result):
-                        result = await cast(Awaitable["GraphQLExecutionResult"], result)
-
-                    result = cast("GraphQLExecutionResult", result)
-                    execution_context.result = result
-                    # Also set errors on the execution_context so that it's easier
-                    # to access in extensions
-                    if result.errors:
-                        execution_context.errors = result.errors
-
-                        # Run the `Schema.process_errors` function here before
-                        # extensions have a chance to modify them (see the MaskErrors
-                        # 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:
-        error = (
-            exc
-            if isinstance(exc, GraphQLError)
-            else GraphQLError(str(exc), original_error=exc)
-        )
-        execution_context.errors = [error]
-        process_errors([error], execution_context)
-        return ExecutionResult(
-            data=None,
-            errors=[error],
-            extensions=await extensions_runner.get_extensions_results(),
-        )
-
-    return ExecutionResult(
-        data=execution_context.result.data,
-        errors=execution_context.result.errors,
-        extensions=await extensions_runner.get_extensions_results(),
-    )
-
-
-def execute_sync(
-    schema: GraphQLSchema,
-    *,
-    allowed_operation_types: Iterable[OperationType],
-    extensions: Sequence[Union[Type[SchemaExtension], SchemaExtension]],
-    execution_context: ExecutionContext,
-    execution_context_class: Optional[Type[GraphQLExecutionContext]] = None,
-    process_errors: Callable[[List[GraphQLError], Optional[ExecutionContext]], None],
-) -> ExecutionResult:
-    extensions_runner = SchemaExtensionsRunner(
-        execution_context=execution_context,
-        extensions=list(extensions),
-    )
-
-    try:
-        with extensions_runner.operation():
-            # 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()
-
-            with extensions_runner.parsing():
-                try:
-                    if not execution_context.graphql_document:
-                        execution_context.graphql_document = parse_document(
-                            execution_context.query, **execution_context.parse_options
-                        )
-
-                except GraphQLError as exc:
-                    execution_context.errors = [exc]
-                    process_errors([exc], execution_context)
-                    return ExecutionResult(
-                        data=None,
-                        errors=[exc],
-                        extensions=extensions_runner.get_extensions_results_sync(),
-                    )
-
-            if execution_context.operation_type not in allowed_operation_types:
-                raise InvalidOperationTypeError(execution_context.operation_type)
-
-            with extensions_runner.validation():
-                _run_validation(execution_context)
-                if execution_context.errors:
-                    process_errors(execution_context.errors, execution_context)
-                    return ExecutionResult(data=None, errors=execution_context.errors)
-
-            with extensions_runner.executing():
-                if not execution_context.result:
-                    result = original_execute(
-                        schema,
-                        execution_context.graphql_document,
-                        root_value=execution_context.root_value,
-                        middleware=extensions_runner.as_middleware_manager(),
-                        variable_values=execution_context.variables,
-                        operation_name=execution_context.operation_name,
-                        context_value=execution_context.context,
-                        execution_context_class=execution_context_class,
-                    )
-
-                    if isawaitable(result):
-                        result = cast(Awaitable["GraphQLExecutionResult"], result)
-                        ensure_future(result).cancel()
-                        raise RuntimeError(
-                            "GraphQL execution failed to complete synchronously."
-                        )
-
-                    result = cast("GraphQLExecutionResult", result)
-                    execution_context.result = result
-                    # Also set errors on the execution_context so that it's easier
-                    # to access in extensions
-                    if result.errors:
-                        execution_context.errors = result.errors
-
-                        # Run the `Schema.process_errors` function here before
-                        # extensions have a chance to modify them (see the MaskErrors
-                        # 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:
-        error = (
-            exc
-            if isinstance(exc, GraphQLError)
-            else GraphQLError(str(exc), original_error=exc)
-        )
-        execution_context.errors = [error]
-        process_errors([error], execution_context)
-        return ExecutionResult(
-            data=None,
-            errors=[error],
-            extensions=extensions_runner.get_extensions_results_sync(),
-        )
-
-    return ExecutionResult(
-        data=execution_context.result.data,
-        errors=execution_context.result.errors,
-        extensions=extensions_runner.get_extensions_results_sync(),
-    )