dirigent-cli 0.20.0__tar.gz → 0.22.0__tar.gz

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: dirigent-cli
-Version: 0.20.0
+Version: 0.22.0
 Summary: The dirigent command line interface (dirigent / dg).
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: dirigent-block-execute==0.20.0
-Requires-Dist: dirigent-blocks==0.20.0
-Requires-Dist: dirigent-client==0.20.0
-Requires-Dist: dirigent-common==0.20.0
-Requires-Dist: dirigent-core==0.20.0
-Requires-Dist: dirigent-examples==0.20.0
-Requires-Dist: dirigent-plugin==0.20.0
-Requires-Dist: dirigent-server==0.20.0
+Requires-Dist: dirigent-block-execute==0.22.0
+Requires-Dist: dirigent-blocks==0.22.0
+Requires-Dist: dirigent-client==0.22.0
+Requires-Dist: dirigent-common==0.22.0
+Requires-Dist: dirigent-core==0.22.0
+Requires-Dist: dirigent-examples==0.22.0
+Requires-Dist: dirigent-plugin==0.22.0
+Requires-Dist: dirigent-server==0.22.0
 Requires-Dist: httpx2>=2.12.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: pyyaml>=6.0.3

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-cli"
-version = "0.20.0"
+version = "0.22.0"
 description = "The dirigent command line interface (dirigent / dg)."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -11,14 +11,14 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-block-execute==0.20.0",
-    "dirigent-blocks==0.20.0",
-    "dirigent-client==0.20.0",
-    "dirigent-common==0.20.0",
-    "dirigent-core==0.20.0",
-    "dirigent-examples==0.20.0",
-    "dirigent-plugin==0.20.0",
-    "dirigent-server==0.20.0",
+    "dirigent-block-execute==0.22.0",
+    "dirigent-blocks==0.22.0",
+    "dirigent-client==0.22.0",
+    "dirigent-common==0.22.0",
+    "dirigent-core==0.22.0",
+    "dirigent-examples==0.22.0",
+    "dirigent-plugin==0.22.0",
+    "dirigent-server==0.22.0",
     "httpx2>=2.12.0",
     "python-dotenv>=1.1.0",
     "pyyaml>=6.0.3",

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-cli"
-version = "0.20.0"
+version = "0.22.0"
 description = "The dirigent command line interface (dirigent / dg)."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -11,14 +11,14 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "dirigent-block-execute==0.20.0",
-    "dirigent-blocks==0.20.0",
-    "dirigent-client==0.20.0",
-    "dirigent-common==0.20.0",
-    "dirigent-core==0.20.0",
-    "dirigent-examples==0.20.0",
-    "dirigent-plugin==0.20.0",
-    "dirigent-server==0.20.0",
+    "dirigent-block-execute==0.22.0",
+    "dirigent-blocks==0.22.0",
+    "dirigent-client==0.22.0",
+    "dirigent-common==0.22.0",
+    "dirigent-core==0.22.0",
+    "dirigent-examples==0.22.0",
+    "dirigent-plugin==0.22.0",
+    "dirigent-server==0.22.0",
     "httpx2>=2.12.0",
     "python-dotenv>=1.1.0",
     "pyyaml>=6.0.3",

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/commands.py

