prefect-client 3.6.23.dev2__tar.gz → 3.6.23.dev4__tar.gz

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.6.23.dev2
+Version: 3.6.23.dev4
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/src/prefect/AGENTS.md

@@ -46,4 +46,7 @@ Use `get_logger()` from `prefect.logging` instead of raw `logging.getLogger()`
 - `settings/` → Configuration system (see settings/AGENTS.md)
 - `concurrency/` → Concurrency slot acquisition and lease management (see concurrency/AGENTS.md)
 - `logging/` → Logging handlers, API log shipping, and run-context loggers (see logging/AGENTS.md)
+- `runner/` → Thin facade over extracted single-responsibility classes for local flow run execution (see runner/AGENTS.md)
+- `deployments/` → YAML-driven deployment lifecycle: project init, build/push/pull steps, and triggering remote flow runs (see deployments/AGENTS.md)
+- `docker/` → `DockerImage` class for building and pushing Docker images during deployment
 - `telemetry/` → OS-level resource metric collection and run telemetry

prefect_client-3.6.23.dev4/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.6.23.dev4"
+__build_date__ = "2026-03-19 08:18:50.089319+00:00"
+__git_commit__ = "e5a389c661e12028d1e94766dda38f85c2e1d9c2"
+__dirty__ = False

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/src/prefect/client/orchestration/__init__.py

@@ -143,6 +143,7 @@ from prefect.client._version_checking import (
 )
 
 if TYPE_CHECKING:
