dirigent-block-execute 0.17.2__tar.gz → 0.17.3__tar.gz

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: dirigent-block-execute
-Version: 0.17.2
+Version: 0.17.3
 Summary: The execute block family for dirigent: shell, docker, compose, buildx, and a checkout.
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: dirigent-block-http==0.17.2
-Requires-Dist: dirigent-common==0.17.2
-Requires-Dist: dirigent-plugin==0.17.2
+Requires-Dist: dirigent-block-http==0.17.3
+Requires-Dist: dirigent-common==0.17.3
+Requires-Dist: dirigent-plugin==0.17.3
 Requires-Dist: httpx2>=2.12.0
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-block-execute"
-version = "0.17.2"
+version = "0.17.3"
 description = "The execute block family for dirigent: shell, docker, compose, buildx, and a checkout."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -11,9 +11,9 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-block-http==0.17.2",
-    "dirigent-common==0.17.2",
-    "dirigent-plugin==0.17.2",
+    "dirigent-block-http==0.17.3",
+    "dirigent-common==0.17.3",
+    "dirigent-plugin==0.17.3",
     "httpx2>=2.12.0",
 ]
 

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-block-execute"
-version = "0.17.2"
+version = "0.17.3"
 description = "The execute block family for dirigent: shell, docker, compose, buildx, and a checkout."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -11,9 +11,9 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-block-http==0.17.2",
-    "dirigent-common==0.17.2",
-    "dirigent-plugin==0.17.2",
+    "dirigent-block-http==0.17.3",
+    "dirigent-common==0.17.3",
+    "dirigent-plugin==0.17.3",
     "httpx2>=2.12.0",
 ]
 

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/src/dirigent_block_execute/build.py

@@ -176,22 +176,18 @@ class DockerBuildOperator(Operator[DockerBuildConfig, DockerBuildOutput]):
         if config.push and (settings is None or not settings.authenticates):
             raise BlockFailure(NO_REGISTRY_CREDENTIAL, error_class=ErrorClass.REJECTED)
         timeout = config.timeout.total_seconds()
-        artifacts = subprocess.prefix(ctx, "build")
-        stdout_uri = f"{artifacts}-stdout.txt"
-        build_log_uri = f"{artifacts}-build.log"
 
         with sealed(settings, root, isolate_config=config.push) as material:
             environ = daemon_environment(
                 subprocess.environment([*DAEMON_ENV, *config.env_allowlist], config.env, root), material
             )
             write_cli_config(root / ".docker")