@@ -86,8 +86,10 @@ from dirigent_cli.messages import (
 )
 from dirigent_cli.messages import WINDOW_GRAMMAR as WINDOW_GRAMMAR_MESSAGE
 from dirigent_cli.output import (
+    CONNECTION_HEALTH,
     Detail,
     age,
+    connection_health,
     console,
     elapsed,
     emit_event,
@@ -350,7 +352,9 @@ def apply_command(
     as_code: Annotated[str | None, typer.Option("--as", help="Register under a different code.")] = None,
     paused: Annotated[
         bool,
-        typer.Option("--paused", help="Create the schedules this apply mints paused; existing ones are untouched."),
+        typer.Option(
+            "--paused", help="Create the schedules and watches this apply mints paused; existing ones are untouched."
+        ),
     ] = False,
     prune: Annotated[
         bool,
@@ -2433,7 +2437,7 @@ def connection_check(ctx: typer.Context, code: Annotated[str, typer.Argument()])
         report = dg.call(dg.connections.check(code))
     emit_fact(
         "connection.checked",
-        message="not verified" if report.healthy is None else "healthy" if report.healthy else "unhealthy",
+        message=CONNECTION_HEALTH[connection_health(report.healthy)],
         code=code,
         healthy=report.healthy,
         detail=report.detail,

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/context.py

@@ -143,4 +143,11 @@ class Session(BlockingDirigent):
 def client_for(state: CliState, *, needs_token: bool = True) -> Session:
     """Build the API client for a resolved endpoint."""
     endpoint = state.endpoint(needs_token=needs_token)
-    return Session(url=endpoint.url, token=endpoint.token, api_prefix=endpoint.api_prefix)
+    return Session(
+        url=endpoint.url,
+        token=endpoint.token,
+        api_prefix=endpoint.api_prefix,
+        timeout=endpoint.timeout.total_seconds(),
+        connect_timeout=endpoint.connect_timeout.total_seconds(),
+        retries=endpoint.retries,
+    )

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/explain.py

@@ -7,9 +7,10 @@ under a deadline. What only the run can decide -- a parameter supplied at the co
 a window's bounds -- is reported as unknown rather than guessed at, and a total that counted
 one of those says so.
 
-The cardinality rules are :func:`dirigent_core.engine.runs.resolve_fan_out`'s: a literal list
-is its own length, ``${steps.<name>.items}`` adopts another fan-out's grid, a reference that
-resolves to a list is that list, and anything else is only the run's to answer.
+The cardinality rules are the engine's: a literal list is its own length,
+``${steps.<name>.items}`` adopts another fan-out's grid, a reference that resolves to a list is
+that list, one that reads a step's output is as wide as that step makes it while the run
+executes, and anything else is only the run's to answer.
 """
 
 from collections.abc import Mapping, Sequence
@@ -31,6 +32,9 @@ UNKNOWN: Final = "unknown"
 #: How a cardinality names the fan-out whose grid a step maps over instead of its own.
 ADOPTS: Final = "adopts {step}"
 
+#: How a cardinality names the step whose output a late grid is expanded from.
+LATE: Final = "from {step}"
+
 
 class DocumentShape(BaseModel):
     """What a whole document will cost: the steps, the totals over them, and the warnings."""
@@ -61,7 +65,7 @@ def explain(definition: PipelineDefinition, catalog: Catalog | None = None) -> D
     order = definition.topological_order()
     shapes: dict[str, StepShape] = {}
     for name in order:
-        shapes[name] = _step_shape(name, definition.steps[name], params, shapes, catalog)
+        shapes[name] = _step_shape(name, definition.steps[name], params, shapes, catalog, definition.grid_source(name))
     rows = [shapes[name] for name in order]
     return DocumentShape(
         attempts_max=sum(row.max_attempts * (1 if row.elements is None else row.elements) for row in rows),
@@ -90,9 +94,13 @@ def _step_shape(
     params: JsonMap,
     done: Mapping[str, StepShape],
     catalog: Catalog | None,
+    source: str | None,
 ) -> StepShape:
-    """Read one step as the work it will become, against the steps already read."""
-    cardinality, elements = _cardinality(step, params, done)
+    """Read one step as the work it will become, against the steps already read.
+
+    ``source`` is the step a late grid waits for, which the row names.
+    """
+    cardinality, elements = _cardinality(step, params, done, source)
     poll, deadline, from_block = _waits(step, _entry(step, catalog))
     return StepShape(
         name=name,
@@ -100,6 +108,7 @@ def _step_shape(
         depends_on=list(step.depends_on),
         cardinality=cardinality,
         elements=elements,
+        grid_source=source,
         reference=step.for_each if isinstance(step.for_each, str) else None,
         items=step.items.value,
         max_attempts=step.retry.max_attempts,
@@ -112,7 +121,9 @@ def _step_shape(
     )
 
 
-def _cardinality(step: StepDefinition, params: JsonMap, done: Mapping[str, StepShape]) -> tuple[int | str, int | None]:
+def _cardinality(
+    step: StepDefinition, params: JsonMap, done: Mapping[str, StepShape], source: str | None
+) -> tuple[int | str, int | None]:
     """Say how many run items a step becomes, and the count behind that where there is one."""
     expression = step.for_each
     if expression is None:
@@ -123,10 +134,8 @@ def _cardinality(step: StepDefinition, params: JsonMap, done: Mapping[str, StepS
     if adopted is not None:
         upstream = done[adopted].elements if adopted in done else None
         return ADOPTS.format(step=adopted), upstream
-    if "steps." in expression:
-        # resolve_fan_out refuses a step's output here, because cardinality is fixed when the
-        # run is created and no step has run by then.
-        return UNKNOWN, None
+    if source is not None:
+        return LATE.format(step=source), None
     try:
         resolved = resolve(expression, ReferenceScope(params=params))
     except UnknownReference:
@@ -202,6 +211,17 @@ def _warnings(rows: Sequence[StepShape], catalog: Catalog | None) -> list[ShapeW
                     ),
                 )
             )
+        if row.grid_source is not None and row.cardinality == LATE.format(step=row.grid_source):
+            found.append(
+                ShapeWarning(
+                    step=row.name,
+                    cause="late-cardinality",
+                    message=(
+                        f"{row.name} fans out over {row.reference}, which {row.grid_source} produces while "
+                        f"the run executes, so it is counted as one item here."
+                    ),
+                )
+            )
         if row.retry_wait is not None and row.deadline is not None and row.retry_wait > row.deadline:
             found.append(
                 ShapeWarning(

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/local.py

@@ -645,7 +645,8 @@ async def run_document(
                 async with session_scope(sessions) as session:
                     await _apply_supporting(session, services, extra_definition)
             async with session_scope(sessions) as session:
-                applied = await apply_document(session, services, definition)
+                # Triggers land paused: the instance runs only the run it was asked for.
+                applied = await apply_document(session, services, definition, pause_schedules=True)
                 if not applied.plan.ok:
                     raise LocalError(
                         "the document does not validate against the installed catalog:\n"
@@ -697,8 +698,8 @@ def _parse_supporting(text: str) -> PipelineDefinition:
 
 
 async def _apply_supporting(session: AsyncSession, services: EngineServices, supporting: PipelineDefinition) -> None:
-    """Apply one document a run depends on, without running it."""
-    applied = await apply_document(session, services, supporting)
+    """Apply one document a run depends on, without running it or arming its triggers."""
+    applied = await apply_document(session, services, supporting, pause_schedules=True)
     if not applied.plan.ok:
         raise LocalError(
             f"the supporting document {supporting.code!r} does not validate:\n"

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/main.py

@@ -50,7 +50,7 @@ from dirigent_cli.messages import (
 )
 from dirigent_cli.output import configure, detail_mode, emit_fact, emit_problem, emit_rendered, refuse
 from dirigent_client.enums import UserRole
-from dirigent_common import Issue
+from dirigent_common import Issue, raised_detail, validation_issues
 from dirigent_core import migrations
 from dirigent_core.config import STATE_DIR, Settings, get_settings, redacted_url, reset_settings_cache
 from dirigent_core.logging import configure_logging, silence_stdout
@@ -127,6 +127,7 @@ app.add_typer(commands.schema_app, rich_help_panel=DEFINE_PANEL)
 app.add_typer(commands.connection_app, rich_help_panel=CONNECT_PANEL)
 app.add_typer(triggers.schedule_app, rich_help_panel=TRIGGER_PANEL)
 app.add_typer(triggers.webhook_app, rich_help_panel=TRIGGER_PANEL)
+app.add_typer(triggers.watch_app, rich_help_panel=TRIGGER_PANEL)
 app.add_typer(triggers.trigger_document_app, rich_help_panel=TRIGGER_PANEL)
 app.add_typer(triggers.alerts_app, rich_help_panel=TRIGGER_PANEL)
 app.add_typer(docker_app, rich_help_panel=PROCESS_PANEL)
@@ -401,7 +402,7 @@ async def _ensure_container(settings: Settings) -> "ContainerResult":
     except DomainError as error:
         commands.fail(STORE_UNCONFIGURED, root=settings.artifact_root, detail=str(error))
     except Exception as error:
-        commands.fail(STORE_UNREACHABLE, root=settings.artifact_root, detail=f"{type(error).__name__}: {error}")
+        commands.fail(STORE_UNREACHABLE, root=settings.artifact_root, detail=raised_detail(error))
     finally:
         await engine.dispose()
 
@@ -442,7 +443,12 @@ def connection_ensure(
     except ValidationError as error:
         # include_input=False: the input here is a credential, and pydantic's default error
         # payload echoes the value that failed.
-        commands.fail(CONNECTION_UNUSABLE, code=code, kind=kind_id, detail=str(error.errors(include_input=False)))
+        commands.fail(
+            CONNECTION_UNUSABLE,
+            code=code,
+            kind=kind_id,
+            problems=validation_issues(error.errors(include_input=False)),
+        )
     key = settings.secret_key.get_secret_value() if settings.secret_key else None
     try:
         public, envelope, key_id = SecretBox(key).encrypt_config(model, validated)
@@ -911,7 +917,7 @@ def dev(
         typer.Option(
             "--seed",
             help="Apply every dirigent/v1 document under this directory once the API answers, "
-            "with its schedules paused; name it more than once to seed one directory after another.",
+            "with its schedules and watches paused; name it more than once to seed one directory after another.",
         ),
     ] = None,
     seed_installed: Annotated[
@@ -934,7 +940,7 @@ def dev(
 
     --seed fills the instance from a directory of documents the moment it answers: the
     connections a file or a document declares are created first, then every document is
-    applied with its schedules paused. A document an instance will not store is reported
+    applied with its schedules and watches paused. A document an instance will not store is reported
     and passed over, because a corpus holds those on purpose.
     """
     import asyncio

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/messages.py

@@ -25,7 +25,7 @@ RUN_DB_UPGRADE = CLI.define("run_db_upgrade", "run dg db upgrade")
 
 UNKNOWN_CONNECTION_KIND = CLI.define("unknown_connection_kind", "no connection kind {kind} is installed ({known})")
 
-CONNECTION_UNUSABLE = CLI.define("connection_unusable", "{code} is not a usable {kind} connection: {detail}")
+CONNECTION_UNUSABLE = CLI.define("connection_unusable", "{code} is not a usable {kind} connection")
 
 INVALID_AGE = CLI.define("invalid_age", "{detail}")
 
@@ -189,6 +189,15 @@ SCHEMA_NOT_AN_OBJECT = CLI.define(
     "{label} is not a JSON Schema: a schema is an object, and this is {kind}",
 )
 
+# What a profile refuses at validation. Pydantic owns the code a validator's refusal reaches
+# the wire under, so this is rendered into the ``ValueError`` it wraps.
+
+PROFILE_NAMES_A_DATABASE = CLI.define(
+    "profile_names_a_database",
+    "profile {name} names a database URL. Profiles address a server over HTTP; "
+    "a database URL belongs in DIRIGENT_DATABASE_URL on the host that runs it",
+)
+
 NOT_AUTHENTICATED = CLI.define("not_authenticated", "no token for {url}")
 
 SET_DG_TOKEN = CLI.define("set_dg_token", "set DG_TOKEN")

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/output.py

@@ -474,16 +474,24 @@ def prioritised(priority: object) -> str:
             return ""
 
 
+#: The floor an alert rule fires at, said beside its scope. The web UI writes this half in the
+#: same words out of its own catalogue, and `tests/test_shared_words.py` holds the two together.
+IMPORTANCE_FLOOR = "{importance} and above"
+
+
 def watching(scope: object, importance: object) -> str:
     """What an alert rule watches, in one cell: its scope, and the floor it fires at.
 
     Almost every rule names no importance, so a column of its own would mostly be empty.
     """
-    return f"{scope}, {importance} and above" if importance else str(scope)
+    if not importance:
+        return str(scope)
+    return f"{scope}, {IMPORTANCE_FLOOR.format(importance=importance)}"
 
 
 #: What each alert event is called in a rendering. The wire's word is what a rule is declared
-#: with; these are the words a reader is shown, here and on the web UI's own listing.
+#: with; these are the words a reader is shown. The web UI draws the same four out of its own
+#: catalogue, and `tests/test_shared_words.py` fails when the two tables stop agreeing.
 ALERT_EVENTS: Mapping[str, str] = {
     "run_failed": "Failed",
     "run_completed_with_errors": "Completed with errors",
@@ -529,17 +537,39 @@ def render_bool(value: object) -> str:
     return "[green]yes[/]" if value else "[dim]no[/]"
 
 
+#: What a connection's last check is called, keyed by the state the web UI keys it by. A
+#: credential's health is one vocabulary across the product, so these are the bundle's own four
+#: words and `tests/test_shared_words.py` fails when the two tables stop agreeing.
+CONNECTION_HEALTH: Mapping[str, str] = {
+    "unchecked": "never checked",
+    "unverified": "not verified",
+    "healthy": "healthy",
+    "failed": "failed",
+}
+
+
+def connection_health(healthy: object) -> str:
+    """Say which state a check that ran left a connection in.
+
+    Args:
+        healthy: What the check decided, or None where the kind publishes no check.
+
+    Returns:
+        The key into `CONNECTION_HEALTH`.
+    """
+    if healthy is None:
+        return "unverified"
+    return "healthy" if healthy else "failed"
+
+
 def render_check(last_check_at: object, healthy: object) -> str:
     """Render what a connection's last check said, across the four states a row can be in.
 
-    A check answers yes, no, or that it could not decide; a row nothing has checked answers
-    none of the three.
+    A check answers that the system is there, that it is not, or that the kind publishes no
+    check at all; a row nothing has ever asked is in none of the three.
     """
-    if not last_check_at:
-        return "-"
-    if healthy is None:
-        return "[dim]not verified[/]"
-    return "[green]yes[/]" if healthy else "[dim]no[/]"
+    state = connection_health(healthy) if last_check_at else "unchecked"
+    return f"[{STATUS_STYLES.get(state, 'dim')}]{CONNECTION_HEALTH[state]}[/]"
 
 
 def moment(value: object) -> str:

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/profiles.py

@@ -1,13 +1,14 @@
-"""Profiles: which server the CLI talks to, and how it gets a token for it.
+"""Profiles: which server the CLI talks to, how it gets a token for it, and how patient it is.
 
-A profile is client-side addressing only and must never hold a database URL: a CLI that
-could reach the database would bypass authentication, attribution, and validation.
+A profile is client-side only and must never hold a database URL: a CLI that could reach the
+database would bypass authentication, attribution, and validation.
 """
 
 import os
 import shutil
 import subprocess
 from collections.abc import Mapping
+from datetime import timedelta
 from pathlib import Path
 from typing import Any, Final, cast
 
@@ -15,8 +16,9 @@ import yaml
 from dotenv import dotenv_values
 from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
 
-from dirigent_client import API_PREFIX
-from dirigent_common import EntityName
+from dirigent_cli.messages import PROFILE_NAMES_A_DATABASE
+from dirigent_client import API_PREFIX, DEFAULT_CONNECT_TIMEOUT, DEFAULT_RETRIES, DEFAULT_TIMEOUT
+from dirigent_common import Duration, EntityName
 
 PROJECT_PROFILES: Final = Path(".dirigent") / "profiles.yaml"
 PROJECT_ENV_FILE: Final = ".env"
@@ -32,13 +34,16 @@ DATABASE_SCHEMES: Final = ("postgresql", "postgres", "sqlite", "mysql")
 
 TOKEN_COMMAND_TIMEOUT: Final = 30.0
 
+DEFAULT_REQUEST_TIMEOUT: Final = timedelta(seconds=DEFAULT_TIMEOUT)
+DEFAULT_CONNECT_BUDGET: Final = timedelta(seconds=DEFAULT_CONNECT_TIMEOUT)
+
 
 class ProfileError(Exception):
     """A profile could not be read, found, or turned into a usable token."""
 
 
 class Profile(BaseModel):
-    """One named server and how to obtain a token for it."""
+    """One named server, how to obtain a token for it, and how long to wait on it."""
 
     model_config = ConfigDict(frozen=True)
 
@@ -53,15 +58,21 @@ class Profile(BaseModel):
     api_prefix: str = API_PREFIX
     """Where this instance serves its API, for one configured with a different prefix."""
 
+    timeout: Duration = DEFAULT_REQUEST_TIMEOUT
+    """How long a request to this instance may take to answer."""
+
+    connect_timeout: Duration = DEFAULT_CONNECT_BUDGET
+    """How long reaching this instance may take before it is called unreachable."""
+
+    retries: int = Field(default=DEFAULT_RETRIES, ge=0)
+    """How many further attempts a lost or refused-with-a-5xx request gets."""
+
     @model_validator(mode="after")
     def _refuse_a_database_url(self) -> "Profile":
         """Refuse a profile pointing at a database rather than at an API."""
         scheme = self.url.split("://", 1)[0].split("+", 1)[0].lower()
         if scheme in DATABASE_SCHEMES:
-            raise ValueError(
-                f"profile {self.name!r} names a database URL. Profiles address a server over HTTP; "
-                f"a database URL belongs in DIRIGENT_DATABASE_URL on the host that runs it"
-            )
+            raise ValueError(PROFILE_NAMES_A_DATABASE.render(name=repr(self.name)))
         return self
 
     def resolve_token(self, environ: Mapping[str, str] | None = None) -> str | None:
@@ -193,6 +204,9 @@ class Endpoint(BaseModel):
     profile: str | None = None
     source: str = "default"
     api_prefix: str = API_PREFIX
+    timeout: Duration = DEFAULT_REQUEST_TIMEOUT
+    connect_timeout: Duration = DEFAULT_CONNECT_BUDGET
+    retries: int = DEFAULT_RETRIES
 
 
 def resolve_endpoint(
@@ -236,4 +250,7 @@ def resolve_endpoint(
         profile=chosen.name if chosen else None,
         source=source,
         api_prefix=chosen.api_prefix if chosen else API_PREFIX,
+        timeout=chosen.timeout if chosen else DEFAULT_REQUEST_TIMEOUT,
+        connect_timeout=chosen.connect_timeout if chosen else DEFAULT_CONNECT_BUDGET,
+        retries=chosen.retries if chosen else DEFAULT_RETRIES,
     )

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/schemas.py

@@ -65,11 +65,14 @@ class StepShape(BaseModel):
     depends_on: list[str] = Field(default_factory=list[str])
 
     cardinality: int | str = 1
-    """How many run items this step becomes: a count, ``adopts <step>``, or ``unknown``."""
+    """How many run items this step becomes: a count, ``adopts <step>``, ``from <step>``, or ``unknown``."""
 
     elements: int | None = 1
     """The count behind the cardinality, which an adoption takes from the grid it adopts."""
 
+    grid_source: str | None = None
+    """The step a late grid waits for before it expands, or null for a grid fixed at creation."""
+
     reference: str | None = None
     """The ``for_each`` this step maps over, where it names one rather than listing it."""
 

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/seeding.py

@@ -136,7 +136,7 @@ async def _connection(client: Dirigent, spec: ConnectionSpec) -> str:
 
 
 async def _apply(client: Dirigent, raw: JsonMap, origin: str) -> Record:
-    """Apply one document with its schedules paused, without the sections it carries."""
+    """Apply one document with its schedules and watches paused, without the sections it carries."""
     document = {name: value for name, value in raw.items() if name not in CARRIED}
     try:
         result = await client.pipelines.apply(
@@ -157,6 +157,7 @@ async def _apply(client: Dirigent, raw: JsonMap, origin: str) -> Record:
         pipeline=result.plan.code,
         action=result.plan.action.value,
         schedules_paused=result.triggers.schedules_created,
+        watches_paused=result.triggers.watches_created,
     )
 
 

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/sources.py

@@ -8,10 +8,13 @@ import httpx2
 import yaml
 from pydantic import BaseModel, ConfigDict
 
+from dirigent_client import DEFAULT_CONNECT_TIMEOUT
 from dirigent_client.enums import ProvenanceSource
 
 STDIN: Final = "-"
-FETCH_TIMEOUT: Final = 30.0
+
+#: The body may take thirty seconds to arrive, and reaching the host that serves it two.
+FETCH_TIMEOUT: Final = httpx2.Timeout(30.0, connect=DEFAULT_CONNECT_TIMEOUT)
 
 
 class SourceError(Exception):

{dirigent_cli-0.20.0 → dirigent_cli-0.22.0}/src/dirigent_cli/triggers.py

@@ -1,4 +1,4 @@
-"""The trigger and alerting command groups: schedules, webhooks, and alert rules."""
+"""The trigger and alerting command groups: schedules, webhooks, watches, and alert rules."""
 
 from pathlib import Path
 from typing import Annotated, Any, cast
@@ -35,6 +35,11 @@ schedule_app = typer.Typer(
     name="schedule", help="A pipeline's clocks: cron, interval, or one-time.", no_args_is_help=True
 )
 webhook_app = typer.Typer(name="webhook", help="Inbound webhooks and their delivery history.", no_args_is_help=True)
+watch_app = typer.Typer(
+    name="watch",
+    help="Sensors kept waiting: one run always waiting on each, the next armed on success.",
+    no_args_is_help=True,
+)
 trigger_document_app = typer.Typer(
     name="trigger-document",
     help="Documents that declare clocks for a pipeline defined elsewhere.",
@@ -246,6 +251,60 @@ def schedule_delete(
     emit_fact("schedule.deleted", message="deleted", code=code, pipeline=pipeline)
 
 
+@watch_app.command("list")
+def watch_list(
+    ctx: typer.Context,
+    pipeline: Annotated[str, typer.Argument(help="The pipeline whose watches to list.")],
+) -> None:
+    """List a pipeline's watches, each with the run it has waiting and how its waits are going."""
+    with client_for(state_of(ctx)) as dg:
+        rows = list(paged(lambda after, size: dg.call(dg.watches.list(pipeline, after=after, limit=size)), None))
+    emit_records("watch", rows)
+
+
+@watch_app.command("show")
+def watch_show(
+    ctx: typer.Context,
+    pipeline: Annotated[str, typer.Argument(help="The pipeline the watch belongs to.")],
+    code: Annotated[str, typer.Argument(help="The watch to show.")],
+) -> None:
+    """Show one watch: the step it waits on, where it left off, and its last error."""
+    with client_for(state_of(ctx)) as dg:
+        row = dg.call(dg.watches.get(pipeline, code))
+    emit_one("watch", row)
+
+
+@watch_app.command("pause")
+def watch_pause(
+    ctx: typer.Context,
+    pipeline: Annotated[str, typer.Argument()],
+    code: Annotated[str, typer.Argument()],
+) -> None:
+    """Stop a watch, cancelling the run it has waiting, and keep where it left off."""
+    with client_for(state_of(ctx)) as dg:
+        row = dg.call(dg.watches.pause(pipeline, code))
+    emit_fact("watch.paused", message="paused", code=code, pipeline=pipeline, cursor=row.cursor)
+
+
+@watch_app.command("resume")
+def watch_resume(
+    ctx: typer.Context,
+    pipeline: Annotated[str, typer.Argument()],
+    code: Annotated[str, typer.Argument()],
+) -> None:
+    """Start a watch again, arming a run from where its last success left off."""
+    with client_for(state_of(ctx)) as dg:
+        row = dg.call(dg.watches.resume(pipeline, code))
+    emit_fact(
+        "watch.resumed",
+        message="resumed",
+        code=code,
+        pipeline=pipeline,
+        waiting_run_id=row.waiting_run_id,
+        cursor=row.cursor,
+    )
+
+
 def _print_token(minted: WebhookTokenOut, *, base_url: str) -> None:
     """Print a minted token once, with the URL already assembled.
 
@@ -621,7 +680,7 @@ def trigger_document_show(
     ctx: typer.Context,
     code: Annotated[str, typer.Argument(help="The triggers document to read.")],
 ) -> None:
-    """Show one triggers document and the schedules and webhooks it owns."""
+    """Show one triggers document and the schedules, webhooks and watches it owns."""
     with client_for(state_of(ctx)) as dg:
         detail = dg.call(dg.trigger_documents.get(code))
     if state_of(ctx).json_output:
@@ -631,6 +690,7 @@ def trigger_document_show(
     console.print(f"  digest    [dim]{detail.digest}[/]")
     console.print(f"  schedules {', '.join(detail.schedules) or '-'}")
     console.print(f"  webhooks  {', '.join(detail.webhooks) or '-'}")
+    console.print(f"  watches   {', '.join(detail.watches) or '-'}")
     if detail.description:
         console.print(f"\n{detail.description}")
 
@@ -643,7 +703,14 @@ def trigger_document_delete(
     """Remove a triggers document and every schedule and webhook it declared."""
     with client_for(state_of(ctx)) as dg:
         dg.call(dg.trigger_documents.delete(code))
-    emit_fact("trigger_document.deleted", message="deleted", code=code, schedules="deleted", webhooks="deleted")
+    emit_fact(
+        "trigger_document.deleted",
+        message="deleted",
+        code=code,
+        schedules="deleted",
+        webhooks="deleted",
+        watches="deleted",
+    )
 
 
 @alerts_app.command("retry")