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

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

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

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

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "strawberry-graphql"
 packages = [ { include = "strawberry" } ]
-version = "0.183.3"
+version = "0.183.4"
 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.4}/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 = [