strawberry-graphql 0.190.0.dev1687447182__py3-none-any.whl → 0.192.1__py3-none-any.whl

strawberry/annotation.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 import sys
 import typing
 from collections import abc
@@ -85,13 +86,15 @@ class StrawberryAnnotation:
         if isinstance(annotation, str):
             annotation = ForwardRef(annotation)
 
+        args = []
+
         evaled_type = eval_type(annotation, self.namespace, None)
 
         if is_private(evaled_type):
             return evaled_type
 
         if get_origin(evaled_type) is Annotated:
-            evaled_type = get_args(evaled_type)[0]
+            evaled_type, *args = get_args(evaled_type)
 
         if self._is_async_type(evaled_type):
             evaled_type = self._strip_async_type(evaled_type)
@@ -116,7 +119,7 @@ class StrawberryAnnotation:
         elif self._is_optional(evaled_type):
             return self.create_optional(evaled_type)
         elif self._is_union(evaled_type):
-            return self.create_union(evaled_type)
+            return self.create_union(evaled_type, args)
         elif is_type_var(evaled_type) or evaled_type is Self:
             return self.create_type_var(cast(TypeVar, evaled_type))
 
@@ -173,7 +176,7 @@ class StrawberryAnnotation:
     def create_type_var(self, evaled_type: TypeVar) -> StrawberryTypeVar:
         return StrawberryTypeVar(evaled_type)
 
-    def create_union(self, evaled_type: Type) -> StrawberryUnion:
+    def create_union(self, evaled_type: Type[Any], args: list[Any]) -> StrawberryUnion:
         # Prevent import cycles
         from strawberry.union import StrawberryUnion
 
@@ -182,9 +185,27 @@ class StrawberryAnnotation:
             return evaled_type
 
         types = evaled_type.__args__
+
         union = StrawberryUnion(
             type_annotations=tuple(StrawberryAnnotation(type_) for type_ in types),
         )
+
+        union_args = [arg for arg in args if isinstance(arg, StrawberryUnion)]
+        if len(union_args) > 1:
+            logging.warning(
+                "Duplicate union definition detected. "
+                "Only the first definition will be considered"
+            )
+
+        if union_args:
+            arg = union_args[0]
+            union.graphql_name = arg.graphql_name
+            union.description = arg.description
+            union.directives = arg.directives
+
+            union._source_file = arg._source_file
+            union._source_line = arg._source_line
+
         return union
 
     @classmethod

strawberry/arguments.py

