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

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

@@ -17,7 +17,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ["3.11", "3.12"] # graphql-api requires Python 3.11+
+        python-version: ["3.11", "3.12", "3.13", "3.14", "3.15"] # graphql-api requires Python 3.11+
 
     steps:
     - name: Checkout repository
@@ -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.6.10 → graphql_api-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.6.10
+Version: 2.0.0
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT
@@ -10,12 +10,17 @@ Keywords: GraphQL,GraphQL-API,GraphQLAPI,Server
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: <3.13,>=3.11
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: graphql-core
+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.6.10 → 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.6.10 → 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.6.10 → 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.6.10 → graphql_api-2.0.0}/graphql_api/remote.py

@@ -157,6 +157,14 @@ class GraphQLRemoteExecutor(GraphQLBaseExecutor, GraphQLObjectType):
     A GraphQL executor that forwards all operations to a remote GraphQL service.
     """
 
+    def __new__(cls, url, name="Remote", *args, **kwargs):
+        # graphql-core >= 3.2.7 gives GraphQLNamedType a __new__(cls, name, ...)
+        # that checks for reserved type names. Our first argument is the URL, so
+        # pass the type name explicitly (older versions have no such __new__).
+        if GraphQLNamedType.__new__ is object.__new__:
+            return super().__new__(cls)
+        return super().__new__(cls, name)
+
     def __init__(
         self,
         url,
@@ -594,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.6.10 → 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.6.10 → graphql_api-2.0.0}/graphql_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.6.10
+Version: 2.0.0
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT
@@ -10,12 +10,17 @@ Keywords: GraphQL,GraphQL-API,GraphQLAPI,Server
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: <3.13,>=3.11
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: graphql-core
+Requires-Dist: graphql-core<3.4,>=3.3.1
 Requires-Dist: requests
 Requires-Dist: typing-inspect
 Requires-Dist: aiohttp

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

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

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

@@ -4,7 +4,7 @@ dynamic = ["version"]
 description = "A framework for building Python GraphQL APIs."
 readme = "README.md"
 license = {text = "MIT"}
-requires-python = ">=3.11,<3.13"
+requires-python = ">=3.11"
 authors = [
     {name = "Robert Parker", email = "rob@parob.com"}
 ]
@@ -13,11 +13,16 @@ classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
 ]
 dependencies = [
-    "graphql-core",
+    "graphql-core>=3.3.1,<3.4",
     "requests",
     "typing-inspect",
     "aiohttp",

{graphql_api-1.6.10 → 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.6.10 → 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)