strawberry-graphql 0.183.3__tar.gz → 0.183.5__tar.gz

{strawberry_graphql-0.183.3 → strawberry_graphql-0.183.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strawberry-graphql
-Version: 0.183.3
+Version: 0.183.5
 Summary: A library for creating GraphQL APIs
 Home-page: https://strawberry.rocks/
 License: MIT

{strawberry_graphql-0.183.3 → strawberry_graphql-0.183.5}/pyproject.toml

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

{strawberry_graphql-0.183.3 → strawberry_graphql-0.183.5}/strawberry/types/types.py

@@ -16,7 +16,6 @@ from typing import (
 from typing_extensions import Self
 
 from strawberry.type import StrawberryType, StrawberryTypeVar
-from strawberry.utils.inspect import get_specialized_type_var_map
 from strawberry.utils.typing import is_generic as is_type_generic
 
 if TYPE_CHECKING:
@@ -116,13 +115,7 @@ class TypeDefinition(StrawberryType):
 
     @property
     def is_specialized_generic(self) -> bool:
-        if not self.is_generic:
-            return False
-
-        type_var_map = get_specialized_type_var_map(self.origin, include_type_vars=True)
-        return type_var_map is None or not any(
-            isinstance(arg, TypeVar) for arg in type_var_map.values()
-        )
+        return self.is_generic and not getattr(self.origin, "__parameters__", None)
 
     @property
     def type_params(self) -> List[TypeVar]:

{strawberry_graphql-0.183.3 → strawberry_graphql-0.183.5}/strawberry/utils/inspect.py

@@ -1,8 +1,15 @@
 import asyncio
 import inspect
 from functools import lru_cache
-from typing import Any, Callable, Dict, List, Optional, TypeVar, Union, overload
-from typing_extensions import Literal, get_args
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    TypeVar,
+)
+from typing_extensions import get_args
 
 
 def in_async_context() -> bool:
@@ -29,36 +36,7 @@ def get_func_args(func: Callable[[Any], Any]) -> List[str]:
     ]
 
 
