strawberry-graphql 0.259.0__tar.gz → 0.260.0__tar.gz

{strawberry_graphql-0.259.0 → strawberry_graphql-0.260.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: strawberry-graphql
-Version: 0.259.0
+Version: 0.260.0
 Summary: A library for creating GraphQL APIs
 License: MIT
 Keywords: graphql,api,rest,starlette,async

{strawberry_graphql-0.259.0 → strawberry_graphql-0.260.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.259.0"
+version = "0.260.0"
 description = "A library for creating GraphQL APIs"
 authors = ["Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "MIT"

{strawberry_graphql-0.259.0 → strawberry_graphql-0.260.0}/strawberry/fastapi/router.py

@@ -125,7 +125,9 @@ class GraphQLRouter(
         keep_alive_interval: float = 1,
         debug: bool = False,
         root_value_getter: Optional[Callable[[], RootValue]] = None,
-        context_getter: Optional[Callable[..., Optional[Context]]] = None,
+        context_getter: Optional[
+            Callable[..., Union[Optional[Context], Awaitable[Optional[Context]]]]
+        ] = None,
         subscription_protocols: Sequence[str] = (
             GRAPHQL_TRANSPORT_WS_PROTOCOL,
             GRAPHQL_WS_PROTOCOL,

strawberry_graphql-0.260.0/strawberry/utils/inspect.py

@@ -0,0 +1,135 @@
+import asyncio
+import inspect
+from functools import lru_cache
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    Optional,
+    Protocol,
+    TypeVar,
+    Union,
+    get_args,
+    get_origin,
+)
+
+import strawberry
+
+
+def in_async_context() -> bool:
+    # Based on the way django checks if there's an event loop in the current thread
+    # https://github.com/django/django/blob/main/django/utils/asyncio.py
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return False
+    else:
+        return True
+
+
+@lru_cache(maxsize=250)
+def get_func_args(func: Callable[[Any], Any]) -> list[str]:
+    """Returns a list of arguments for the function."""
+    sig = inspect.signature(func)
+
+    return [
+        arg_name
+        for arg_name, param in sig.parameters.items()
+        if param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
+    ]
+
+
+def get_specialized_type_var_map(cls: type) -> Optional[dict[str, type]]:
+    """Get a type var map for specialized types.
+
+    Consider the following:
+
+    ```python
+    class Foo(Generic[T]): ...
+
+
+    class Bar(Generic[K]): ...
+
+
+    class IntBar(Bar[int]): ...
+
+
+    class IntBarSubclass(IntBar): ...
+
+
+    class IntBarFoo(IntBar, Foo[str]): ...
+    ```
+
+    This would return:
+
+    ```python
+    get_specialized_type_var_map(object)
+    # None
+
+    get_specialized_type_var_map(Foo)
+    # {}
+
+    get_specialized_type_var_map(Bar)
+    # {}
+
+    get_specialized_type_var_map(IntBar)
+    # {~T: int, ~K: int}
+
+    get_specialized_type_var_map(IntBarSubclass)
+    # {~T: int, ~K: int}
+
+    get_specialized_type_var_map(IntBarFoo)
+    # {~T: int, ~K: str}
+    ```
+    """
+    from strawberry.types.base import has_object_definition
+
+    param_args: dict[TypeVar, Union[TypeVar, type]] = {}
+
+    types: list[type] = [cls]
+    while types:
+        tp = types.pop(0)
+        if (origin := get_origin(tp)) is None or origin in (Generic, Protocol):
+            origin = tp
+
+        # only get type vars for base generics (i.e. Generic[T]) and for strawberry types
+        if not has_object_definition(origin):
+            continue
+
+        if (type_params := getattr(origin, "__parameters__", None)) is not None:
+            args = get_args(tp)
+            if args:
+                for type_param, arg in zip(type_params, args):
+                    if type_param not in param_args:
+                        param_args[type_param] = arg
+            else:
+                for type_param in type_params:
+                    if type_param not in param_args:
+                        param_args[type_param] = strawberry.UNSET
+
+        if orig_bases := getattr(origin, "__orig_bases__", None):
+            types.extend(orig_bases)
+    if not param_args:
+        return None
+
+    for type_param, arg in list(param_args.items()):
+        resolved_arg = arg
+        while (
+            isinstance(resolved_arg, TypeVar) and resolved_arg is not strawberry.UNSET
+        ):
+            resolved_arg = (
+                param_args.get(resolved_arg, strawberry.UNSET)
+                if resolved_arg is not type_param
+                else strawberry.UNSET
+            )
+
+        param_args[type_param] = resolved_arg
+
+    return {
+        k.__name__: v
+        for k, v in reversed(param_args.items())
+        if v is not strawberry.UNSET and not isinstance(v, TypeVar)
+    }
+
+
+__all__ = ["get_func_args", "get_specialized_type_var_map", "in_async_context"]

strawberry_graphql-0.259.0/strawberry/utils/inspect.py

@@ -1,123 +0,0 @@
-import asyncio
-import inspect
-from functools import lru_cache
-from typing import (
-    Any,
-    Callable,
-    Optional,
-    TypeVar,
-    get_origin,
-)
-from typing_extensions import get_args
-
-from strawberry.utils.typing import is_generic_alias
-
-
-def in_async_context() -> bool:
-    # Based on the way django checks if there's an event loop in the current thread
-    # https://github.com/django/django/blob/main/django/utils/asyncio.py
-    try:
-        asyncio.get_running_loop()
-    except RuntimeError:
-        return False
-    else:
-        return True
-
-
-@lru_cache(maxsize=250)
-def get_func_args(func: Callable[[Any], Any]) -> list[str]:
-    """Returns a list of arguments for the function."""
-    sig = inspect.signature(func)
-
-    return [
-        arg_name
-        for arg_name, param in sig.parameters.items()
-        if param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD
-    ]
-
-
-def get_specialized_type_var_map(cls: type) -> Optional[dict[str, type]]:
-    """Get a type var map for specialized types.
-
-    Consider the following:
-
-    ```python
-    class Foo(Generic[T]): ...
-
-
-    class Bar(Generic[K]): ...
-
-
-    class IntBar(Bar[int]): ...
-
-
-    class IntBarSubclass(IntBar): ...
-
-
-    class IntBarFoo(IntBar, Foo[str]): ...
-    ```
-
-    This would return:
-
-    ```python
-    get_specialized_type_var_map(object)
-    # None
-
-    get_specialized_type_var_map(Foo)
-    # {}
-
-    get_specialized_type_var_map(Bar)
-    # {~T: ~T}
-
-    get_specialized_type_var_map(IntBar)
-    # {~T: int}
-
-    get_specialized_type_var_map(IntBarSubclass)
-    # {~T: int}
-
-    get_specialized_type_var_map(IntBarFoo)
-    # {~T: int, ~K: str}
-    ```
-    """
-    from strawberry.types.base import has_object_definition
-
-    orig_bases = getattr(cls, "__orig_bases__", None)
-    if orig_bases is None:
-        # Specialized generic aliases will not have __orig_bases__
-        if get_origin(cls) is not None and is_generic_alias(cls):
-            orig_bases = (cls,)
-        else:
-            # Not a specialized type
-            return None
-
-    type_var_map = {}
-
-    # only get type vars for base generics (ie. Generic[T]) and for strawberry types
-
-    orig_bases = [b for b in orig_bases if has_object_definition(b)]
-
-    for base in orig_bases:
-        # Recursively get type var map from base classes
-        if base is not cls:
-            base_type_var_map = get_specialized_type_var_map(base)
-            if base_type_var_map is not None:
-                type_var_map.update(base_type_var_map)
-
-        args = get_args(base)
-        origin = getattr(base, "__origin__", None)
-
-        params = origin and getattr(origin, "__parameters__", None)
-        if params is None:
-            params = getattr(base, "__parameters__", None)
-
-        if not params:
-            continue
-
-        type_var_map.update(
-            {p.__name__: a for p, a in zip(params, args) if not isinstance(a, TypeVar)}
-        )
-
-    return type_var_map
-
-
-__all__ = ["get_func_args", "get_specialized_type_var_map", "in_async_context"]