graphql-api 1.7.0__tar.gz → 2.0.0__tar.gz

{graphql_api-1.7.0 → graphql_api-2.0.0}/.github/workflows/python-package.yml

@@ -30,6 +30,8 @@ jobs:
 
     - name: Install UV
       uses: astral-sh/setup-uv@v3
+      with:
+        enable-cache: true
 
     - name: Install dependencies
       run: uv sync --dev

{graphql_api-1.7.0 → graphql_api-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.7.0
+Version: 2.0.0
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: graphql-core<3.3
+Requires-Dist: graphql-core<3.4,>=3.3.1
 Requires-Dist: requests
 Requires-Dist: typing-inspect
 Requires-Dist: aiohttp

graphql_api-2.0.0/VERSION

@@ -0,0 +1 @@
+2.0.0

{graphql_api-1.7.0 → graphql_api-2.0.0}/docs/content/docs/fundamentals/field-types.md

@@ -180,22 +180,23 @@ You can define custom GraphQL scalar types for specialized data handling:
 from graphql import GraphQLScalarType, StringValueNode
 
 # Define a custom scalar
-def parse_value(value):
+def coerce_input_value(value):
     return str(value) + "_parsed"
 
-def parse_literal(node):
+def coerce_input_literal(node):
     if isinstance(node, StringValueNode):
-        return parse_value(node.value)
+        return coerce_input_value(node.value)
+    raise TypeError("A Key literal must be a string")
 
-def serialize(value):
+def coerce_output_value(value):
     return str(value) + "_serialized"
 
 GraphQLKey = GraphQLScalarType(
     name="Key",
     description="The `Key` scalar type represents a unique key.",
-    serialize=serialize,
-    parse_value=parse_value,
-    parse_literal=parse_literal,
+    coerce_output_value=coerce_output_value,
+    coerce_input_value=coerce_input_value,
+    coerce_input_literal=coerce_input_literal,
 )
 
 @api.type(is_root_type=True)
@@ -206,9 +207,11 @@ class Root:
 ```
 
 **Key functions:**
-- `serialize`: Converts Python value to GraphQL response format
-- `parse_value`: Parses variable values from GraphQL requests
-- `parse_literal`: Parses literal values from GraphQL queries
+- `coerce_output_value`: Converts a Python value to the GraphQL response format
+- `coerce_input_value`: Parses variable values from GraphQL requests
+- `coerce_input_literal`: Parses literal values written in GraphQL queries
+
+These are the graphql-core 3.3 names. The older `serialize`, `parse_value` and `parse_literal` still work until graphql-core 3.4, but `parse_literal` is now always called with two arguments, `(node, variables)`.
 
 ## GraphQL ID Type
 

{graphql_api-1.7.0 → graphql_api-2.0.0}/graphql_api/executor.py

@@ -3,7 +3,6 @@ from inspect import isawaitable
 from typing import Any, Dict, Optional, List, Callable, AsyncIterator, Tuple
 
 from graphql import (
-    ExecutionContext,
     GraphQLError,
     GraphQLOutputType,
     execute,
@@ -14,7 +13,9 @@ from graphql import (
     validate_schema,
 )
 from graphql.execution import ExecutionResult
+from graphql.execution.executor import Executor
 from graphql.execution.middleware import MiddlewareManager
+from graphql.pyutils import Path
 from graphql.language import DocumentNode
 from graphql.type.schema import GraphQLSchema
 
@@ -54,10 +55,10 @@ class GraphQLBaseExecutor:
         raise NotImplementedError
 
 
-class ErrorProtectionExecutionContext(ExecutionContext):
+class ErrorProtectionExecutionContext(Executor):
     """
-    A custom GraphQL ExecutionContext that can selectively suppress or raise errors
-    based on an 'error_protection' attribute in the GraphQLError or its original error.
+    A custom graphql-core Executor that can selectively suppress or raise errors
+    based on an 'error_protection' attribute in the error or its original error.
     """
 
     # Default to True, meaning errors are protected by default (not raised directly).
@@ -66,40 +67,38 @@ class ErrorProtectionExecutionContext(ExecutionContext):
 
     def handle_field_error(
         self,
-        error: GraphQLError,
+        raw_error: Exception,
         return_type: GraphQLOutputType,
-        *args: Any,
-        **kwargs: Any,
+        field_details_list: Any,
+        path: Path,
     ) -> None:
         """
         Intercept field errors to decide whether to raise or suppress them based on the
         'error_protection' attribute, either on the error or its original error.
 
-        Anything after ``return_type`` is forwarded to graphql-core untouched.
-        graphql-core added a ``path`` argument to this method in 3.2.8, and an
-        override with a fixed arity turns every field error into a TypeError
-        raised from inside the executor — so the resolver's real error never
-        reaches the caller and a validation failure reads as a crash. Since
-        this class exists precisely to sit in the error path, it must not be
-        the thing that breaks it: accepting whatever the installed version
-        passes keeps it working across both signatures.
+        graphql-core passes the error as raised. That is usually the resolver's own
+        exception, but it can be a GraphQLError that wraps one (e.g. from a nested
+        executor), so the flag is looked up on both.
         """
         error_protection = self.default_error_protection
-        original_error = error.original_error
+        original_error = (
+            raw_error.original_error if isinstance(raw_error, GraphQLError) else None
+        )
 
         # Check if this error or its original error has a custom error_protection flag
-        if hasattr(error, self.error_protection):
-            error_protection = getattr(error, self.error_protection)
+        if hasattr(raw_error, self.error_protection):
+            error_protection = getattr(raw_error, self.error_protection)
         elif hasattr(original_error, self.error_protection):
             error_protection = getattr(original_error, self.error_protection)
 
         # If error protection is disabled, re-raise the original error
         if not error_protection:
-            raise error.original_error if error.original_error is not None else error
+            raise original_error if original_error is not None else raw_error
 
-        # Otherwise, call the default error handler. Positionally, because the
-        # trailing arguments differ by version and only the caller knows them.
-        return super().handle_field_error(error, return_type, *args, **kwargs)
+        # Otherwise, let graphql-core locate and collect the error.
+        return super().handle_field_error(
+            raw_error, return_type, field_details_list, path
+        )
 
 
 class NoErrorProtectionExecutionContext(ErrorProtectionExecutionContext):
@@ -153,8 +152,8 @@ class GraphQLExecutor(GraphQLBaseExecutor):
         # can serve every execution.
         self._middleware_manager = MiddlewareManager(*self.middleware)
 
-        # Set the custom ExecutionContext class to handle error protection
-        self.execution_context_class = (
+        # Set the custom Executor class to handle error protection
+        self.executor_class = (
             ErrorProtectionExecutionContext
             if error_protection
             else NoErrorProtectionExecutionContext
@@ -221,7 +220,7 @@ class GraphQLExecutor(GraphQLBaseExecutor):
             operation_name=operation_name,
             middleware=self._middleware_manager,
             root_value=root_value,
-            execution_context_class=self.execution_context_class,
+            executor_class=self.executor_class,
         )
         return result
 
@@ -248,7 +247,7 @@ class GraphQLExecutor(GraphQLBaseExecutor):
             operation_name=operation_name,
             middleware=self._middleware_manager,
             root_value=root_value,
-            execution_context_class=self.execution_context_class,
+            executor_class=self.executor_class,
         )
         if isawaitable(result):
             result = await result
@@ -267,13 +266,15 @@ class GraphQLExecutor(GraphQLBaseExecutor):
         # graphql-core subscribe expects a parsed document
         document = parse(query)
         # Use the same middleware and execution context where applicable
-        async_iter = await subscribe(
+        async_iter = subscribe(
             schema=self.schema,
             document=document,
             variable_values=variables,
             operation_name=operation_name,
             context_value=context,
             root_value=root_value,
-            # execution_context_class is not a parameter for subscribe in graphql-core v3
         )
+        # graphql-core >= 3.3 returns the result directly when it can.
+        if isawaitable(async_iter):
+            async_iter = await async_iter
         return async_iter  # type: ignore

{graphql_api-1.7.0 → graphql_api-2.0.0}/graphql_api/mapper.py

@@ -1,7 +1,5 @@
-import collections.abc
 import enum
 import inspect
-import types
 import typing
 from datetime import date, datetime
 from typing import Any, Annotated, Callable, List, Optional, Set, Tuple, Type, Union, cast, get_origin, get_args
@@ -21,7 +19,7 @@ from graphql import (
     is_union_type,
     GraphQLWrappingType,
 )
-from graphql.pyutils import Undefined, UndefinedType
+from graphql.pyutils import Undefined
 from graphql.type.definition import (
     GraphQLArgument,
     GraphQLEnumType,
@@ -659,27 +657,6 @@ class GraphQLTypeMapper:
 
         enum_type.enum_type = type_
 
-        def serialize(_self, value) -> Union[str, None, UndefinedType]:
-            if value and isinstance(value, collections.abc.Hashable):
-                # For enums, always return the enum name (which matches the GraphQL enum value)
-                if isinstance(value, enum.Enum):
-                    return value.name
-                else:
-                    # For non-enum values, try to look them up in the value lookup
-                    # This handles cases where the value might be a string representation
-                    lookup_key = value
-                    # noinspection PyProtectedMember
-                    lookup_value = _self._value_lookup.get(lookup_key)
-                    if lookup_value:
-                        return lookup_value
-                    else:
-                        # If lookup fails, the value might be invalid
-                        return Undefined
-
-            return None
-
-        enum_type.serialize = types.MethodType(serialize, enum_type)
-
         self.add_applied_directives(enum_type, name, type_)
 
         return enum_type
@@ -831,7 +808,7 @@ class GraphQLTypeMapper:
 
                     # Use the raw Python default for input coercion.
                     # Do not convert to GraphQL query literals here.
-                    default_value = local_default_args.get(key, None)
+                    default_value = local_default_args.get(key, Undefined)
 
                     arguments[to_camel_case(key)] = GraphQLInputField(
                         type_=input_arg_type, default_value=default_value  # type: ignore

{graphql_api-1.7.0 → graphql_api-2.0.0}/graphql_api/remote.py

@@ -602,9 +602,15 @@ class GraphQLRemoteObject:
                 ast_val = to_ast_value(val, unwrapped_field_type)
                 if isinstance(
                     unwrapped_field_type, (GraphQLScalarType, GraphQLEnumType)
-                ) and hasattr(unwrapped_field_type, "parse_literal"):
-                    parsed_val = unwrapped_field_type.parse_literal(
-                        ast_val, None)  # type: ignore
+                ):
+                    # Scalars defined with the pre-3.3 hooks have no
+                    # coerce_input_literal; they still provide parse_literal.
+                    coerce_literal = unwrapped_field_type.coerce_input_literal
+                    if coerce_literal is not None:
+                        parsed_val = coerce_literal(ast_val)  # type: ignore
+                    else:
+                        parsed_val = unwrapped_field_type.parse_literal(
+                            ast_val, None)  # type: ignore
                     # If the field is an enum, convert to the Python enum if available
                     if isinstance(unwrapped_field_type, GraphQLEnumType) and hasattr(
                         unwrapped_field_type, "enum_type"

{graphql_api-1.7.0 → graphql_api-2.0.0}/graphql_api/types.py

@@ -1,10 +1,11 @@
 import binascii
+import collections.abc
 import datetime
 import json
 import uuid
 import enum
 
-from typing import Any, Dict, List, Optional, Type, Union, cast
+from typing import Any, Dict, List, Optional, Type, Union
 
 from graphql import (
     GraphQLEnumType,
@@ -13,45 +14,54 @@ from graphql import (
     Undefined,
     ValueNode,
 )
+from graphql.pyutils import UndefinedType
 from graphql.language import ast
 
 
 class GraphQLMappedEnumType(GraphQLEnumType):
+    """A GraphQL enum backed by a Python Enum.
+
+    Inputs (inline literals and variables) are coerced to the Python Enum member,
+    and outputs accept either the member or its value.
+    """
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.enum_type: Optional[Type[enum.Enum]] = None
 
-    def parse_literal(self, *args, **kwargs):
-        result = super().parse_literal(*args, **kwargs)
-        if result is not Undefined and result is not None and getattr(self, "enum_type", None):
+    def _to_enum_member(self, result):
+        if result is not Undefined and result is not None and self.enum_type is not None:
             try:
-                enum_type: Optional[Type[enum.Enum]] = self.enum_type
-                if enum_type is None:
-                    return result
-                return cast(Type[enum.Enum], enum_type)(result)
+                return self.enum_type(result)
             except (ValueError, KeyError, TypeError):
                 # Invalid enum value or type casting error
                 return Undefined
         return result
 
-    def parse_value(self, value):
-        """Coerce incoming variable values to the mapped Python Enum instance.
+    def coerce_input_literal(self, value_node, hide_suggestions=False):
+        return self._to_enum_member(
+            super().coerce_input_literal(value_node, hide_suggestions)
+        )
+
+    def coerce_input_value(self, input_value, hide_suggestions=False):
+        return self._to_enum_member(
+            super().coerce_input_value(input_value, hide_suggestions)
+        )
+
+    def coerce_output_value(self, output_value) -> Union[str, None, UndefinedType]:
+        if output_value and isinstance(output_value, collections.abc.Hashable):
+            # For enums, always return the enum name (which matches the GraphQL enum value)
+            if isinstance(output_value, enum.Enum):
+                return output_value.name
+            # For non-enum values, try to look them up in the value lookup.
+            # This handles cases where the value might be a string representation.
+            lookup_value = self._value_lookup.get(output_value)
+            if lookup_value:
+                return lookup_value
+            # If lookup fails, the value is invalid
+            return Undefined
 
-        GraphQL variables use `parse_value`, while inline literals use
-        `parse_literal`. Ensure both paths produce the Python Enum.
-        """
-        result = super().parse_value(value)
-        if result is not Undefined and result is not None and getattr(self, "enum_type", None):
-            try:
-                enum_type: Optional[Type[enum.Enum]] = self.enum_type
-                if enum_type is None:
-                    return result
-                return cast(Type[enum.Enum], enum_type)(result)
-            except (ValueError, KeyError, TypeError):
-                # Invalid enum value or type casting error
-                return Undefined
-        return result
+        return None
 
 
 def parse_uuid_literal(
@@ -85,9 +95,9 @@ def parse_uuid_value(value: Any) -> uuid.UUID:
 GraphQLUUID = GraphQLScalarType(
     name="UUID",
     description="The `UUID` scalar type represents a unique identifer.",
-    serialize=str,
-    parse_value=parse_uuid_value,
-    parse_literal=parse_uuid_literal,
+    coerce_output_value=str,
+    coerce_input_value=parse_uuid_value,
+    coerce_input_literal=parse_uuid_literal,
 )
 
 
@@ -134,9 +144,9 @@ GraphQLDateTime = GraphQLScalarType(
     name="DateTime",
     description="The `DateTime` scalar type represents a datetime, "
     "the datetime should be in the format `2018-01-22 17:46:32`",
-    serialize=serialize_datetime,
-    parse_value=parse_datetime_value,
-    parse_literal=parse_datetime_literal,
+    coerce_output_value=serialize_datetime,
+    coerce_input_value=parse_datetime_value,
+    coerce_input_literal=parse_datetime_literal,
 )
 
 
@@ -166,9 +176,9 @@ GraphQLDate = GraphQLScalarType(
     name="Date",
     description="The `Date` scalar type represents a datetime, "
     "the datetime should be in the format `2018-01-22`",
-    serialize=serialize_date,
-    parse_value=parse_date_value,
-    parse_literal=parse_date_literal,
+    coerce_output_value=serialize_date,
+    coerce_input_value=parse_date_value,
+    coerce_input_literal=parse_date_literal,
 )
 
 
@@ -204,9 +214,9 @@ GraphQLJSON = GraphQLScalarType(
     description="The `JSON` scalar type represents JSON values as specified by"
     " [ECMA-404](http://www.ecma-international.org/"
     "publications/files/ECMA-ST/ECMA-404.pdf).",
-    serialize=serialize_json,
-    parse_value=parse_json_value,
-    parse_literal=parse_json_literal,
+    coerce_output_value=serialize_json,
+    coerce_input_value=parse_json_value,
+    coerce_input_literal=parse_json_literal,
 )
 
 
@@ -234,7 +244,7 @@ GraphQLBytes = GraphQLScalarType(
     description="The `Bytes` scalar type expects and returns a "
     "Byte array in UTF-8 string format that represents the Bytes. "
     "If the data is not UTF-encodable the errors will be ignored",
-    serialize=serialize_bytes,
-    parse_value=parse_bytes_value,
-    parse_literal=parse_bytes_literal,
+    coerce_output_value=serialize_bytes,
+    coerce_input_value=parse_bytes_value,
+    coerce_input_literal=parse_bytes_literal,
 )

{graphql_api-1.7.0 → graphql_api-2.0.0}/graphql_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.7.0
+Version: 2.0.0
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT
@@ -20,7 +20,7 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: graphql-core<3.3
+Requires-Dist: graphql-core<3.4,>=3.3.1
 Requires-Dist: requests
 Requires-Dist: typing-inspect
 Requires-Dist: aiohttp

{graphql_api-1.7.0 → graphql_api-2.0.0}/graphql_api.egg-info/requires.txt

@@ -1,4 +1,4 @@
-graphql-core<3.3
+graphql-core<3.4,>=3.3.1
 requests
 typing-inspect
 aiohttp

{graphql_api-1.7.0 → graphql_api-2.0.0}/pyproject.toml

@@ -22,7 +22,7 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "graphql-core<3.3",
+    "graphql-core>=3.3.1,<3.4",
     "requests",
     "typing-inspect",
     "aiohttp",

{graphql_api-1.7.0 → graphql_api-2.0.0}/tests/test_custom_types.py

@@ -371,19 +371,20 @@ class TestCustomTypes:
     def test_custom_scalar_type(self) -> None:
         api = GraphQLAPI()
 
-        def parse_value(value):
+        def coerce_input_value(value):
             return str(value) + "_parsed_value"
 
-        def parse_literal(node):
+        def coerce_input_literal(node):
             if isinstance(node, StringValueNode):
-                return parse_value(node.value)
+                return coerce_input_value(node.value)
+            raise TypeError("A Key literal must be a string")
 
         GraphQLKey = GraphQLScalarType(
             name="Key",
             description="The `Key` scalar type represents a key.",
-            serialize=lambda value: str(value) + "_serialized",
-            parse_value=parse_value,
-            parse_literal=parse_literal,  # type: ignore[reportIncompatibleMethodOverride]
+            coerce_output_value=lambda value: str(value) + "_serialized",
+            coerce_input_value=coerce_input_value,
+            coerce_input_literal=coerce_input_literal,
         )
 
         @api.type(is_root_type=True)

{graphql_api-1.7.0 → graphql_api-2.0.0}/tests/test_docs_field_types.py

@@ -189,22 +189,23 @@ class TestFieldTypesExamples:
         api = GraphQLAPI()
 
         # Define a custom scalar
-        def parse_value(value):
+        def coerce_input_value(value):
             return str(value) + "_parsed"
 
-        def parse_literal(node):
+        def coerce_input_literal(node):
             if isinstance(node, StringValueNode):
-                return parse_value(node.value)
+                return coerce_input_value(node.value)
+            raise TypeError("A Key literal must be a string")
 
-        def serialize(value):
+        def coerce_output_value(value):
             return str(value) + "_serialized"
 
         GraphQLKey = GraphQLScalarType(
             name="Key",
             description="The `Key` scalar type represents a unique key.",
-            serialize=serialize,
-            parse_value=parse_value,
-            parse_literal=parse_literal,
+            coerce_output_value=coerce_output_value,
+            coerce_input_value=coerce_input_value,
+            coerce_input_literal=coerce_input_literal,
         )
 
         @api.type(is_root_type=True)

{graphql_api-1.7.0 → graphql_api-2.0.0}/tests/test_executor_signature.py

@@ -12,7 +12,8 @@ It went unnoticed because this library's own environment resolves an older
 graphql-core than its consumers do, so the existing error tests all pass here
 and fail there. Asserting against a pinned signature would repeat that mistake,
 so these tests ask the *installed* graphql-core what it expects and check the
-override against that.
+override against that. (graphql-core 3.3 renamed `ExecutionContext` to
+`Executor`; the hook kept its name and now receives the raw error.)
 """
 
 from __future__ import annotations
@@ -20,7 +21,7 @@ from __future__ import annotations
 import inspect
 
 from graphql import GraphQLError, GraphQLInt
-from graphql.execution.execute import ExecutionContext
+from graphql.execution.executor import CollectedErrors, Executor
 from graphql.pyutils import Path
 
 from graphql_api.api import GraphQLAPI
@@ -45,7 +46,7 @@ def _accepted_arity(func) -> int:
 class TestHandleFieldErrorSignature:
     def test_override_accepts_everything_graphql_core_passes(self) -> None:
         """The override must be callable however the installed version calls it."""
-        expected = _accepted_arity(ExecutionContext.handle_field_error)
+        expected = _accepted_arity(Executor.handle_field_error)
         override = inspect.signature(
             ErrorProtectionExecutionContext.handle_field_error
         )
@@ -65,27 +66,45 @@ class TestHandleFieldErrorSignature:
 
         This is the exact call that was raising TypeError in production.
         """
-        context = ErrorProtectionExecutionContext.__new__(
+        executor = ErrorProtectionExecutionContext.__new__(
             ErrorProtectionExecutionContext
         )
-        error = GraphQLError("boom", original_error=ValueError("boom"))
-        args = [error, GraphQLInt]
-        if _accepted_arity(ExecutionContext.handle_field_error) > 2:
-            # graphql-core >= 3.2.8 also passes the field's path.
-            args.append(Path(None, "field", None))
-
-        # Nullable return type, so the error is collected rather than re-raised;
-        # the point is only that the call itself is well-formed.
-        context.errors = []
+        executor.collected_errors = CollectedErrors()
+        executor.error_propagation = True
+        # raw error, return type, field details, path: as many as the
+        # installed graphql-core passes.
+        args = [ValueError("boom"), GraphQLInt, [], Path(None, "field", None)]
+        args = args[:_accepted_arity(Executor.handle_field_error)]
+
+        # Nullable return type, so the error is collected rather than re-raised.
         try:
-            context.handle_field_error(*args)
+            executor.handle_field_error(*args)
         except TypeError as exc:  # pragma: no cover - this is the regression
             raise AssertionError(
                 f"handle_field_error rejected graphql-core's own call: {exc}"
             ) from exc
-        except Exception:
-            # Any GraphQL-level outcome is fine; a TypeError is not.
-            pass
+
+        assert [e.message for e in executor.collected_errors.errors] == ["boom"]
+
+    def test_a_wrapped_error_keeps_its_protection_flag(self) -> None:
+        """A GraphQLError wrapping the resolver's error (e.g. from a nested
+        executor) still honours the flag set on the original error."""
+        executor = NoErrorProtectionExecutionContext.__new__(
+            NoErrorProtectionExecutionContext
+        )
+        executor.collected_errors = CollectedErrors()
+        executor.error_propagation = True
+        original = ValueError("boom")
+        wrapped = GraphQLError("boom", original_error=original)
+
+        try:
+            executor.handle_field_error(
+                wrapped, GraphQLInt, [], Path(None, "field", None)
+            )
+        except ValueError as exc:
+            assert exc is original
+        else:  # pragma: no cover
+            raise AssertionError("the unprotected error was swallowed")
 
     def test_the_no_protection_variant_inherits_the_same_shape(self) -> None:
         assert (

{graphql_api-1.7.0 → graphql_api-2.0.0}/tests/test_remote.py

@@ -1,6 +1,6 @@
 import asyncio
 import enum
-import random
+import itertools
 import time
 import uuid
 from dataclasses import dataclass
@@ -491,6 +491,10 @@ class TestGraphQLRemote:
 
     def test_remote_return_object_cache(self) -> None:
         api = GraphQLAPI()
+        # Every real resolver call returns a new number, so getting the same
+        # number back means the cache answered. (random.randint here made
+        # the "not cached" assertions fail whenever two draws collided.)
+        calls = itertools.count()
 
         @dataclass
         class Door:
@@ -498,7 +502,7 @@ class TestGraphQLRemote:
 
             @api.field
             def rand(self, max: int = 100) -> int:
-                return random.randint(0, max)
+                return next(calls)
 
         @api.type(is_root_type=True)
         class House:

{graphql_api-1.7.0 → graphql_api-2.0.0}/tests/test_subscriptions.py

@@ -1,4 +1,6 @@
 from asyncio import create_task, sleep, wait
+from collections.abc import AsyncIterator
+from inspect import isawaitable
 from dataclasses import dataclass
 from typing import Any, AsyncGenerator
 import enum
@@ -9,7 +11,6 @@ from graphql import (
     GraphQLInt,
     GraphQLObjectType,
     GraphQLSchema,
-    MapAsyncIterator,
     graphql,
     parse,
     subscribe,
@@ -69,8 +70,10 @@ class TestSubscriptions:
 
         query = "subscription {count}"
 
-        subscription = await subscribe(schema, parse(query))
-        assert isinstance(subscription, MapAsyncIterator)
+        subscription = subscribe(schema, parse(query))
+        if isawaitable(subscription):
+            subscription = await subscription
+        assert isinstance(subscription, AsyncIterator)
 
         assert a and b and c
 
@@ -86,7 +89,9 @@ class TestSubscriptions:
             await sleep(0.1)
             await graphql(schema, "mutation {increaseCount}")
 
-        subscription = await subscribe(schema, parse(query))  # type: ignore
+        subscription = subscribe(schema, parse(query))
+        if isawaitable(subscription):
+            subscription = await subscription
 
         async def receive_count():
             async for result in subscription:  # type: ignore

{graphql_api-1.7.0 → graphql_api-2.0.0}/uv.lock

@@ -546,7 +546,7 @@ dev = [
 requires-dist = [
     { name = "aiohttp" },
     { name = "docstring-parser" },
-    { name = "graphql-core", specifier = "<3.3" },
+    { name = "graphql-core", specifier = ">=3.3.1,<3.4" },
     { name = "pydantic" },
     { name = "requests" },
     { name = "typing-inspect" },
@@ -569,11 +569,11 @@ dev = [
 
 [[package]]
 name = "graphql-core"
-version = "3.2.13"
+version = "3.3.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4e/5e/aa0d4e701b50db0bab71b125dd19ddb0f98c638d008d6f7e3d8ce9cbc92e/graphql_core-3.2.13.tar.gz", hash = "sha256:bb81dd266d4ab7b591bd976f1b23639d97776cb9ac1a896b4a93c271e11ed618", size = 577471, upload-time = "2026-09-27T12:22:57.136Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/91/223fbace7c8648690d7fb77855e29bd248c9ed1e0833ed3002ab29bc1441/graphql_core-3.3.1.tar.gz", hash = "sha256:8d9b6f95fb66b58b260904cf9e191f422782620533ec8fa0c96ab941b6659a2a", size = 751402, upload-time = "2026-10-25T09:34:09.764Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1f/b4/b52a324b0b297ddc49b8ea31a51d39fae63132f694a267b9381d94e2e0af/graphql_core-3.2.13-py3-none-any.whl", hash = "sha256:b0eb04f2c31556b2310a77c8fb53c74e8b56570f8fea594d89c6ef7827dbb497", size = 268191, upload-time = "2026-09-27T12:22:55.661Z" },
+    { url = "https://files.pythonhosted.org/packages/57/0e/e51b006267e7fa785abf5d1f86a7d60b84f7f893e3ba4fe23df9be2000cf/graphql_core-3.3.1-py3-none-any.whl", hash = "sha256:43ebcd0d9a0662a71b1a2f6562ba863d253057ec11cbc45835b2e2683a0a3770", size = 349047, upload-time = "2026-10-25T09:34:07.725Z" },
 ]
 
 [[package]]

graphql_api-1.7.0/VERSION

@@ -1 +0,0 @@
-1.7.0