-            code, out, err = await subprocess.run(
+            code, out, err, stdout_uri, build_log_uri = await subprocess.run(
                 directory=root,
                 ctx=ctx,
-                stdout_uri=stdout_uri,
-                stderr_uri=build_log_uri,
                 timeout_seconds=timeout,
                 environ=environ,
+                stderr_name="build.log",
                 argv=build_argv(config, context, iidfile),
                 what="docker buildx build",
                 redact=material.secrets,

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/src/dirigent_block_execute/compose.py

@@ -342,7 +342,6 @@ class DockerComposeUpOperator(Operator[DockerComposeUpConfig, DockerComposeUpOut
         assert compose_file is not None
         project = config.project_name or _default_project(ctx)
         timeout = config.timeout.total_seconds()
-        stdout_uri, stderr_uri = _artifact_uris(ctx, "up")
 
         with sealed(_connection(config.connection, ctx), root) as material:
             environ = daemon_environment(
@@ -350,13 +349,13 @@ class DockerComposeUpOperator(Operator[DockerComposeUpConfig, DockerComposeUpOut
             )
             write_cli_config(root / ".docker")
             try:
-                code, out, err = await subprocess.run(
+                code, out, err, stdout_uri, stderr_uri = await subprocess.run(
                     directory=root,
                     ctx=ctx,
-                    stdout_uri=stdout_uri,
-                    stderr_uri=stderr_uri,
                     timeout_seconds=timeout,
                     environ=environ,
+                    stdout_name="up-stdout",
+                    stderr_name="up-stderr",
                     argv=up_argv(config, project, compose_file, root),
                     what="docker compose up",
                 )
@@ -411,20 +410,19 @@ class DockerComposeDownOperator(Operator[DockerComposeDownConfig, DockerComposeD
         compose_file = _compose_file(config.file, config.content, ctx, root)
         project = config.project_name or _default_project(ctx)
         timeout = config.timeout.total_seconds()
-        stdout_uri, stderr_uri = _artifact_uris(ctx, "down")
 
         with sealed(_connection(config.connection, ctx), root) as material:
             environ = daemon_environment(
                 subprocess.environment([*DAEMON_ENV, *config.env_allowlist], config.env, root), material
             )
             write_cli_config(root / ".docker")
-            code, out, err = await subprocess.run(
+            code, out, err, stdout_uri, stderr_uri = await subprocess.run(
                 directory=root,
                 ctx=ctx,
-                stdout_uri=stdout_uri,
-                stderr_uri=stderr_uri,
                 timeout_seconds=timeout,
                 environ=environ,
+                stdout_name="down-stdout",
+                stderr_name="down-stderr",
                 argv=down_argv(config, project, compose_file, root),
                 what="docker compose down",
             )
@@ -656,12 +654,6 @@ def _work_relative(path: Path, root: Path) -> str:
     return str(path.relative_to(root))
 
 
-def _artifact_uris(ctx: StepContext, action: str) -> tuple[str, str]:
-    """Where the CLI's two streams are written for this attempt."""
-    root = f"{subprocess.prefix(ctx, 'compose')}-{action}"
-    return f"{root}-stdout.txt", f"{root}-stderr.txt"
-
-
 def _default_project(ctx: StepContext) -> str:
     """A project name that is the same across a run's up, drive and down, and unique between runs."""
     return f"dirigent-{ctx.run_id.hex}"

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/src/dirigent_block_execute/docker.py

@@ -582,21 +582,16 @@ class DockerRunOperator(Operator[DockerRunConfig, DockerRunOutput]):
 
     async def fetch(self, handle: RemoteHandle, config: DockerRunConfig, ctx: StepContext) -> DockerRunOutput:
         """Collect the exit code, the streams, and the declared files, then drop the container."""
-        artifacts = subprocess.prefix(ctx, "docker")
-        stdout_uri = f"{artifacts}-stdout.txt"
-        stderr_uri = f"{artifacts}-stderr.txt"
         with _material(config, ctx) as environ:
             async with _daemon(config, environ) as daemon:
                 inspected = await daemon.inspect(handle.ref)
                 if inspected is None:
                     raise BlockFailure(CONTAINER_GONE, error_class=ErrorClass.TRANSIENT, container=handle.ref[:12])
-                async with (
-                    ctx.storage.open_write(stdout_uri) as out_sink,
-                    ctx.storage.open_write(stderr_uri) as err_sink,
-                ):
+                async with ctx.capture("stdout") as out_sink, ctx.capture("stderr") as err_sink:
                     stdout, stderr = await drain_logs(
                         daemon, handle.ref, ctx.inline_capture, sinks=(out_sink, err_sink)
                     )
+                    stdout_uri, stderr_uri = out_sink.uri, err_sink.uri
                 collected = await _collect_outputs(config, handle, ctx)
                 # The run log gets only what the probes have not already streamed: the segment
                 # between the last committed cursor and the exit. The full read above is for

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/src/dirigent_block_execute/git.py

@@ -381,16 +381,13 @@ class _Git:
         artifact rather than a buffer in the worker. Each command writes its own pair, named for
         its subcommand; the pair the last one wrote is what the output carries.
         """
-        artifacts = f"{subprocess.prefix(self.ctx, 'git')}-{argv[0]}"
-        stdout_uri = f"{artifacts}-stdout.txt"
-        stderr_uri = f"{artifacts}-stderr.txt"
-        code, out, err = await subprocess.run(
+        code, out, err, stdout_uri, stderr_uri = await subprocess.run(
             directory=directory,
             ctx=self.ctx,
-            stdout_uri=stdout_uri,
-            stderr_uri=stderr_uri,
             timeout_seconds=self.timeout,
             environ=self.environ,
+            stdout_name=f"{argv[0]}-stdout",
+            stderr_name=f"{argv[0]}-stderr",
             argv=[self.binary, *argv],
             what=f"git {argv[0]}",
             redact=self.secrets,

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/src/dirigent_block_execute/shell.py

@@ -136,14 +136,9 @@ class ShellRunOperator(Operator[ShellRunConfig, ShellRunOutput]):
         workspace = subprocess.workspace(ctx, "shell")
         directory = workspace / config.cwd if config.cwd else workspace
         directory.mkdir(parents=True, exist_ok=True)
-        artifacts = subprocess.prefix(ctx, "shell")
-        stdout_uri = f"{artifacts}-stdout.txt"
-        stderr_uri = f"{artifacts}-stderr.txt"
-        code, out, err = await subprocess.run(
+        code, out, err, stdout_uri, stderr_uri = await subprocess.run(
             directory=directory,
             ctx=ctx,
-            stdout_uri=stdout_uri,
-            stderr_uri=stderr_uri,
             timeout_seconds=config.timeout.total_seconds(),
             environ=_environment(config, directory),
             argv=config.argv or None,

{dirigent_block_execute-0.17.2 → dirigent_block_execute-0.17.3}/src/dirigent_block_execute/subprocess.py

@@ -14,6 +14,7 @@ import os
 import signal
 from collections.abc import Sequence
 from pathlib import Path
+from typing import NamedTuple
 
 from dirigent_block_execute.capture import Drained, LiveLines, drain
 from dirigent_block_execute.environment import allowed
@@ -24,22 +25,26 @@ from dirigent_plugin import BlockFailure, ErrorClass, StepContext
 BASELINE_ENV = ("PATH", "LANG", "LC_ALL", "TZ")
 
 
+class Ran(NamedTuple):
+    """What one child process left behind: how it exited, both streams, and where they were written."""
+
+    code: int
+    out: Drained
+    err: Drained
+    stdout_uri: str
+    stderr_uri: str
+
+
 def segment(ctx: StepContext, name: str) -> str:
-    """The path this attempt's files sit at, under either of the run's two roots.
+    """The path this attempt's files sit at, inside the run's work directory.
 
-    ``{name}/{step}[/{item}]/attempt-{n}``. Both roots are the run's, so the step key and,
-    inside a fan-out, the item id are what keep two steps of one run and two items of one step
-    out of each other's files and working directories.
+    ``{name}/{step}[/{item}]/attempt-{n}``. The step key, and inside a fan-out the item id,
+    are what keep two steps of one run and two items of one step out of each other's files.
     """
     item = f"/{ctx.run_item_id}" if ctx.run_item_id is not None else ""
     return f"{name}/{ctx.step}{item}/attempt-{ctx.attempt}"
 
 
-def prefix(ctx: StepContext, name: str) -> str:
-    """The storage URI this attempt's artifact names are built on, under the run's scratch prefix."""
-    return f"{ctx.scratch.rstrip('/')}/{segment(ctx, name)}"
-
-
 def workspace(ctx: StepContext, name: str) -> Path:
     """This attempt's working directory inside the run's work directory, made if absent."""
     directory = ctx.work / segment(ctx, name)
@@ -59,22 +64,24 @@ async def run(
     *,
     directory: Path,
     ctx: StepContext,
-    stdout_uri: str,
-    stderr_uri: str,
     timeout_seconds: float,
     environ: dict[str, str],
+    stdout_name: str = "stdout",
+    stderr_name: str = "stderr",
     argv: list[str] | None = None,
     command: str | None = None,
     what: str = "the command",
     redact: Sequence[str] = (),
-) -> tuple[int, Drained, Drained]:
+) -> Ran:
     """Start the process, drain it under the timeout, and leave nothing of it behind.
 
-    Both pipes are read as the process writes them and written straight through to storage,
-    so what is held is two bounded ends of each stream rather than all of it: a process that
-    prints more than the worker has memory for is a file, not a dead worker. Each stream's
-    first lines go into the run log where they are printed, so a long command is visible
-    working; ``redact`` names the strings it was handed that must not reach one of them.
+    Both pipes are read as the process writes them and written straight through to a capture
+    the context opens and names, so what is held is two bounded ends of each stream rather
+    than all of it: a process that prints more than the worker has memory for is a file, not
+    a dead worker. The two names distinguish one command's streams from another's where a
+    step runs more than one. Each stream's first lines go into the run log where they are
+    printed, so a long command is visible working; ``redact`` names the strings it was
+    handed that must not reach one of them.
 
     The process leads a session of its own, so what it starts is killable with it: a command
     is usually ``sh -c``, and killing the shell alone leaves the children doing the work.
@@ -106,7 +113,7 @@ async def run(
     pgid = group_of(process)
     try:
         async with asyncio.timeout(timeout_seconds):
-            async with ctx.storage.open_write(stdout_uri) as out_sink, ctx.storage.open_write(stderr_uri) as err_sink:
+            async with ctx.capture(stdout_name) as out_sink, ctx.capture(stderr_name) as err_sink:
                 out, err = await asyncio.gather(
                     drain(
                         process.stdout,
@@ -126,7 +133,7 @@ async def run(
         raise BlockFailure(TIMED_OUT, error_class=ErrorClass.TRANSIENT, what=what, seconds=timeout_seconds) from error
     finally:
         await end(process, pgid)
-    return process.returncode or 0, out, err
+    return Ran(process.returncode or 0, out, err, out_sink.uri, err_sink.uri)
 
 
 async def output(
@@ -207,12 +214,12 @@ def kill(pgid: int, pid: int) -> None:
 
 __all__ = [
     "BASELINE_ENV",
+    "Ran",
     "end",
     "environment",
     "group_of",
     "kill",
     "output",
-    "prefix",
     "run",
     "segment",
     "workspace",