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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.219.1
+Version: 0.220.0.dev1709543239
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT
@@ -53,7 +53,7 @@ Requires-Dist: pydantic (>1.6.1) ; extra == "pydantic"
 Requires-Dist: pygments (>=2.3,<3.0) ; extra == "debug-server" or extra == "cli"
 Requires-Dist: pyinstrument (>=4.0.0) ; extra == "pyinstrument"
 Requires-Dist: python-dateutil (>=2.7.0,<3.0.0)
-Requires-Dist: python-multipart (>=0.0.5,<0.0.7) ; extra == "asgi" or extra == "debug-server" or extra == "fastapi"
+Requires-Dist: python-multipart (>=0.0.7) ; extra == "asgi" or extra == "debug-server" or extra == "fastapi"
 Requires-Dist: quart (>=0.19.3) ; extra == "quart"
 Requires-Dist: rich (>=12.0.0) ; extra == "debug" or extra == "debug-server" or extra == "cli"
 Requires-Dist: sanic (>=20.12.2) ; extra == "sanic"

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

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.219.1"
+version = "0.220.0.dev.1709543239"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"
@@ -50,7 +50,7 @@ opentelemetry-api = {version = "<2", optional = true}
 opentelemetry-sdk = {version = "<2", optional = true}
 chalice = {version = "^1.22", optional = true}
 pydantic = {version = ">1.6.1", optional = true}
-python-multipart = {version = ">=0.0.5,<0.0.7", optional = true}
+python-multipart = {version = ">=0.0.7", optional = true}
 sanic = {version = ">=20.12.2", optional = true}
 aiohttp = {version = "^3.7.4.post0", optional = true}
 fastapi = {version = ">=0.65.2", optional = true}
@@ -83,7 +83,7 @@ pytest-emoji = "^0.2.0"
 pytest-mock = "^3.10"
 pytest-snapshot = "^0.9.0"
 pytest-xdist = {extras = ["psutil"], version = "^3.1.0"}
-python-multipart = ">=0.0.5,<0.0.7"
+python-multipart = ">=0.0.7"
 rich = {version = ">=12.5.1,<14.0.0", optional = false}
 sanic-testing = ">=22.9,<24.0"
 sentry-sdk = "^1.39.2"
@@ -192,8 +192,34 @@ stubPath = ""
 
 [tool.ruff]
 line-length = 88
-select = ["ALL"]
 target-version = "py38"
+fix = true
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+    "tests/codegen/snapshots"
+]
+src = ["strawberry", "tests"]
+
+[tool.ruff.lint]
+select = ["ALL"]
 ignore = [
     # https://github.com/astral-sh/ruff/pull/4427
     # equivalent to keep-runtime-typing
@@ -326,38 +352,14 @@ ignore = [
     "FIX002",
     "FA100",
 ]
-fix = true
-exclude = [
-    ".bzr",
-    ".direnv",
-    ".eggs",
-    ".git",
-    ".hg",
-    ".mypy_cache",
-    ".nox",
-    ".pants.d",
-    ".ruff_cache",
-    ".svn",
-    ".tox",
-    ".venv",
-    "__pypackages__",
-    "_build",
-    "buck-out",
-    "build",
-    "dist",
-    "node_modules",
-    "venv",
-    "tests/codegen/snapshots"
-]
-src = ["strawberry", "tests"]
 
-[tool.ruff.per-file-ignores]
+[tool.ruff.lint.per-file-ignores]
 "strawberry/schema/types/concrete_type.py" = ["TCH002"]
 "tests/*" = ["RSE102", "SLF001", "TCH001", "TCH002", "TCH003", "ANN001", "ANN201", "PLW0603", "PLC1901", "S603", "S607", "B018"]
 "strawberry/extensions/tracing/__init__.py" = ["TCH004"]
 "tests/http/clients/__init__.py" = ["F401"]
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 known-first-party = ["strawberry"]
 known-third-party = ["django", "graphql"]
 extra-standard-library = ["typing_extensions"]

{strawberry_graphql-0.219.1 → strawberry_graphql-0.220.0.dev1709543239}/strawberry/experimental/pydantic/utils.py

@@ -6,7 +6,6 @@ from typing import (
     Any,
     List,
     NamedTuple,
-    NoReturn,
     Set,
     Tuple,
     Type,
@@ -126,7 +125,7 @@ def get_default_factory_for_field(
 
 def ensure_all_auto_fields_in_pydantic(
     model: Type[BaseModel], auto_fields: Set[str], cls_name: str
-) -> Union[NoReturn, None]:
+) -> None:
     # Raise error if user defined a strawberry.auto field not present in the model
     non_existing_fields = list(auto_fields - get_model_fields(model).keys())
 
@@ -135,4 +134,4 @@ def ensure_all_auto_fields_in_pydantic(
             fields=non_existing_fields, cls_name=cls_name, model=model
         )
     else:
-        return None
+        return

{strawberry_graphql-0.219.1 → strawberry_graphql-0.220.0.dev1709543239}/strawberry/extensions/max_aliases.py

@@ -65,7 +65,7 @@ def create_validator(max_alias_count: int) -> Type[ValidationRule]:
 
 
 def count_fields_with_alias(
-    selection_set_owner: Union[ExecutableDefinitionNode, FieldNode, InlineFragmentNode]
+    selection_set_owner: Union[ExecutableDefinitionNode, FieldNode, InlineFragmentNode],
 ) -> int:
     if selection_set_owner.selection_set is None:
         return 0

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

@@ -0,0 +1,274 @@
+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(),
+    )

{strawberry_graphql-0.219.1 → strawberry_graphql-0.220.0.dev1709543239}/strawberry/utils/aio.py

@@ -24,7 +24,7 @@ async def aenumerate(
     i = 0
     async for element in iterable:
         yield i, element
-        i += 1
+        i += 1  # noqa: SIM113
 
 
 async def aislice(

{strawberry_graphql-0.219.1 → strawberry_graphql-0.220.0.dev1709543239}/strawberry/utils/typing.py

@@ -214,7 +214,7 @@ def _ast_replace_union_operation(expr: ast.Expr) -> ast.Expr:
 
 
 def _ast_replace_union_operation(
-    expr: Union[ast.Expr, ast.expr]
+    expr: Union[ast.Expr, ast.expr],
 ) -> Union[ast.Expr, ast.expr]:
     if isinstance(expr, ast.Expr) and isinstance(
         expr.value, (ast.BinOp, ast.Subscript)