-@overload
-def get_specialized_type_var_map(
-    cls: type,
-    *,
-    include_type_vars: Literal[True],
-) -> Optional[Dict[TypeVar, Union[TypeVar, type]]]:
-    ...
-
-
-@overload
-def get_specialized_type_var_map(
-    cls: type,
-    *,
-    include_type_vars: Literal[False] = ...,
-) -> Optional[Dict[TypeVar, type]]:
-    ...
-
-
-@overload
-def get_specialized_type_var_map(
-    cls: type,
-    *,
-    include_type_vars: bool,
-) -> Optional[
-    Union[Optional[Dict[TypeVar, type]], Dict[TypeVar, Union[TypeVar, type]]]
-]:
-    ...
-
-
-def get_specialized_type_var_map(cls: type, *, include_type_vars: bool = False):
+def get_specialized_type_var_map(cls: type) -> Optional[Dict[TypeVar, type]]:
     """Get a type var map for specialized types.
 
     Consider the following:
@@ -85,8 +63,6 @@ def get_specialized_type_var_map(cls: type, *, include_type_vars: bool = False):
         None
         >>> get_specialized_type_var_map(Foo)
         {}
-        >>> get_specialized_type_var_map(Foo, include_type_vars=True)
-        {~T: ~T}
         >>> get_specialized_type_var_map(Bar)
         {~T: ~T}
         >>> get_specialized_type_var_map(IntBar)
@@ -104,6 +80,10 @@ def get_specialized_type_var_map(cls: type, *, include_type_vars: bool = False):
 
     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 hasattr(b, "_type_definition")]
+
     for base in orig_bases:
         # Recursively get type var map from base classes
         base_type_var_map = get_specialized_type_var_map(base)
@@ -121,11 +101,7 @@ def get_specialized_type_var_map(cls: type, *, include_type_vars: bool = False):
             continue
 
         type_var_map.update(
-            {
-                p: a
-                for p, a in zip(params, args)
-                if include_type_vars or not isinstance(a, TypeVar)
-            }
+            {p: a for p, a in zip(params, args) if not isinstance(a, TypeVar)}
         )
 
     return type_var_map

{strawberry_graphql-0.183.3 → strawberry_graphql-0.183.5}/strawberry/utils/typing.py

@@ -1,5 +1,4 @@
 import ast
-import re
 import sys
 import typing
 from functools import lru_cache
@@ -12,6 +11,7 @@ from typing import (  # type: ignore
     Dict,
     ForwardRef,
     Generic,
+    List,
     Optional,
     Tuple,
     Type,
@@ -222,9 +222,66 @@ def _ast_replace_union_operation(
     return expr
 
 
-_annotated_re = re.compile(
-    r"(Annotated\[)(?P<type>\w*),(?P<args>.*)(\])",
-)
+def _get_namespace_from_ast(
+    expr: Union[ast.Expr, ast.expr],
+    globalns: Optional[Dict] = None,
+    localns: Optional[Dict] = None,
+) -> Dict[str, Type]:
+    from strawberry.lazy_type import StrawberryLazyReference
+
+    extra = {}
+
+    if isinstance(expr, ast.Expr) and isinstance(
+        expr.value, (ast.BinOp, ast.Subscript)
+    ):
+        extra.update(_get_namespace_from_ast(expr.value, globalns, localns))
+    elif isinstance(expr, ast.BinOp):
+        for elt in (expr.left, expr.right):
+            extra.update(_get_namespace_from_ast(elt, globalns, localns))
+    elif (
+        isinstance(expr, ast.Subscript)
+        and isinstance(expr.value, ast.Name)
+        and expr.value.id == "Union"
+    ):
+        if hasattr(ast, "Index") and isinstance(expr.slice, ast.Index):
+            # The cast is required for mypy on python 3.7 and 3.8
+            expr_slice = cast(Any, expr.slice).value
+        else:
+            expr_slice = expr.slice
+
+        for elt in cast(ast.Tuple, expr_slice).elts:
+            extra.update(_get_namespace_from_ast(elt, globalns, localns))
+    elif (
+        isinstance(expr, ast.Subscript)
+        and isinstance(expr.value, ast.Name)
+        and expr.value.id == "Annotated"
+    ):
+        assert ast_unparse
+
+        if hasattr(ast, "Index") and isinstance(expr.slice, ast.Index):
+            # The cast is required for mypy on python 3.7 and 3.8
+            expr_slice = cast(Any, expr.slice).value
+        else:
+            expr_slice = expr.slice
+
+        args: List[str] = []
+        for elt in cast(ast.Tuple, expr_slice).elts:
+            extra.update(_get_namespace_from_ast(elt, globalns, localns))
+            args.append(ast_unparse(elt))
+
+        # When using forward refs, the whole
+        # Annotated[SomeType, strawberry.lazy("type.module")] is a forward ref,
+        # and trying to _eval_type on it will fail. Take a different approach
+        # here to resolve lazy types by execing the annotated args, resolving the
+        # type directly and then adding it to extra namespace, so that _eval_type
+        # can properly resolve it later
+        type_name = args[0]
+        for arg in args[1:]:
+            evaled_arg = eval(arg, globalns, localns)  # noqa: PGH001
+            if isinstance(evaled_arg, StrawberryLazyReference):
+                extra[type_name] = evaled_arg.resolve_forward_ref(ForwardRef(type_name))
+
+    return extra
 
 
 def eval_type(
@@ -240,51 +297,22 @@ def eval_type(
     globalns = globalns or {}
     # If this is not a string, maybe its args are (e.g. List["Foo"])
     if isinstance(type_, ForwardRef):
+        ast_obj = cast(ast.Expr, ast.parse(type_.__forward_arg__).body[0])
+
         # For Python 3.10+, we can use the built-in _eval_type function directly.
         # It will handle "|" notations properly
         if sys.version_info < (3, 10):
-            parsed = _ast_replace_union_operation(
-                cast(ast.Expr, ast.parse(type_.__forward_arg__).body[0])
-            )
+            ast_obj = _ast_replace_union_operation(ast_obj)
 
             # We replaced "a | b" with "Union[a, b], so make sure Union can be resolved
             # at globalns because it may not be there
             if "Union" not in globalns:
                 globalns["Union"] = Union
 
-            assert ast_unparse
-            type_ = ForwardRef(ast_unparse(parsed))
-
-        # When using forward refs, the whole
-        # Annotated[SomeType, strabwerry.lazy("type.module")] is a forward ref,
-        # and trying to _eval_type on it will fail. Take a different approach
-        # here to resolve lazy types by execing the annotated args and resolving
-        # the type directly.
-        annotated_match = _annotated_re.search(type_.__forward_arg__)
-        if annotated_match:
-            gdict = annotated_match.groupdict()
-            # FIXME: Eval the remaining annotated args to get their real values
-            # We might want to refactor how we import lazy modules to avoid having
-            # to eval the code in here
-            args = eval(f'({gdict["args"]}, )', globalns, localns)  # noqa: PGH001
-            lazy_ref = next(
-                (arg for arg in args if isinstance(arg, StrawberryLazyReference)),
-                None,
-            )
-            if lazy_ref is not None:
-                remaining = [
-                    a for a in args if not isinstance(a, StrawberryLazyReference)
-                ]
-                type_ = lazy_ref.resolve_forward_ref(ForwardRef(gdict["type"]))
-                # If we only had a StrawberryLazyReference, we can return the type
-                # directly. It already did its job!
-                if not remaining:
-                    return type_
+        globalns.update(_get_namespace_from_ast(ast_obj, globalns, localns))
 
-                # Otherwise return the type annotated with the remaining annotations
-                return Annotated.__class_getitem__(  # type: ignore
-                    (type_, *remaining),
-                )
+        assert ast_unparse
+        type_ = ForwardRef(ast_unparse(ast_obj))
 
         return _eval_type(type_, globalns, localns)
 
@@ -302,7 +330,12 @@ def eval_type(
                         for a in args[1:]
                         if not isinstance(arg, StrawberryLazyReference)
                     ]
-                    args = (arg.resolve_forward_ref(args[0]), *remaining_args)
+                    type_arg = (
+                        arg.resolve_forward_ref(args[0])
+                        if isinstance(args[0], ForwardRef)
+                        else args[0]
+                    )
+                    args = (type_arg, *remaining_args)
                     break
                 if isinstance(arg, StrawberryAuto):
                     remaining_args = [