squarepeg 0.1.0__tar.gz → 0.2.1__tar.gz

{squarepeg-0.1.0 → squarepeg-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squarepeg
-Version: 0.1.0
+Version: 0.2.1
 Summary: Run a docker-run-style command as a Kubernetes Pod or Job, streaming its output like a local process
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -12,6 +12,15 @@ Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: pytest-cov>=5; extra == "dev"
 Requires-Dist: ruff>=0.4; extra == "dev"
 
+```
+   _____                                             
+  / ___/____ ___  ______ _________  ____  ___  ____ _
+  \__ \/ __ `/ / / / __ `/ ___/ _ \/ __ \/ _ \/ __ `/
+ ___/ / /_/ / /_/ / /_/ / /  /  __/ /_/ /  __/ /_/ / 
+/____/\__, /\__,_/\__,_/_/   \___/ .___/\___/\__, /  
+        /_/                     /_/         /____/   
+```
+
 # squarepeg
 
 Run a `docker run`-style command as a Kubernetes Pod or Job, streaming its

{squarepeg-0.1.0 → squarepeg-0.2.1}/README.md

@@ -1,3 +1,12 @@
+```
+   _____                                             
+  / ___/____ ___  ______ _________  ____  ___  ____ _
+  \__ \/ __ `/ / / / __ `/ ___/ _ \/ __ \/ _ \/ __ `/
+ ___/ / /_/ / /_/ / /_/ / /  /  __/ /_/ /  __/ /_/ / 
+/____/\__, /\__,_/\__,_/_/   \___/ .___/\___/\__, /  
+        /_/                     /_/         /____/   
+```
+
 # squarepeg
 
 Run a `docker run`-style command as a Kubernetes Pod or Job, streaming its

{squarepeg-0.1.0 → squarepeg-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "squarepeg"
-version = "0.1.0"
+version = "0.2.1"
 description = "Run a docker-run-style command as a Kubernetes Pod or Job, streaming its output like a local process"
 readme = "README.md"
 requires-python = ">=3.11"

squarepeg-0.2.1/squarepeg/__init__.py

@@ -0,0 +1,6 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("squarepeg")
+except PackageNotFoundError:  # running from a source checkout that was never pip-installed
+    __version__ = "0.0.0+unknown"

{squarepeg-0.1.0 → squarepeg-0.2.1}/squarepeg/cli.py

@@ -1,13 +1,23 @@
 import click
 import yaml
 
-from squarepeg import __version__
-from squarepeg.config import coerce_bool, coerce_int, load_effective_config, select_profile
-from squarepeg.dockerargs import check_supported_image, parse_env_entries, reject_unsupported
+from squarepeg import __version__, ui
+from squarepeg.config import (
+    coerce_bool,
+    coerce_int,
+    load_effective_config,
+    select_profile,
+)
+from squarepeg.dockerargs import (
+    check_supported_image,
+    parse_env_entries,
+    reject_unsupported,
+)
 from squarepeg.errors import SquarepegError, UsageError
 from squarepeg.k8s.dryrun import server_dry_run
 from squarepeg.k8s.runner import run_manifest
 from squarepeg.k8s.session import Session
+from squarepeg.log import chatter
 from squarepeg.manifest import build_job, build_pod
 from squarepeg.naming import generate_name, validate_rfc1123
 from squarepeg.quantities import docker_cpus_to_k8s, docker_memory_to_k8s
@@ -16,7 +26,11 @@ from squarepeg.volumes import auto_mounts_from_config, parse_volume_flag
 
 _CONFIG_OPTIONS = [
     click.option(
-        "--config", "config_paths", multiple=True, type=click.Path(), help="repeatable, layered left-to-right"
+        "--config",
+        "config_paths",
+        multiple=True,
+        type=click.Path(),
+        help="repeatable, layered left-to-right",
     ),
     click.option("--no-default-config", "no_default_config", is_flag=True),
     click.option("--profile", "profile", default=None),
@@ -30,7 +44,9 @@ def _add_config_options(cmd):
 
 
 def _resolve_config(config_paths, no_default_config, profile):
-    effective, sources = load_effective_config(config_paths, no_default_config=no_default_config)
+    effective, sources = load_effective_config(
+        config_paths, no_default_config=no_default_config
+    )
     resolved = select_profile(effective, profile)
     return resolved, sources
 
@@ -74,7 +90,24 @@ def _add_unsupported_options(cmd):
     return cmd
 
 
-@click.group()
+_LOGO = r"""
+   _____                                             
+  / ___/____ ___  ______ _________  ____  ___  ____ _
+  \__ \/ __ `/ / / / __ `/ ___/ _ \/ __ \/ _ \/ __ `/
+ ___/ / /_/ / /_/ / /_/ / /  /  __/ /_/ /  __/ /_/ / 
+/____/\__, /\__,_/\__,_/_/   \___/ .___/\___/\__, /  
+        /_/                     /_/         /____/   
+""".strip("\n")
+
+class _LogoGroup(click.Group):
+    """Prints the ASCII logo above the 'Usage:' line, rather than as part of the help body."""
+
+    def format_usage(self, ctx, formatter):
+        formatter.write(_LOGO + "\n\n")
+        super().format_usage(ctx, formatter)
+
+
+@click.group(cls=_LogoGroup)
 @click.version_option(__version__, prog_name="squarepeg")
 def cli():
     """Run a docker-run-style command as a Kubernetes Pod or Job."""
@@ -84,14 +117,38 @@ def cli():
     context_settings={"allow_interspersed_args": False, "ignore_unknown_options": True},
 )
 @click.option("-e", "--env", "env_entries", multiple=True, help="KEY=VALUE, repeatable")
-@click.option("-v", "--volume", "volume_entries", multiple=True, help="[NAME|/host]:/container[:ro|rw], repeatable")
+@click.option(
+    "-v",
+    "--volume",
+    "volume_entries",
+    multiple=True,
+    help="[NAME|/host]:/container[:ro|rw], repeatable",
+)
 @click.option("--name", "name", default=None, help="Pod/Job name")
 @click.option("-w", "--workdir", "workdir", default=None)
-@click.option("--entrypoint", "entrypoint", default=None, help="Override the image ENTRYPOINT (-> k8s 'command')")
-@click.option("-i", "--interactive", "interactive", is_flag=True, help="accepted; stdin is not forwarded")
+@click.option(
+    "--entrypoint",
+    "entrypoint",
+    default=None,
+    help="Override the image ENTRYPOINT (-> k8s 'command')",
+)
+@click.option(
+    "-i",
+    "--interactive",
+    "interactive",
+    is_flag=True,
+    help="accepted; stdin is not forwarded",
+)
 @click.option("-t", "--tty", "tty", is_flag=True)
-@click.option("--rm", "rm_flag", is_flag=True, help="accepted no-op; cleanup is already the default")
-@click.option("--pull", "pull", type=click.Choice(["always", "missing", "never"]), default=None)
+@click.option(
+    "--rm",
+    "rm_flag",
+    is_flag=True,
+    help="accepted no-op; cleanup is already the default",
+)
+@click.option(
+    "--pull", "pull", type=click.Choice(["always", "missing", "never"]), default=None
+)
 @click.option("--cpus", "cpus", default=None)
 @click.option("-m", "--memory", "memory", default=None)
 @click.option("--request-cpu", "request_cpu", default=None)
@@ -100,8 +157,12 @@ def cli():
 @click.option("--limit-memory", "limit_memory", default=None)
 @click.option("--mode", "mode", type=click.Choice(["pod", "job"]), default=None)
 @click.option("-n", "--namespace", "namespace", default=None)
-@click.option("--keep", "keep", is_flag=True, help="do not delete the pod/job after it finishes")
-@click.option("--dry-run", "dry_run", is_flag=True, help="render the manifest without creating it")
+@click.option(
+    "--keep", "keep", is_flag=True, help="do not delete the pod/job after it finishes"
+)
+@click.option(
+    "--dry-run", "dry_run", is_flag=True, help="render the manifest without creating it"
+)
 @click.option(
     "--dry-run-server",
     "dry_run_server",
@@ -110,6 +171,12 @@ def cli():
 )
 @click.option("--timeout", "timeout", type=int, default=None)
 @click.option("--quiet", "quiet", is_flag=True)
+@click.option(
+    "--no-color",
+    "no_color",
+    is_flag=True,
+    help="disable colour/animation in squarepeg's own stderr output",
+)
 @click.option("--context", "context", default=None, help="kubeconfig context to use")
 @click.option("--container-name", "container_name", default="main")
 @click.argument("image")
@@ -142,22 +209,28 @@ def run(
     profile,
     timeout,
     quiet,
+    no_color,
     context,
     container_name,
     image,
     command,
 ):
     """Run IMAGE [COMMAND...] as a Kubernetes Pod or Job."""
+    ui.set_color_override(False if no_color else None)
     check_supported_image(image)
     if rm_flag and keep:
         raise UsageError("--rm and --keep are mutually exclusive")
     if dry_run and dry_run_server:
         raise UsageError("--dry-run and --dry-run-server are mutually exclusive")
 
-    resolved_config, _sources = _resolve_config(config_paths, no_default_config, profile)
+    resolved_config, _sources = _resolve_config(
+        config_paths, no_default_config, profile
+    )
     config_defaults = resolved_config.get("defaults") or {}
     config_volumes = resolved_config.get("volumes") or {}
-    allow_host_path_mounts = coerce_bool(resolved_config.get("allow_host_path_mounts", False), "allow_host_path_mounts")
+    allow_host_path_mounts = coerce_bool(
+        resolved_config.get("allow_host_path_mounts", False), "allow_host_path_mounts"
+    )
 
     claims: set[str] = set()
 
@@ -166,12 +239,18 @@ def run(
         claims.add(f"/spec/containers/[name={container_name}]/env/[name={key}]")
 
     cli_volumes = [
-        parse_volume_flag(v, config_volumes=config_volumes, allow_host_path_mounts=allow_host_path_mounts)
+        parse_volume_flag(
+            v,
+            config_volumes=config_volumes,
+            allow_host_path_mounts=allow_host_path_mounts,
+        )
         for v in volume_entries
     ]
     for vol in cli_volumes:
         claims.add(f"/spec/volumes/[name={vol.volume_name}]")
-        claims.add(f"/spec/containers/[name={container_name}]/volumeMounts/[name={vol.volume_name}]")
+        claims.add(
+            f"/spec/containers/[name={container_name}]/volumeMounts/[name={vol.volume_name}]"
+        )
 
     # config-declared auto-mounts (volumes.NAME with a mount_path) are not claimed -- they're
     # config-driven, not CLI-driven, so kubernetes.spec passthrough in the same config can still
@@ -200,7 +279,9 @@ def run(
         claims.add(f"/spec/containers/[name={container_name}]/resources/limits/cpu")
     if request_memory is not None:
         resources.request_memory = request_memory
-        claims.add(f"/spec/containers/[name={container_name}]/resources/requests/memory")
+        claims.add(
+            f"/spec/containers/[name={container_name}]/resources/requests/memory"
+        )
     if limit_memory is not None:
         resources.limit_memory = limit_memory
         claims.add(f"/spec/containers/[name={container_name}]/resources/limits/memory")
@@ -209,7 +290,9 @@ def run(
     if cli_set_cpus and limit_cpu is None:
         claims.add(f"/spec/containers/[name={container_name}]/resources/limits/cpu")
     if cli_set_memory and request_memory is None:
-        claims.add(f"/spec/containers/[name={container_name}]/resources/requests/memory")
+        claims.add(
+            f"/spec/containers/[name={container_name}]/resources/requests/memory"
+        )
     if cli_set_memory and limit_memory is None:
         claims.add(f"/spec/containers/[name={container_name}]/resources/limits/memory")
 
@@ -224,7 +307,11 @@ def run(
     else:
         namespace = resolved_config.get("namespace")
 
-    pull_policy = {"always": "Always", "missing": "IfNotPresent", "never": "Never"}.get(pull) if pull else None
+    pull_policy = (
+        {"always": "Always", "missing": "IfNotPresent", "never": "Never"}.get(pull)
+        if pull
+        else None
+    )
     if pull_policy is not None:
         claims.add(f"/spec/containers/[name={container_name}]/imagePullPolicy")
     elif "image_pull_policy" in config_defaults:
@@ -236,13 +323,25 @@ def run(
         workdir = config_defaults["workdir"]
 
     mode = mode or resolved_config.get("mode", "pod")
-    timeout = timeout if timeout is not None else coerce_int(resolved_config.get("timeout", 300), "timeout")
+    timeout = (
+        timeout
+        if timeout is not None
+        else coerce_int(resolved_config.get("timeout", 300), "timeout")
+    )
     quiet = quiet or coerce_bool(resolved_config.get("quiet", False), "quiet")
-    cleanup = False if keep else coerce_bool(resolved_config.get("cleanup", True), "cleanup")
-    orphan_sweep = coerce_bool(resolved_config.get("orphan_sweep", True), "orphan_sweep")
-    orphan_sweep_min_age = coerce_int(resolved_config.get("orphan_sweep_min_age", 300), "orphan_sweep_min_age")
+    cleanup = (
+        False if keep else coerce_bool(resolved_config.get("cleanup", True), "cleanup")
+    )
+    orphan_sweep = coerce_bool(
+        resolved_config.get("orphan_sweep", True), "orphan_sweep"
+    )
+    orphan_sweep_min_age = coerce_int(
+        resolved_config.get("orphan_sweep_min_age", 300), "orphan_sweep_min_age"
+    )
     if orphan_sweep_min_age < 0:
-        raise UsageError(f"'orphan_sweep_min_age' must not be negative, got {orphan_sweep_min_age}")
+        raise UsageError(
+            f"'orphan_sweep_min_age' must not be negative, got {orphan_sweep_min_age}"
+        )
 
     entrypoint_tuple = (entrypoint,) if entrypoint is not None else None
     if entrypoint_tuple is not None:
@@ -255,11 +354,14 @@ def run(
         if not interactive:
             # some clusters reject tty=true with stdin=false; -i is accepted but never
             # forwards real stdin, so this can hang a container that then blocks reading it.
-            click.echo(
-                "squarepeg: -t implies stdin is opened on the container (stdinOnce), but stdin is "
+            # This is a real hazard warning, so it's deliberately never suppressed by
+            # --quiet (quiet=False below), unlike squarepeg's other informational chatter.
+            chatter(
+                "-t implies stdin is opened on the container (stdinOnce), but stdin is "
                 "never actually forwarded; a process that blocks reading stdin will hang. Pass -i "
                 "explicitly to acknowledge this.",
-                err=True,
+                quiet=False,
+                level="warn",
             )
             interactive = True
     if interactive:
@@ -311,21 +413,38 @@ def run(
     raise SystemExit(exit_code)
 
 
-@cli.group("config")
-def config_group():
-    """Inspect the resolved config."""
+def _print_config(config_paths, no_default_config, profile):
+    resolved_config, sources = _resolve_config(config_paths, no_default_config, profile)
+    for path, origin in sources:
+        chatter(f"{path} ({origin})", level="info")
+    if not sources:
+        chatter("no config files loaded", level="info")
+    click.echo(yaml.safe_dump(resolved_config, sort_keys=False), nl=False)
+
+
+@cli.group("config", invoke_without_command=True)
+@_add_config_options
+@click.pass_context
+def config_group(ctx, config_paths, no_default_config, profile):
+    """Inspect the resolved config (same as 'config show')."""
+    if ctx.invoked_subcommand is None:
+        _print_config(config_paths, no_default_config, profile)
+        return
+    default_map = {}
+    if config_paths:
+        default_map["config_paths"] = config_paths
+    if no_default_config:
+        default_map["no_default_config"] = no_default_config
+    if profile is not None:
+        default_map["profile"] = profile
+    ctx.default_map = {"show": default_map}
 
 
 @config_group.command("show")
 @_add_config_options
 def config_show(config_paths, no_default_config, profile):
-    """Print the merged effective config (stdout) and its sources (stderr)."""
-    resolved_config, sources = _resolve_config(config_paths, no_default_config, profile)
-    for path, origin in sources:
-        click.echo(f"[squarepeg] {path} ({origin})", err=True)
-    if not sources:
-        click.echo("[squarepeg] no config files loaded", err=True)
-    click.echo(yaml.safe_dump(resolved_config, sort_keys=False), nl=False)
+    """Print the merged effective config (stdout) and its sources (stderr). Same as bare 'config'."""
+    _print_config(config_paths, no_default_config, profile)
 
 
 def main():
@@ -337,7 +456,11 @@ def main():
     except click.exceptions.Exit as exc:
         raise SystemExit(exc.exit_code) from exc
     except SquarepegError as exc:
-        click.echo(f"squarepeg: {exc}", err=True)
+        click.echo(
+            click.style(f"squarepeg: {exc}", fg="red", bold=True),
+            err=True,
+            color=ui.color_enabled(),
+        )
         raise SystemExit(exc.exit_code) from exc
 
 

{squarepeg-0.1.0 → squarepeg-0.2.1}/squarepeg/k8s/events.py

@@ -16,4 +16,4 @@ def print_pod_events(session, pod_name: str, *, quiet: bool = False) -> None:
         return  # best-effort diagnostics; never fail the run because event listing failed
 
     for event in events.items or []:
-        chatter(f"{pod_name}: {event.reason}: {event.message}", quiet=quiet)
+        chatter(f"{pod_name}: {event.reason}: {event.message}", quiet=quiet, level="detail")

{squarepeg-0.1.0 → squarepeg-0.2.1}/squarepeg/k8s/logs.py

@@ -115,12 +115,13 @@ def stream_logs(session, pod_name: str, container_name: str, stop_event, *, quie
                     f"log stream for pod {pod_name!r} failed after {attempt - 1} reconnect attempts ({exc}); "
                     "still waiting for the pod to finish",
                     quiet=quiet,
+                    level="warn",
                 )
                 return
             if dedupe.last_ts is not None:
                 since_seconds = since_seconds_from(dedupe.last_ts)
             backoff = min(2**attempt, MAX_BACKOFF_SECONDS)
-            chatter(f"log stream for pod {pod_name!r} dropped, reconnecting in {backoff}s", quiet=quiet)
+            chatter(f"log stream for pod {pod_name!r} dropped, reconnecting in {backoff}s", quiet=quiet, level="warn")
             time.sleep(backoff)
         finally:
             response.close()

{squarepeg-0.1.0 → squarepeg-0.2.1}/squarepeg/k8s/orphans.py

@@ -191,8 +191,8 @@ def sweep_orphans(
             if delete_resource(session, kind, name):
                 deleted += 1
         except Exception as exc:  # one bad delete must not abort the rest of the sweep
-            chatter(f"orphan sweep: failed to delete {kind} {name!r}: {exc}", quiet=spec.quiet)
+            chatter(f"orphan sweep: failed to delete {kind} {name!r}: {exc}", quiet=spec.quiet, level="warn")
 
     if deleted:
-        chatter(f"swept {deleted} orphaned resource(s) from previous runs", quiet=spec.quiet)
+        chatter(f"swept {deleted} orphaned resource(s) from previous runs", quiet=spec.quiet, level="success")
     return deleted

{squarepeg-0.1.0 → squarepeg-0.2.1}/squarepeg/k8s/runner.py

@@ -8,6 +8,7 @@ import threading
 from kubernetes import watch
 from kubernetes.client.rest import ApiException
 
+from squarepeg import ui
 from squarepeg.errors import InterruptError, RunnerError
 from squarepeg.k8s.apierrors import delete_resource, wrap_api_exception
 from squarepeg.k8s.events import print_pod_events
@@ -21,9 +22,9 @@ from squarepeg.runspec import RunSpec
 # kept as module-level aliases: existing callers/tests referencing these names still work
 _wrap_api_exception = wrap_api_exception
 
-# how long a single watch call may block waiting for the pod to become terminal,
-# once it has already started; the loop simply re-watches if this elapses.
-TERMINAL_WATCH_POLL_SECONDS = 3600
+# how long a single watch call may block waiting for the pod to become terminal, once it
+# has already started; the loop simply re-watches if this elapses.
+TERMINAL_WATCH_POLL_SECONDS = 5
 
 
 def create_resource(session, spec: RunSpec, manifest: dict) -> None:
@@ -48,13 +49,17 @@ def discover_job_pod(session, job_name: str, timeout: int) -> str:
         ):
             return event["object"].metadata.name
     except ApiException as exc:
-        raise _wrap_api_exception(exc, f"failed to watch for the pod created by job {job_name!r}") from exc
+        raise _wrap_api_exception(
+            exc, f"failed to watch for the pod created by job {job_name!r}"
+        ) from exc
     finally:
         watcher.stop()
     raise RunnerError(f"timed out waiting for job {job_name!r} to create a pod")
 
 
-def wait_until_running_or_terminal(session, pod_name: str, timeout: int, *, quiet: bool = False) -> str:
+def wait_until_running_or_terminal(
+    session, pod_name: str, timeout: int, *, quiet: bool = False
+) -> str:
     """Wait until the pod is Running/Succeeded/Failed, or fail fast on a known-bad waiting reason.
 
     This bounds only the *startup* window (image pull, scheduling, container create); once the
@@ -81,17 +86,23 @@ def _watch_for_start(session, pod_name: str, timeout: int) -> str:
             for cs in pod.status.container_statuses or []:
                 waiting = cs.state.waiting
                 if waiting is not None and waiting.reason in FAIL_FAST_REASONS:
-                    raise RunnerError(f"container failed to start ({waiting.reason}): {waiting.message}")
+                    raise RunnerError(
+                        f"container failed to start ({waiting.reason}): {waiting.message}"
+                    )
             if phase in ("Running", "Succeeded", "Failed"):
                 return phase
     except ApiException as exc:
         raise _wrap_api_exception(exc, f"failed to watch pod {pod_name!r}") from exc
     finally:
         watcher.stop()
-    raise RunnerError(f"timed out after {timeout}s waiting for pod {pod_name!r} to start")
+    raise RunnerError(
+        f"timed out after {timeout}s waiting for pod {pod_name!r} to start"
+    )
 
 
-def wait_for_terminal(session, pod_name: str, stop_event: threading.Event) -> str | None:
+def wait_for_terminal(
+    session, pod_name: str, stop_event: threading.Event
+) -> str | None:
     """Wait, with no overall timeout, until the pod is Succeeded/Failed, or stop_event is set."""
     while not stop_event.is_set():
         watcher = watch.Watch()
@@ -115,7 +126,9 @@ def wait_for_terminal(session, pod_name: str, stop_event: threading.Event) -> st
     return None
 
 
-def extract_exit_code(session, pod_name: str, container_name: str) -> tuple[int, str | None]:
+def extract_exit_code(
+    session, pod_name: str, container_name: str
+) -> tuple[int, str | None]:
     try:
         pod = session.core.read_namespaced_pod(pod_name, session.namespace)
     except ApiException as exc:
@@ -164,9 +177,12 @@ class _InterruptHandler:
             chatter(
                 f"interrupted; cleaning up {self.mode} {self.name!r} (press Ctrl+C again to leave it running)",
                 quiet=self.quiet,
+                level="warn",
             )
         else:
-            chatter(f"leaving {self.mode} {self.name!r} running", quiet=False)
+            chatter(
+                f"leaving {self.mode} {self.name!r} running", quiet=False, level="warn"
+            )
 
     @property
     def interrupted(self) -> bool:
@@ -184,10 +200,39 @@ def run_manifest(session, spec: RunSpec, manifest: dict) -> int:
     with _InterruptHandler(name, spec.mode, spec.quiet) as handler:
         log_thread = None
         try:
-            create_resource(session, spec, manifest)
-            pod_name = discover_job_pod(session, name, spec.timeout) if spec.mode == "job" else name
+            with ui.Status(
+                f"creating {spec.mode} {name!r} in namespace {session.namespace!r}",
+                quiet=spec.quiet,
+            ):
+                create_resource(session, spec, manifest)
+
+            if spec.mode == "job":
+                with ui.Status(
+                    f"waiting for job {name!r} to create a pod",
+                    quiet=spec.quiet,
+                    slow_hint="the job controller has not produced a pod yet",
+                    slow_after=15,
+                ):
+                    pod_name = discover_job_pod(session, name, spec.timeout)
+            else:
+                pod_name = name
+
+            with ui.Status(
+                f"waiting for pod {pod_name!r} to start",
+                quiet=spec.quiet,
+                slow_hint="still scheduling or pulling the image; a cold pull of a large image can take a while",
+                slow_after=20,
+                spinner_delay=0.0,
+            ):
+                phase = wait_until_running_or_terminal(
+                    session, pod_name, spec.timeout, quiet=spec.quiet
+                )
 
-            phase = wait_until_running_or_terminal(session, pod_name, spec.timeout, quiet=spec.quiet)
+            chatter(
+                f"streaming logs from pod {pod_name!r} (waiting for it to finish; Ctrl+C to stop)",
+                quiet=spec.quiet,
+                level="step",
+            )
 
             log_thread = threading.Thread(
                 target=stream_logs,
@@ -206,28 +251,51 @@ def run_manifest(session, spec: RunSpec, manifest: dict) -> int:
             # truncate output for fast-exiting containers.
             log_thread.join(timeout=30)
             if log_thread.is_alive():
-                chatter(f"log stream for pod {pod_name!r} did not finish on its own; stopping it", quiet=spec.quiet)
+                chatter(
+                    f"log stream for pod {pod_name!r} did not finish on its own; stopping it",
+                    quiet=spec.quiet,
+                    level="warn",
+                )
                 handler.stop_event.set()
                 log_thread.join(timeout=5)
 
             if handler.interrupted:
                 raise InterruptError(f"interrupted while running {spec.mode} {name!r}")
 
-            exit_code, reason = extract_exit_code(session, pod_name, spec.container_name)
+            exit_code, reason = extract_exit_code(
+                session, pod_name, spec.container_name
+            )
             if reason == "OOMKilled":
-                chatter(f"container was OOMKilled (exit code {exit_code})", quiet=spec.quiet)
+                chatter(
+                    f"container was OOMKilled (exit code {exit_code})",
+                    quiet=spec.quiet,
+                    level="error",
+                )
             return exit_code
         finally:
             handler.stop_event.set()
             if log_thread is not None:
                 log_thread.join(timeout=2)
             if spec.cleanup and not handler.abandoned:
-                cleanup(session, spec, name)
+                with ui.Status(f"deleting {spec.mode} {name!r}", quiet=spec.quiet):
+                    cleanup(session, spec, name)
             elif not handler.abandoned and not spec.quiet:
-                chatter(f"kept {spec.mode} {name!r}; inspect with 'kubectl describe {spec.mode} {name}'", quiet=False)
+                chatter(
+                    f"kept {spec.mode} {name!r}; inspect with 'kubectl describe {spec.mode} {name}'",
+                    quiet=False,
+                    level="warn",
+                )
             if spec.orphan_sweep and not handler.abandoned:
-                own_run_id = manifest.get("metadata", {}).get("labels", {}).get(RUN_ID_LABEL)
+                own_run_id = (
+                    manifest.get("metadata", {}).get("labels", {}).get(RUN_ID_LABEL)
+                )
                 try:
-                    sweep_orphans(session, spec, exclude_run_id=own_run_id)
+                    with ui.Status(
+                        "sweeping orphaned resources from previous runs",
+                        quiet=spec.quiet,
+                    ):
+                        sweep_orphans(session, spec, exclude_run_id=own_run_id)
                 except Exception as exc:
-                    chatter(f"orphan sweep skipped: {exc}", quiet=spec.quiet)
+                    chatter(
+                        f"orphan sweep skipped: {exc}", quiet=spec.quiet, level="warn"
+                    )

squarepeg-0.2.1/squarepeg/log.py

@@ -0,0 +1,5 @@
+from squarepeg import ui
+
+
+def chatter(message: str, *, quiet: bool = False, level: ui.Level = "info") -> None:
+    ui.emit(message, level=level, quiet=quiet)