graphql-api 1.6.8__tar.gz → 1.6.9__tar.gz

{graphql_api-1.6.8 → graphql_api-1.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.6.8
+Version: 1.6.9
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT

graphql_api-1.6.9/VERSION

@@ -0,0 +1 @@
+1.6.9

{graphql_api-1.6.8 → graphql_api-1.6.9}/graphql_api/api.py

@@ -262,6 +262,7 @@ class GraphQLAPI(GraphQLBaseExecutor):
         self.error_protection = error_protection
         self.federation = federation
         self._cached_schema: Optional[Tuple[GraphQLSchema, Dict]] = None
+        self._cached_executor: Optional[GraphQLExecutor] = None
         self.max_docstring_length = max_docstring_length
         self.enum_suffix = enum_suffix
         self.interface_suffix = interface_suffix
@@ -904,10 +905,32 @@ class GraphQLAPI(GraphQLBaseExecutor):
         operation_name=None,
         root_value: Any = None,
     ) -> ExecutionResult:
-        return self.executor(root_value=root_value).execute(
+        # Reuse one executor across execute() calls: constructing one
+        # validates the schema and builds the middleware chain, which only
+        # depend on the (cached) schema. The root value keeps its per-call
+        # semantics — a fresh root instance per execution when root_type is
+        # callable — by being passed to execute() rather than frozen into
+        # the executor.
+        schema, meta = self.build()
+        executor = self._cached_executor
+        if executor is None or executor.schema is not schema:
+            executor = GraphQLExecutor(
+                schema=schema,
+                meta=meta,
+                root_value=None,
+                middleware=self.middleware,
+                error_protection=self.error_protection,
+            )
+            self._cached_executor = executor
+
+        if callable(self.root_type) and root_value is None:
+            root_value = self.root_type()
+
+        return executor.execute(
             query=query,
             variables=variables,
             operation_name=operation_name,
+            root_value=root_value,
         )
 
     def executor(

{graphql_api-1.6.8 → graphql_api-1.6.9}/graphql_api/executor.py

@@ -19,14 +19,7 @@ from graphql.language import DocumentNode
 from graphql.type.schema import GraphQLSchema
 
 from graphql_api.context import GraphQLContext
-from graphql_api.middleware import (
-    middleware_adapt_enum,
-    middleware_call_coroutine,
-    middleware_catch_exception,
-    middleware_field_context,
-    middleware_local_proxy,
-    middleware_request_context,
-)
+from graphql_api.middleware import middleware_combined
 
 
 class GraphQLBaseExecutor:
@@ -132,14 +125,13 @@ class GraphQLExecutor(GraphQLBaseExecutor):
         self.meta = meta if meta is not None else {}
         self.root_value = root_value
 
+        # The six built-in middleware are merged into one function: they run
+        # on every field resolution, and separate functions cost five extra
+        # call frames per field. Custom middleware stay innermost (closest to
+        # the resolver), exactly as with the individual built-ins.
         self.middleware = [
             *(middleware if middleware else []),
-            middleware_catch_exception,
-            middleware_field_context,
-            middleware_request_context,
-            middleware_local_proxy,
-            middleware_adapt_enum,
-            middleware_call_coroutine,
+            middleware_combined,
         ]
 
         # Build the middleware chain once. graphql-core constructs a fresh

{graphql_api-1.6.8 → graphql_api-1.6.9}/graphql_api/middleware.py

@@ -145,3 +145,98 @@ def middleware_field_context(next_, root, info, **args):
         info.context.field = None
 
     return value
+
+
+def middleware_combined(next_, root, info, **args):
+    """
+    All six built-in middleware merged into one function.
+
+    Runs on every field resolution, so the individual middleware — each a
+    trivial check — cost more in nested call frames than in work. This
+    preserves their exact composed semantics (outermost to innermost:
+    call_coroutine, adapt_enum, local_proxy, request_context, field_context,
+    catch_exception) in a single frame. The individual functions above remain
+    exported and behaviourally identical.
+    """
+    from graphql_api.api import GraphQLFieldContext, GraphQLRequestContext
+
+    context = info.context
+
+    # -- field_context (set up) --
+    field_meta = context.meta.get(
+        (info.parent_type.name, to_snake_case(info.field_name)), {}
+    )
+    if field_meta is None:
+        field_meta = {}
+    return_type = info.return_type
+    unwrapped_type = (
+        return_type.of_type
+        if return_type and isinstance(return_type, GraphQLNonNull)
+        else return_type
+    )
+    kwargs = {}
+    if unwrapped_type and isinstance(unwrapped_type, GraphQLObjectType):
+        sub_loc = info.field_nodes[0].selection_set.loc
+        kwargs["query"] = sub_loc.source.body[sub_loc.start: sub_loc.end]
+    context.field = GraphQLFieldContext(meta=field_meta, **kwargs)
+
+    # -- request_context (set up) --
+    request_created = False
+    if not context.request:
+        context.request = GraphQLRequestContext(
+            args={to_snake_case(key): arg for key, arg in args.items()}, info=info
+        )
+        request_created = True
+
+    try:
+        # -- catch_exception --
+        try:
+            value = next_(root, info, **args)
+        except Exception as err:
+            from graphql_api.executor import ErrorProtectionExecutionContext
+
+            if field_meta.get(GraphQLMetaKey.error_protection) is not None:
+                setattr(
+                    err,
+                    ErrorProtectionExecutionContext.error_protection,
+                    field_meta.get(GraphQLMetaKey.error_protection),
+                )
+            ignored = isinstance(info.return_type, GraphQLNonNull)
+            print(
+                f"GraphQLField '{info.field_name}' on '{info.parent_type.name}' "
+                f"resolver {'(ignored) ' if ignored else ''}Exception: {err} ",
+                file=sys.stderr,
+            )
+            traceback.print_exc()
+            raise err
+    finally:
+        if request_created:
+            context.request = None
+        context.field = None
+
+    # -- local_proxy --
+    try:
+        if hasattr(value, "_get_current_object"):
+            # noinspection PyProtectedMember
+            value = value._get_current_object()
+    except GraphQLError:
+        # hasattr calls getattr and remote.getattr() can raise a GraphQLError
+        # if the object doesn't have the attr
+        pass
+    if isinstance(value, Exception):
+        raise value
+
+    # -- adapt_enum --
+    if isinstance(value, enum.Enum) and not isinstance(value, TypeKind):
+        value = value.value
+
+    # -- call_coroutine --
+    if inspect.iscoroutine(value):
+        # Async GraphQL execution already awaits resolver coroutines.
+        # Only force resolution when called from a sync context.
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            value = asyncio.run(value)
+
+    return value

{graphql_api-1.6.8 → graphql_api-1.6.9}/graphql_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphql-api
-Version: 1.6.8
+Version: 1.6.9
 Summary: A framework for building Python GraphQL APIs.
 Author-email: Robert Parker <rob@parob.com>
 License: MIT

graphql_api-1.6.8/VERSION

@@ -1 +0,0 @@
-1.6.8