+    from prefect.client.schemas.responses import WorkQueueConcurrencyStatus
     from prefect.tasks import Task as TaskObject
 
 from prefect.client.base import (
@@ -713,6 +714,44 @@ class PrefectClient(
                 raise
         return WorkQueueStatusDetail.model_validate(response.json())
 
+    async def read_work_queue_concurrency_status(
+        self,
+        id: UUID,
+        page: int = 1,
+        limit: Optional[int] = None,
+    ) -> "WorkQueueConcurrencyStatus":
+        """
+        Read concurrency status for a work queue.
+
+        Args:
+            id: the id of the work queue
+            page: Page number (1-indexed).
+            limit: Max flow runs per page (server default if None).
+
+        Raises:
+            prefect.exceptions.ObjectNotFound: If request returns 404
+            httpx.RequestError: If request fails
+
+        Returns:
+            Paginated WorkQueueConcurrencyStatus with flow run summaries
+        """
+        from prefect.client.schemas.responses import WorkQueueConcurrencyStatus
+
+        body: dict = {"page": page}
+        if limit is not None:
+            body["limit"] = limit
+
+        try:
+            response = await self._client.post(
+                f"/work_queues/{id}/concurrency_status", json=body
+            )
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == status.HTTP_404_NOT_FOUND:
+                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
+            else:
+                raise
+        return WorkQueueConcurrencyStatus.model_validate(response.json())
+
     async def match_work_queues(
         self,
         prefixes: list[str],
@@ -1882,6 +1921,44 @@ class SyncPrefectClient(
                 raise
         return WorkQueueStatusDetail.model_validate(response.json())
 
+    def read_work_queue_concurrency_status(
+        self,
+        id: UUID,
+        page: int = 1,
+        limit: Optional[int] = None,
+    ) -> "WorkQueueConcurrencyStatus":
+        """
+        Read concurrency status for a work queue.
+
+        Args:
+            id: the id of the work queue
+            page: Page number (1-indexed).
+            limit: Max flow runs per page (server default if None).
+
+        Raises:
+            prefect.exceptions.ObjectNotFound: If request returns 404
+            httpx.RequestError: If request fails
+
+        Returns:
+            Paginated WorkQueueConcurrencyStatus with flow run summaries
+        """
+        from prefect.client.schemas.responses import WorkQueueConcurrencyStatus
+
+        body: dict = {"page": page}
+        if limit is not None:
+            body["limit"] = limit
+
+        try:
+            response = self._client.post(
+                f"/work_queues/{id}/concurrency_status", json=body
+            )
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == status.HTTP_404_NOT_FOUND:
+                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
+            else:
+                raise
+        return WorkQueueConcurrencyStatus.model_validate(response.json())
+
     def match_work_queues(
         self,
         prefixes: list[str],

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/src/prefect/client/orchestration/_work_pools/client.py

@@ -25,7 +25,10 @@ if TYPE_CHECKING:
         WorkerMetadata,
         WorkPool,
     )
-    from prefect.client.schemas.responses import WorkerFlowRunResponse
+    from prefect.client.schemas.responses import (
+        WorkerFlowRunResponse,
+        WorkPoolConcurrencyStatus,
+    )
 
 from prefect.exceptions import ObjectAlreadyExists, ObjectNotFound, ObjectUnsupported
 
@@ -316,6 +319,47 @@ class WorkPoolClient(BaseClient):
 
         return WorkerFlowRunResponse.model_validate_list(response.json())
 
+    def read_work_pool_concurrency_status(
+        self,
+        work_pool_name: str,
+        page: int = 1,
+        limit: int | None = None,
+        flow_run_limit: int = 10,
+    ) -> "WorkPoolConcurrencyStatus":
+        """
+        Reads concurrency status for a work pool.
+
+        Args:
+            work_pool_name: The name of the work pool.
+            page: Page number (1-indexed).
+            limit: Max queues per page (server default if None).
+            flow_run_limit: Max flow runs per queue (0-200).
+
+        Returns:
+            Paginated concurrency status with per-queue breakdown.
+        """
+        from prefect.client.schemas.responses import WorkPoolConcurrencyStatus
+
+        body: dict[str, Any] = {"page": page}
+        if limit is not None:
+            body["limit"] = limit
+        body["flow_run_limit"] = flow_run_limit
+
+        try:
+            response = self.request(
+                "POST",
+                "/work_pools/{name}/concurrency_status",
+                path_params={"name": work_pool_name},
+                json=body,
+            )
+        except HTTPStatusError as e:
+            if e.response.status_code == 404:
+                raise ObjectNotFound(http_exc=e) from e
+            else:
+                raise
+
+        return WorkPoolConcurrencyStatus.model_validate(response.json())
+
 
 class WorkPoolAsyncClient(BaseAsyncClient):
     async def send_worker_heartbeat(
@@ -599,3 +643,44 @@ class WorkPoolAsyncClient(BaseAsyncClient):
                 raise
 
         return WorkerFlowRunResponse.model_validate_list(response.json())
+
+    async def read_work_pool_concurrency_status(
+        self,
+        work_pool_name: str,
+        page: int = 1,
+        limit: int | None = None,
+        flow_run_limit: int = 10,
+    ) -> "WorkPoolConcurrencyStatus":
+        """
+        Reads concurrency status for a work pool.
+
+        Args:
+            work_pool_name: The name of the work pool.
+            page: Page number (1-indexed).
+            limit: Max queues per page (server default if None).
+            flow_run_limit: Max flow runs per queue (0-200).
+
+        Returns:
+            Paginated concurrency status with per-queue breakdown.
+        """
+        from prefect.client.schemas.responses import WorkPoolConcurrencyStatus
+
+        body: dict[str, Any] = {"page": page}
+        if limit is not None:
+            body["limit"] = limit
+        body["flow_run_limit"] = flow_run_limit
+
+        try:
+            response = await self.request(
+                "POST",
+                "/work_pools/{name}/concurrency_status",
+                path_params={"name": work_pool_name},
+                json=body,
+            )
+        except HTTPStatusError as e:
+            if e.response.status_code == 404:
+                raise ObjectNotFound(http_exc=e) from e
+            else:
+                raise
+
+        return WorkPoolConcurrencyStatus.model_validate(response.json())

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/src/prefect/client/orchestration/routes.py

@@ -125,6 +125,7 @@ ServerRoutes = Literal[
     "/version",
     "/work_pools/",
     "/work_pools/{name}",
+    "/work_pools/{name}/concurrency_status",
     "/work_pools/{name}/get_scheduled_flow_runs",
     "/work_pools/{work_pool_name}/queues",
     "/work_pools/{work_pool_name}/queues/{name}",
@@ -137,6 +138,7 @@ ServerRoutes = Literal[
     "/work_queues/",
     "/work_queues/{id}",
     "/work_queues/{id}/get_runs",
+    "/work_queues/{id}/concurrency_status",
     "/work_queues/{id}/status",
     "/work_queues/filter",
     "/work_queues/name/{name}",

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/src/prefect/client/schemas/objects.py

@@ -1433,6 +1433,13 @@ class WorkQueue(ObjectBaseModel):
     status: Optional[WorkQueueStatus] = Field(
         default=None, description="The queue status."
     )
+    active_slots: Optional[int] = Field(
+        default=None,
+        description=(
+            "The number of concurrency slots currently in use. "
+            "None when concurrency_limit is not set."
+        ),
+    )
 
 
 class WorkQueueHealthPolicy(PrefectBaseModel):
@@ -1554,6 +1561,13 @@ class WorkPool(ObjectBaseModel):
     status: Optional[WorkPoolStatus] = Field(
         default=None, description="The current status of the work pool."
     )
+    active_slots: Optional[int] = Field(
+        default=None,
+        description=(
+            "The number of concurrency slots occupied by pending or running "
+            "flow runs. None when concurrency_limit is not set."
+        ),
+    )
 
     storage_configuration: WorkPoolStorageConfiguration = Field(
         default_factory=WorkPoolStorageConfiguration,

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/src/prefect/client/schemas/responses.py

@@ -1,4 +1,5 @@
 import datetime
+from datetime import timedelta
 from typing import TYPE_CHECKING, Any, ClassVar, Generic, Optional, TypeVar, Union
 from uuid import UUID
 
@@ -501,3 +502,50 @@ class GlobalConcurrencyLimitResponse(ObjectBaseModel):
         default=2.0,
         description="The decay rate for active slots when used as a rate limit.",
     )
+
+
+class FlowRunSlotSummary(PrefectBaseModel):
+    """Summary of a flow run occupying a concurrency slot."""
+
+    id: UUID
+    name: str
+    state_type: Optional[objects.StateType] = None
+    state_name: Optional[str] = None
+    start_time: Optional[DateTime] = None
+    state_timestamp: Optional[DateTime] = None
+    time_in_current_state: Optional[timedelta] = None
+
+
+class WorkQueueConcurrencyStatusDetail(PrefectBaseModel):
+    """Per-queue concurrency status with flow run details."""
+
+    queue_id: UUID
+    queue_name: str
+    active_slots: int
+    concurrency_limit: Optional[int] = None
+    flow_runs: list[FlowRunSlotSummary] = Field(default_factory=list)
+    flow_run_count: Optional[int] = None
+
+
+class WorkPoolConcurrencyStatus(PrefectBaseModel):
+    """Paginated pool-level concurrency status with per-queue breakdown."""
+
+    active_slots: int
+    concurrency_limit: Optional[int] = None
+    queues: list[WorkQueueConcurrencyStatusDetail] = Field(default_factory=list)
+    count: int
+    limit: int
+    pages: int
+    page: int
+
+
+class WorkQueueConcurrencyStatus(PrefectBaseModel):
+    """Paginated queue-level concurrency status with flow run details."""
+
+    active_slots: int
+    concurrency_limit: Optional[int] = None
+    flow_runs: list[FlowRunSlotSummary] = Field(default_factory=list)
+    count: int
+    limit: int
+    pages: int
+    page: int

prefect_client-3.6.23.dev4/src/prefect/deployments/AGENTS.md

@@ -0,0 +1,39 @@
+# Deployments
+
+YAML-driven configuration for packaging, publishing, and triggering flow runs from infrastructure.
+
+## Purpose & Scope
+
+Handles deployment lifecycle: initializing projects, building/pushing deployment artifacts, and triggering remote flow runs. Does NOT manage flow execution itself — that lives in `flow_engine.py` and `task_engine.py`.
+
+## Entry Points & Contracts
+
+- `runner.py` → `deploy()` — programmatic deployment creation from `Flow` objects
+- `flow_runs.py` → `run_deployment()` / `arun_deployment()` — trigger a run of an existing deployment
+- `base.py` → `initialize_project()` — scaffold `prefect.yaml` in a project directory
+- `steps/core.py` → `run_step()` / `run_steps()` — execute lifecycle steps defined in `prefect.yaml`
+
+## Steps System
+
+Steps are YAML entries in `build`, `push`, or `pull` blocks of `prefect.yaml`. Each step maps to a Python function imported at runtime. The `requires` keyword auto-installs missing packages before import.
+
+Step outputs are templated into subsequent steps via `{{ step-id.key }}`.
+
+Built-in steps:
+- `steps/pull.py` — `git_clone`, `set_working_directory`, `pull_from_remote_storage`
+- `steps/utility.py` — `run_shell_script`, `pip_install_requirements`
+
+## Entrypoint Formats
+
+`runner.py`'s `from_storage` / `afrom_storage` (and `Flow.from_source`) support two entrypoint formats:
+- **File path**: `path/to/file.py:flow_func_name` — detected by presence of `:`
+- **Module path**: `my_package.flows.flow_func` — detected by absence of `:`
+
+For module path entrypoints, the storage destination is temporarily prepended to `sys.path` so the module can be imported, then removed in a `finally` block. Any new code that loads flows from module paths must follow this same pattern to avoid polluting `sys.path`.
+
+## Pitfalls
+
+- **Windows shell mode**: `run_shell_script` always uses `asyncio.create_subprocess_shell` on Windows (`sys.platform == "win32"`), regardless of the `shell` parameter. This ensures cmd.exe built-ins (`echo`, `dir`, `set`, etc.) work. On non-Windows, `shell=False` (default) uses `create_subprocess_exec` with `shlex.split`.
+- **Step ID namespace**: `id` and `requires` are reserved keywords — do not use them as step output keys.
+- **Step import side effects**: steps are imported dynamically; packages listed in `requires` are installed into the current environment at execution time.
+- **String `image` argument suppresses build/push output.** When `deploy()` / `adeploy()` receives `image` as a plain string, it constructs `DockerImage(stream_progress_to=None)`, silencing all build and push progress. `DockerImage` itself defaults to `sys.stdout`, so users who pass a string get no output. To see build/push progress, pass a `DockerImage` object explicitly: `DockerImage("registry/image:tag", stream_progress_to=sys.stdout)`.

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/src/prefect/deployments/runner.py

@@ -32,6 +32,7 @@ Example:
 from __future__ import annotations
 
 import importlib
+import sys
 import tempfile
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -1160,7 +1161,8 @@ class RunnerDeployment(BaseModel):
 
         Args:
             entrypoint:  The path to a file containing a flow and the name of the flow function in
-                the format `./path/to/file.py:flow_func_name`.
+                the format `./path/to/file.py:flow_func_name`, or a module path to a flow function
+                in the format `module.path.flow_func_name`.
             name: A name for the deployment
             flow_name: The name of the flow to deploy
             storage: A storage object to use for retrieving flow code. If not provided, a
@@ -1213,10 +1215,19 @@ class RunnerDeployment(BaseModel):
             storage.set_base_path(Path(tmpdir))
             await storage.pull_code()
 
-            full_entrypoint = str(storage.destination / entrypoint)
-            flow = await from_async.wait_for_call_in_new_thread(
-                create_call(load_flow_from_entrypoint, full_entrypoint)
-            )
+            if ":" in entrypoint:
+                full_entrypoint = str(storage.destination / entrypoint)
+            else:
+                sys.path.insert(0, str(storage.destination))
+                full_entrypoint = entrypoint
+
+            try:
+                flow = await from_async.wait_for_call_in_new_thread(
+                    create_call(load_flow_from_entrypoint, full_entrypoint)
+                )
+            finally:
+                if ":" not in entrypoint:
+                    sys.path.remove(str(storage.destination))
 
         deployment = cls(
             name=name,
@@ -1239,6 +1250,11 @@ class RunnerDeployment(BaseModel):
             job_variables=job_variables,
         )
         deployment._sla = _sla
+        deployment._entrypoint_type = (
+            EntrypointType.FILE_PATH
+            if ":" in entrypoint
+            else EntrypointType.MODULE_PATH
+        )
         deployment._path = str(storage.destination).replace(
             tmpdir, "$STORAGE_BASE_PATH"
         )
@@ -1282,7 +1298,8 @@ class RunnerDeployment(BaseModel):
 
         Args:
             entrypoint:  The path to a file containing a flow and the name of the flow function in
-                the format `./path/to/file.py:flow_func_name`.
+                the format `./path/to/file.py:flow_func_name`, or a module path to a flow function
+                in the format `module.path.flow_func_name`.
             name: A name for the deployment
             flow_name: The name of the flow to deploy
             storage: A storage object to use for retrieving flow code. If not provided, a
@@ -1335,8 +1352,17 @@ class RunnerDeployment(BaseModel):
             storage.set_base_path(Path(tmpdir))
             run_coro_as_sync(storage.pull_code())
 
-            full_entrypoint = str(storage.destination / entrypoint)
-            flow = load_flow_from_entrypoint(full_entrypoint)
+            if ":" in entrypoint:
+                full_entrypoint = str(storage.destination / entrypoint)
+            else:
+                sys.path.insert(0, str(storage.destination))
+                full_entrypoint = entrypoint
+
+            try:
+                flow = load_flow_from_entrypoint(full_entrypoint)
+            finally:
+                if ":" not in entrypoint:
+                    sys.path.remove(str(storage.destination))
 
         deployment = cls(
             name=name,
@@ -1359,6 +1385,11 @@ class RunnerDeployment(BaseModel):
             job_variables=job_variables,
         )
         deployment._sla = _sla
+        deployment._entrypoint_type = (
+            EntrypointType.FILE_PATH
+            if ":" in entrypoint
+            else EntrypointType.MODULE_PATH
+        )
         deployment._path = str(storage.destination).replace(
             tmpdir, "$STORAGE_BASE_PATH"
         )
@@ -1448,7 +1479,7 @@ async def adeploy(
 
     if image and isinstance(image, str):
         image_name, image_tag = parse_image_tag(image)
-        image = DockerImage(name=image_name, tag=image_tag)
+        image = DockerImage(name=image_name, tag=image_tag, stream_progress_to=None)
 
     try:
         async with get_client() as client:
@@ -1687,7 +1718,7 @@ def deploy(
 
     if image and isinstance(image, str):
         image_name, image_tag = parse_image_tag(image)
-        image = DockerImage(name=image_name, tag=image_tag)
+        image = DockerImage(name=image_name, tag=image_tag, stream_progress_to=None)
 
     try:
         with get_client(sync_client=True) as client:

{prefect_client-3.6.23.dev2 → prefect_client-3.6.23.dev4}/src/prefect/deployments/steps/utility.py

@@ -20,6 +20,7 @@ Example:
     ```
 """
 
+import asyncio
 import io
 import os
 import shlex
@@ -28,6 +29,7 @@ import subprocess
 import sys
 from typing import Any, Dict, Optional
 
+import anyio
 from anyio import create_task_group
 from anyio.streams.text import TextReceiveStream
 from typing_extensions import TypedDict
@@ -60,6 +62,41 @@ async def _stream_capture_process_output(
         )
 
 
+async def _read_stream(
+    stream: asyncio.StreamReader,
+    *sinks: io.IOBase,
+):
+    """Read from an asyncio stream and write to one or more sinks."""
+    while True:
+        data = await stream.read(4096)
+        if not data:
+            break
+        text = data.decode()
+        for sink in sinks:
+            sink.write(text)
+            if hasattr(sink, "flush"):
+                sink.flush()
+
+
+async def _stream_capture_shell_process_output(
+    process: asyncio.subprocess.Process,
+    stdout_sink: io.StringIO,
+    stderr_sink: io.StringIO,
+    stream_output: bool = True,
+):
+    """Capture output from a shell subprocess (asyncio-based)."""
+    stdout_sinks = [stdout_sink, sys.stdout] if stream_output else [stdout_sink]
+    stderr_sinks = [stderr_sink, sys.stderr] if stream_output else [stderr_sink]
+
+    tasks = []
+    if process.stdout:
+        tasks.append(_read_stream(process.stdout, *stdout_sinks))
+    if process.stderr:
+        tasks.append(_read_stream(process.stderr, *stderr_sinks))
+
+    await asyncio.gather(*tasks)
+
+
 class RunShellScriptResult(TypedDict):
     """
     The result of a `run_shell_script` step.
@@ -79,6 +116,7 @@ async def run_shell_script(
     env: Optional[Dict[str, str]] = None,
     stream_output: bool = True,
     expand_env_vars: bool = False,
+    shell: bool = False,
 ) -> RunShellScriptResult:
     """
     Runs one or more shell commands in a subprocess. Returns the standard
@@ -93,6 +131,11 @@ async def run_shell_script(
             stdout/stderr
         expand_env_vars: Whether to expand environment variables in the script
             before running it
+        shell: Whether to run the command through the system shell.
+            When True, shell operators like pipes (|), redirects (>),
+            and logical operators (&&, ||) are supported. Only set this
+            to True when you need shell features, as it has security
+            implications similar to subprocess.run(shell=True).
 
     Returns:
         A dictionary with the keys `stdout` and `stderr` containing the output
@@ -158,6 +201,14 @@ async def run_shell_script(
             - prefect.deployments.steps.run_shell_script:
                 script: "bash path/to/script.sh"
         ```
+
+        Run a command that uses shell operators like pipes:
+        ```yaml
+        push:
+            - prefect.deployments.steps.run_shell_script:
+                script: echo "hello world" | tr '[:lower:]' '[:upper:]'
+                shell: true
+        ```
     """
     current_env = os.environ.copy()
     current_env.update(env or {})
@@ -170,30 +221,53 @@ async def run_shell_script(
         if expand_env_vars:
             # Expand environment variables in command and provided environment
             command = string.Template(command).safe_substitute(current_env)
-        split_command = shlex.split(command, posix=sys.platform != "win32")
-        if not split_command:
-            continue
-        async with open_process(
-            split_command,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            cwd=directory,
-            env=current_env,
-        ) as process:
-            await _stream_capture_process_output(
+
+        # On Windows, always use shell mode so cmd.exe built-ins
+        # (echo, dir, set, type, etc.) work without requiring shell=True.
+        use_shell = shell or sys.platform == "win32"
+
+        if use_shell:
+            command = command.strip()
+            if not command:
+                continue
+            process = await asyncio.create_subprocess_shell(
+                command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=directory,
+                env=current_env,
+            )
+        else:
+            split_command = shlex.split(command)
+            if not split_command:
+                continue
+            process = await asyncio.create_subprocess_exec(
+                *split_command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=directory,
+                env=current_env,
+            )
+
+        try:
+            await _stream_capture_shell_process_output(
                 process,
                 stdout_sink=stdout_sink,
                 stderr_sink=stderr_sink,
                 stream_output=stream_output,
             )
-
             await process.wait()
+        except BaseException:
+            with anyio.CancelScope(shield=True):
+                process.kill()
+                await process.wait()
+            raise
 
-            if process.returncode != 0:
-                raise RuntimeError(
-                    f"`run_shell_script` failed with error code {process.returncode}:"
-                    f" {stderr_sink.getvalue()}"
-                )
+        if process.returncode != 0:
+            raise RuntimeError(
+                f"`run_shell_script` failed with error code {process.returncode}:"
+                f" {stderr_sink.getvalue()}"
+            )
 
     return {
         "stdout": stdout_sink.getvalue().strip(),