@@ -177,13 +177,17 @@ def convert_argument(
     if has_object_definition(type_):
         kwargs = {}
 
-        for field in type_.__strawberry_definition__.fields:
+        type_definition = type_.__strawberry_definition__
+        for field in type_definition.fields:
             value = cast(Mapping, value)
             graphql_name = config.name_converter.from_field(field)
 
             if graphql_name in value:
                 kwargs[field.python_name] = convert_argument(
-                    value[graphql_name], field.type, scalar_registry, config
+                    value[graphql_name],
+                    field.resolve_type(type_definition=type_definition),
+                    scalar_registry,
+                    config,
                 )
 
         type_ = cast(type, type_)

strawberry/channels/testing.py

@@ -14,7 +14,7 @@ from typing import (
     Union,
 )
 
-from graphql import GraphQLError
+from graphql import GraphQLError, GraphQLFormattedError
 
 from channels.testing.websocket import WebsocketCommunicator
 from strawberry.subscriptions import GRAPHQL_TRANSPORT_WS_PROTOCOL, GRAPHQL_WS_PROTOCOL
@@ -100,6 +100,9 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
             response = await self.receive_json_from()
             assert response["type"] == GQL_CONNECTION_ACK
 
+    # Actual `ExecutionResult`` objects are not available client-side, since they
+    # get transformed into `FormattedExecutionResult` on the wire, but we attempt
+    # to do a limited representation of them here, to make testing simpler.
     async def subscribe(
         self, query: str, variables: Optional[Dict] = None
     ) -> Union[ExecutionResult, AsyncIterator[ExecutionResult]]:
@@ -125,22 +128,28 @@ class GraphQLWebsocketCommunicator(WebsocketCommunicator):
             message_type = response["type"]
             if message_type == NextMessage.type:
                 payload = NextMessage(**response).payload
-                ret = ExecutionResult(None, None)
-                for field in dataclasses.fields(ExecutionResult):
-                    setattr(ret, field.name, payload.get(field.name, None))
-                    yield ret
+                ret = ExecutionResult(payload["data"], None)
+                if "errors" in payload:
+                    ret.errors = self.process_errors(payload["errors"])
+                ret.extensions = payload.get("extensions", None)
+                yield ret
             elif message_type == ErrorMessage.type:
                 error_payload = ErrorMessage(**response).payload
                 yield ExecutionResult(
-                    data=None,
-                    errors=[
-                        GraphQLError(
-                            message=message["message"],
-                            extensions=message.get("extensions", None),
-                        )
-                        for message in error_payload
-                    ],
+                    data=None, errors=self.process_errors(error_payload)
                 )
                 return  # an error message is the last message for a subscription
             else:
                 return
+
+    def process_errors(self, errors: List[GraphQLFormattedError]) -> List[GraphQLError]:
+        """Reconst a GraphQLError from a FormattedGraphQLError"""
+        result = []
+        for f_error in errors:
+            error = GraphQLError(
+                message=f_error["message"],
+                extensions=f_error.get("extensions", None),
+            )
+            error.path = f_error.get("path", None)
+            result.append(error)
+        return result

strawberry/cli/__init__.py

@@ -1,7 +1,7 @@
-from .commands.codegen import codegen  # noqa
-from .commands.export_schema import export_schema  # noqa
-from .commands.server import server  # noqa
-
+from .commands.codegen import codegen as codegen  # noqa
+from .commands.export_schema import export_schema as export_schema  # noqa
+from .commands.server import server as server  # noqa
+from .commands.upgrade import upgrade as upgrade  # noqa
 
 from .app import app
 

strawberry/cli/commands/upgrade/__init__.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import glob
+import pathlib  # noqa: TCH003
+import sys
+from typing import List
+
+import rich
+import typer
+from libcst.codemod import CodemodContext
+
+from strawberry.cli.app import app
+from strawberry.codemods.annotated_unions import ConvertUnionToAnnotatedUnion
+
+from ._run_codemod import run_codemod
+
+codemods = {
+    "annotated-union": ConvertUnionToAnnotatedUnion,
+}
+
+
+# TODO: add support for running all of them
+@app.command(help="Upgrades a Strawberry project to the latest version")
+def upgrade(
+    codemod: str = typer.Argument(
+        ...,
+        autocompletion=lambda: list(codemods.keys()),
+        help="Name of the upgrade to run",
+    ),
+    paths: List[pathlib.Path] = typer.Argument(file_okay=True, dir_okay=True),
+    python_target: str = typer.Option(
+        ".".join(str(x) for x in sys.version_info[:2]),
+        "--python-target",
+        help="Python version to target",
+    ),
+    use_typing_extensions: bool = typer.Option(
+        False,
+        "--use-typing-extensions",
+        help="Use typing_extensions instead of typing for newer features",
+    ),
+) -> None:
+    if codemod not in codemods:
+        rich.print(f'[red]Upgrade named "{codemod}" does not exist')
+
+        raise typer.Exit(2)
+
+    python_target_version = tuple(int(x) for x in python_target.split("."))
+
+    transformer = ConvertUnionToAnnotatedUnion(
+        CodemodContext(),
+        use_pipe_syntax=python_target_version >= (3, 10),
+        use_typing_extensions=use_typing_extensions,
+    )
+
+    files: list[str] = []
+
+    for path in paths:
+        if path.is_dir():
+            glob_path = str(path / "**/*.py")
+            files.extend(glob.glob(glob_path, recursive=True))
+        else:
+            files.append(str(path))
+
+    files = list(set(files))
+
+    results = list(run_codemod(transformer, files))
+    changed = [result for result in results if result.changed]
+
+    rich.print()
+    rich.print("[green]Upgrade completed successfully, here's a summary:")
+    rich.print(f"  - {len(changed)} files changed")
+    rich.print(f"  - {len(results) - len(changed)} files skipped")
+
+    if changed:
+        raise typer.Exit(1)

strawberry/cli/commands/upgrade/_fake_progress.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+from rich.progress import TaskID
+
+
+class FakeProgress:
+    """A fake progress bar that does nothing.
+
+    This is used when the user has only one file to process."""
+
+    def advance(self, task_id: TaskID) -> None:
+        pass
+
+    def add_task(self, *args: Any, **kwargs: Any) -> TaskID:
+        return TaskID(0)
+
+    def __enter__(self) -> "FakeProgress":
+        return self
+
+    def __exit__(self, *args: Any, **kwargs: Any) -> None:
+        pass

strawberry/cli/commands/upgrade/_run_codemod.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import contextlib
+import os
+from multiprocessing import Pool, cpu_count
+from typing import TYPE_CHECKING, Any, Dict, Generator, Sequence, Type, Union
+
+from libcst.codemod._cli import ExecutionConfig, ExecutionResult, _execute_transform
+from libcst.codemod._dummy_pool import DummyPool
+from rich.progress import Progress
+
+from ._fake_progress import FakeProgress
+
+if TYPE_CHECKING:
+    from libcst.codemod import Codemod
+
+ProgressType = Union[Type[Progress], Type[FakeProgress]]
+PoolType = Union[Type[Pool], Type[DummyPool]]  # type: ignore
+
+
+def _execute_transform_wrap(
+    job: Dict[str, Any],
+) -> ExecutionResult:
+    # TODO: maybe capture warnings?
+    with open(os.devnull, "w") as null:  # noqa: PTH123
+        with contextlib.redirect_stderr(null):
+            return _execute_transform(**job)
+
+
+def _get_progress_and_pool(
+    total_files: int, jobs: int
+) -> tuple[PoolType, ProgressType]:
+    poll_impl: PoolType = Pool  # type: ignore
+    progress_impl: ProgressType = Progress
+
+    if total_files == 1 or jobs == 1:
+        poll_impl = DummyPool
+
+    if total_files == 1:
+        progress_impl = FakeProgress
+
+    return poll_impl, progress_impl
+
+
+def run_codemod(
+    codemod: Codemod,
+    files: Sequence[str],
+) -> Generator[ExecutionResult, None, None]:
+    chunk_size = 4
+    total = len(files)
+    jobs = min(cpu_count(), (total + chunk_size - 1) // chunk_size)
+
+    config = ExecutionConfig()
+
+    pool_impl, progress_impl = _get_progress_and_pool(total, jobs)
+
+    tasks = [
+        {
+            "transformer": codemod,
+            "filename": filename,
+            "config": config,
+        }
+        for filename in files
+    ]
+
+    with pool_impl(processes=jobs) as p, progress_impl() as progress:  # type: ignore
+        task_id = progress.add_task("[cyan]Updating...", total=len(tasks))
+
+        for result in p.imap_unordered(
+            _execute_transform_wrap, tasks, chunksize=chunk_size
+        ):
+            progress.advance(task_id)
+
+            yield result

strawberry/codemods/annotated_unions.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import libcst as cst
+import libcst.matchers as m
+from libcst._nodes.expression import BaseExpression, Call  # noqa: TCH002
+from libcst.codemod import CodemodContext, VisitorBasedCodemodCommand
+from libcst.codemod.visitors import AddImportsVisitor, RemoveImportsVisitor
+
+
+def _find_named_argument(args: Sequence[cst.Arg], name: str) -> cst.Arg | None:
+    return next(
+        (arg for arg in args if arg.keyword and arg.keyword.value == name),
+        None,
+    )
+
+
+def _find_positional_argument(
+    args: Sequence[cst.Arg], search_index: int
+) -> cst.Arg | None:
+    for index, arg in enumerate(args):
+        if index > search_index:
+            return None
+
+        if index == search_index and arg.keyword is None:
+            return arg
+
+    return None
+
+
+class ConvertUnionToAnnotatedUnion(VisitorBasedCodemodCommand):
+    DESCRIPTION: str = (
+        "Converts strawberry.union(..., types=(...)) to "
+        "Annotated[Union[...], strawberry.union(...)]"
+    )
+
+    def __init__(
+        self,
+        context: CodemodContext,
+        use_pipe_syntax: bool = True,
+        use_typing_extensions: bool = False,
+    ) -> None:
+        self._is_using_named_import = False
+        self.use_pipe_syntax = use_pipe_syntax
+        self.use_typing_extensions = use_typing_extensions
+
+        super().__init__(context)
+
+    def visit_Module(self, node: cst.Module) -> Optional[bool]:
+        self._is_using_named_import = False
+
+        return super().visit_Module(node)
+
+    @m.visit(
+        m.ImportFrom(
+            m.Name("strawberry"),
+            [
+                m.ZeroOrMore(),
+                m.ImportAlias(m.Name("union")),
+                m.ZeroOrMore(),
+            ],
+        )
+    )
+    def visit_import_from(self, original_node: cst.ImportFrom) -> None:
+        self._is_using_named_import = True
+
+    @m.leave(
+        m.Call(
+            func=m.Attribute(value=m.Name("strawberry"), attr=m.Name("union"))
+            | m.Name("union")
+        )
+    )
+    def leave_union_call(
+        self, original_node: Call, updated_node: Call
+    ) -> BaseExpression:
+        if not self._is_using_named_import and isinstance(original_node.func, cst.Name):
+            return original_node
+
+        types = _find_named_argument(original_node.args, "types")
+        union_name = _find_named_argument(original_node.args, "name")
+
+        if types is None:
+            types = _find_positional_argument(original_node.args, 1)
+
+        # this is probably a strawberry.union(name="...") so we skip the conversion
+        # as it is going to be used in the new way already 😊
+
+        if types is None:
+            return original_node
+
+        AddImportsVisitor.add_needed_import(
+            self.context,
+            "typing_extensions" if self.use_typing_extensions else "typing",
+            "Annotated",
+        )
+
+        RemoveImportsVisitor.remove_unused_import(self.context, "strawberry", "union")
+
+        if union_name is None:
+            union_name = _find_positional_argument(original_node.args, 0)
+
+        assert union_name
+        assert isinstance(types.value, (cst.Tuple, cst.List))
+
+        types = types.value.elements  # type: ignore
+        union_name = union_name.value  # type: ignore
+
+        description = _find_named_argument(original_node.args, "description")
+        directives = _find_named_argument(original_node.args, "directives")
+
+        if self.use_pipe_syntax:
+            union_node = self._create_union_node_with_pipe_syntax(types)  # type: ignore
+        else:
+            AddImportsVisitor.add_needed_import(self.context, "typing", "Union")
+
+            union_node = cst.Subscript(
+                value=cst.Name(value="Union"),
+                slice=[
+                    cst.SubscriptElement(slice=cst.Index(value=t.value)) for t in types  # type: ignore  # noqa: E501
+                ],
+            )
+
+        union_call_args = [
+            cst.Arg(
+                value=union_name,  # type: ignore
+                keyword=cst.Name(value="name"),
+                equal=cst.AssignEqual(
+                    whitespace_before=cst.SimpleWhitespace(""),
+                    whitespace_after=cst.SimpleWhitespace(""),
+                ),
+            )
+        ]
+
+        additional_args = {"description": description, "directives": directives}
+
+        union_call_args.extend(
+            cst.Arg(
+                value=arg.value,
+                keyword=cst.Name(name),
+                equal=cst.AssignEqual(
+                    whitespace_before=cst.SimpleWhitespace(""),
+                    whitespace_after=cst.SimpleWhitespace(""),
+                ),
+            )
+            for name, arg in additional_args.items()
+            if arg is not None
+        )
+
+        union_call_node = cst.Call(
+            func=cst.Attribute(
+                value=cst.Name(value="strawberry"),
+                attr=cst.Name(value="union"),
+            ),
+            args=union_call_args,
+        )
+
+        return cst.Subscript(
+            value=cst.Name(value="Annotated"),
+            slice=[
+                cst.SubscriptElement(
+                    slice=cst.Index(
+                        value=union_node,
+                    ),
+                ),
+                cst.SubscriptElement(
+                    slice=cst.Index(
+                        value=union_call_node,
+                    ),
+                ),
+            ],
+        )
+
+    @classmethod
+    def _create_union_node_with_pipe_syntax(
+        cls, types: Sequence[cst.BaseElement]
+    ) -> cst.BaseExpression:
+        type_names = [t.value for t in types]
+
+        if not all(isinstance(t, cst.Name) for t in type_names):
+            raise ValueError("Only names are supported for now")
+
+        expression = " | ".join(name.value for name in type_names)  # type: ignore
+
+        return cst.parse_expression(expression)

strawberry/exceptions/invalid_union_type.py

@@ -20,11 +20,18 @@ class InvalidUnionTypeError(StrawberryException):
 
     invalid_type: object
 
-    def __init__(self, union_name: str, invalid_type: object) -> None:
+    def __init__(
+        self,
+        union_name: str,
+        invalid_type: object,
+        union_definition: Optional[StrawberryUnion] = None,
+    ) -> None:
         from strawberry.custom_scalar import ScalarWrapper
+        from strawberry.type import StrawberryList
 
         self.union_name = union_name
         self.invalid_type = invalid_type
+        self.union_definition = union_definition
 
         # assuming that the exception happens two stack frames above the current one.
         # one is our code checking for invalid types, the other is the caller
@@ -32,6 +39,8 @@ class InvalidUnionTypeError(StrawberryException):
 
         if isinstance(invalid_type, ScalarWrapper):
             type_name = invalid_type.wrap.__name__
+        elif isinstance(invalid_type, StrawberryList):
+            type_name = "list[...]"
         else:
             try:
                 type_name = invalid_type.__name__  # type: ignore
@@ -50,10 +59,21 @@ class InvalidUnionTypeError(StrawberryException):
 
     @cached_property
     def exception_source(self) -> Optional[ExceptionSource]:
-        path = Path(self.frame.filename)
-
         source_finder = SourceFinder()
 
+        if self.union_definition:
+            source = source_finder.find_annotated_union(
+                self.union_definition, self.invalid_type
+            )
+
+            if source:
+                return source
+
+        if not self.frame:
+            return None
+
+        path = Path(self.frame.filename)
+
         return source_finder.find_union_call(path, self.union_name, self.invalid_type)