dirigent-cli 0.21.0__tar.gz → 0.23.0__tar.gz

{dirigent_cli-0.21.0 → dirigent_cli-0.23.0}/PKG-INFO

@@ -1,19 +1,19 @@
 Metadata-Version: 2.4
 Name: dirigent-cli
-Version: 0.21.0
+Version: 0.23.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.21.0
-Requires-Dist: dirigent-blocks==0.21.0
-Requires-Dist: dirigent-client==0.21.0
-Requires-Dist: dirigent-common==0.21.0
-Requires-Dist: dirigent-core==0.21.0
-Requires-Dist: dirigent-examples==0.21.0
-Requires-Dist: dirigent-plugin==0.21.0
-Requires-Dist: dirigent-server==0.21.0
+Requires-Dist: dirigent-block-execute==0.23.0
+Requires-Dist: dirigent-blocks==0.23.0
+Requires-Dist: dirigent-client==0.23.0
+Requires-Dist: dirigent-common==0.23.0
+Requires-Dist: dirigent-core==0.23.0
+Requires-Dist: dirigent-examples==0.23.0
+Requires-Dist: dirigent-plugin==0.23.0
+Requires-Dist: dirigent-server==0.23.0
 Requires-Dist: httpx2>=2.12.0
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: pyyaml>=6.0.3

{dirigent_cli-0.21.0 → dirigent_cli-0.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-cli"
-version = "0.21.0"
+version = "0.23.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.21.0",
-    "dirigent-blocks==0.21.0",
-    "dirigent-client==0.21.0",
-    "dirigent-common==0.21.0",
-    "dirigent-core==0.21.0",
-    "dirigent-examples==0.21.0",
-    "dirigent-plugin==0.21.0",
-    "dirigent-server==0.21.0",
+    "dirigent-block-execute==0.23.0",
+    "dirigent-blocks==0.23.0",
+    "dirigent-client==0.23.0",
+    "dirigent-common==0.23.0",
+    "dirigent-core==0.23.0",
+    "dirigent-examples==0.23.0",
+    "dirigent-plugin==0.23.0",
+    "dirigent-server==0.23.0",
     "httpx2>=2.12.0",
     "python-dotenv>=1.1.0",
     "pyyaml>=6.0.3",

{dirigent_cli-0.21.0 → dirigent_cli-0.23.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "dirigent-cli"
-version = "0.21.0"
+version = "0.23.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.21.0",
-    "dirigent-blocks==0.21.0",
-    "dirigent-client==0.21.0",
-    "dirigent-common==0.21.0",
-    "dirigent-core==0.21.0",
-    "dirigent-examples==0.21.0",
-    "dirigent-plugin==0.21.0",
-    "dirigent-server==0.21.0",
+    "dirigent-block-execute==0.23.0",
+    "dirigent-blocks==0.23.0",
+    "dirigent-client==0.23.0",
+    "dirigent-common==0.23.0",
+    "dirigent-core==0.23.0",
+    "dirigent-examples==0.23.0",
+    "dirigent-plugin==0.23.0",
+    "dirigent-server==0.23.0",
     "httpx2>=2.12.0",
     "python-dotenv>=1.1.0",
     "pyyaml>=6.0.3",

{dirigent_cli-0.21.0 → dirigent_cli-0.23.0}/src/dirigent_cli/commands.py

@@ -74,6 +74,7 @@ from dirigent_cli.messages import (
     RUN_SKIPPED,
     SCAFFOLD_REFUSED,
     SCHEMA_NOT_AN_OBJECT,
+    SCHEMA_NOTHING_TO_CHANGE,
     SCHEMA_UNREADABLE,
     SET_DG_TOKEN,
     SOURCE_REFUSED,
@@ -86,8 +87,11 @@ from dirigent_cli.messages import (
 )
 from dirigent_cli.messages import WINDOW_GRAMMAR as WINDOW_GRAMMAR_MESSAGE
 from dirigent_cli.output import (
+    CONNECTION_HEALTH,
+    RUNS_IN_FLIGHT,
     Detail,
     age,
+    connection_health,
     console,
     elapsed,
     emit_event,
@@ -133,6 +137,7 @@ from dirigent_cli.sources import (
 from dirigent_cli.stream import Sink, track_steps, use_scratch_prefix
 from dirigent_cli.timing import RunProfile, attempt_timing, by_step, profile, step_timing
 from dirigent_client import (
+    CLEAR,
     ApplyResult,
     AttemptEvent,
     AttemptOut,
@@ -140,6 +145,7 @@ from dirigent_client import (
     BackfillAccepted,
     BlockKind,
     Catalog,
+    Clear,
     DocumentKind,
     ExampleDetail,
     ExampleOut,
@@ -157,6 +163,7 @@ from dirigent_client import (
     RunReport,
     RunStatus,
     ValidationIssue,
+    declared_label,
 )
 from dirigent_common import Issue, JsonMap, Message
 from dirigent_core import migrations
@@ -821,7 +828,7 @@ def pipeline_list(
         return emit_records("pipeline", rows)
     table(
         "pipelines",
-        ["code", "name", "tags", "version", "active", "runs in flight", "updated"],
+        ["code", "name", "tags", "version", "active", RUNS_IN_FLIGHT, "updated"],
         [
             [
                 row.code,
@@ -857,7 +864,7 @@ def pipeline_show(
             "importance": row.importance.value,
             "active": "yes" if row.active else "no",
             "current version": row.current_version,
-            "runs in flight": row.active_runs,
+            RUNS_IN_FLIGHT: row.active_runs,
             "created": moment(row.created_at),
         },
     )
@@ -2435,7 +2442,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,
@@ -2463,8 +2470,11 @@ def schema_list(ctx: typer.Context) -> None:
         return emit_records("schema", rows)
     table(
         "schemas",
-        ["code", "name", "description"],
-        [[row.code, row.name or "-", row.description or "-"] for row in rows],
+        ["code", "name", "description", "used by"],
+        [
+            [row.code, row.name or "-", row.description or "-", str(len(row.used_by)) if row.used_by else "-"]
+            for row in rows
+        ],
     )
 
 
@@ -2481,6 +2491,19 @@ def schema_create(
     ] = None,
 ) -> None:
     """Store a locally authored JSON Schema, taking its identity from its own keywords."""
+    schema, document = _read_schema(reference)
+    resolved = code
+    if resolved is None and not (isinstance(schema.get("$id"), str) and code_from_id(cast("str", schema["$id"]))):
+        resolved = code_from_id(Path(document.ref).name) if document.ref != "(stdin)" else None
+    with client_for(state_of(ctx)) as dg:
+        created = dg.call(dg.schemas.create(schema, code=resolved, name=name, description=description))
+    if state_of(ctx).json_output:
+        return emit_fact("schema.created", message="created", code=created.code, name=created.name)
+    console.print(f"[green]stored[/] schema [bold]{created.code}[/]")
+
+
+def _read_schema(reference: str) -> tuple[JsonMap, Document]:
+    """Read a locally authored JSON Schema from a file, a URL, or standard input."""
     try:
         document = read_document(reference)
     except SourceError as error:
@@ -2491,15 +2514,69 @@ def schema_create(
         fail(SCHEMA_UNREADABLE, label=document.label, detail=str(error))
     if not isinstance(body, dict):
         fail(SCHEMA_NOT_AN_OBJECT, label=document.label, kind=type(body).__name__)
-    schema = cast("JsonMap", body)
-    resolved = code
-    if resolved is None and not (isinstance(schema.get("$id"), str) and code_from_id(cast("str", schema["$id"]))):
-        resolved = code_from_id(Path(document.ref).name) if document.ref != "(stdin)" else None
+    return cast("JsonMap", body), document
+
+
+def _label_given(text: str | None) -> str | Clear | None:
+    """Read a label option: not given leaves what is stored, and given empty clears it.
+
+    An empty title is the absence of one rather than a title, and no screen can draw it, so
+    the empty string is never what gets stored.
+    """
+    if text is None:
+        return None
+    return text.strip() or CLEAR
+
+
+@schema_app.command("update")
+def schema_update(
+    ctx: typer.Context,
+    code: Annotated[str, typer.Argument(help="The schema to change; a code is fixed once minted.")],
+    reference: Annotated[
+        str | None,
+        typer.Argument(help="A JSON Schema file, or - for standard input, to replace the stored body with."),
+    ] = None,
+    name: Annotated[
+        str | None,
+        typer.Option(help="A human title; taken from the replacing schema's title when omitted, cleared when empty."),
+    ] = None,
+    description: Annotated[
+        str | None,
+        typer.Option(help="What the schema is for; taken from the replacing schema's description, cleared when empty."),
+    ] = None,
+) -> None:
+    """Correct a stored schema: replace the shape, relabel it, or both.
+
+    What this was not given is left as it stands, and an option given empty clears what is
+    stored. Replacing the body takes the new schema's own ``title`` and ``description`` where
+    the options name neither, exactly as storing one does, so the labels belong to the shape
+    the instance now holds rather than to the one it no longer does.
+
+    An edit is never refused for being depended on: a code is fixed once minted, so refusing
+    it would freeze an in-use shape permanently. The answer names the pipelines that validate
+    against it, and the decision was made for them.
+    """
+    schema = _read_schema(reference)[0] if reference is not None else None
+    label = _label_given(name)
+    about = _label_given(description)
+    if schema is not None:
+        label = declared_label(schema, "title") if label is None else label
+        about = declared_label(schema, "description") if about is None else about
+    changed = [
+        field for field, given in (("name", label), ("description", about), ("body", schema)) if given is not None
+    ]
+    if not changed:
+        fail(SCHEMA_NOTHING_TO_CHANGE, code=code)
     with client_for(state_of(ctx)) as dg:
-        created = dg.call(dg.schemas.create(schema, code=resolved, name=name, description=description))
-    if state_of(ctx).json_output:
-        return emit_fact("schema.created", message="created", code=created.code, name=created.name)
-    console.print(f"[green]stored[/] schema [bold]{created.code}[/]")
+        edited = dg.call(dg.schemas.update(code, body=schema, name=label, description=about))
+    emit_fact(
+        "schema.updated",
+        message="updated",
+        code=edited.code,
+        name=edited.name,
+        changed=changed,
+        used_by=edited.used_by,
+    )
 
 
 @schema_app.command("show")
@@ -2509,13 +2586,20 @@ def schema_show(ctx: typer.Context, code: Annotated[str, typer.Argument()]) -> N
         row = dg.call(dg.schemas.get(code))
     if state_of(ctx).json_output:
         return emit_one("schema", row)
-    fields(f"schema {code}", {"name": row.name or "-", "description": row.description or "-"})
+    fields(
+        f"schema {code}",
+        {
+            "name": row.name or "-",
+            "description": row.description or "-",
+            "used by": ", ".join(row.used_by) or "-",
+        },
+    )
     console.print_json(data=row.body)
 
 
 @schema_app.command("delete")
 def schema_delete(ctx: typer.Context, code: Annotated[str, typer.Argument()]) -> None:
-    """Remove a schema."""
+    """Remove a schema, which the instance refuses while a stored pipeline names it."""
     with client_for(state_of(ctx)) as dg:
         dg.call(dg.schemas.delete(code))
     emit_fact("schema.deleted", message="deleted", code=code)

{dirigent_cli-0.21.0 → dirigent_cli-0.23.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.21.0 → dirigent_cli-0.23.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.21.0 → dirigent_cli-0.23.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
@@ -402,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()
 
@@ -443,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)

{dirigent_cli-0.21.0 → dirigent_cli-0.23.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,20 @@ SCHEMA_NOT_AN_OBJECT = CLI.define(
     "{label} is not a JSON Schema: a schema is an object, and this is {kind}",
 )
 
+SCHEMA_NOTHING_TO_CHANGE = CLI.define(
+    "schema_nothing_to_change",
+    "nothing was given to change about {code}; pass a schema file, --name or --description",
+)
+
+# 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.21.0 → dirigent_cli-0.23.0}/src/dirigent_cli/output.py

@@ -474,16 +474,29 @@ 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"
+
+#: What a pipeline's unsettled runs are called, wherever a rendering names the count the server
+#: computes from `ACTIVE_RUN_STATUSES`. The web UI heads its own feed of them with the same noun
+#: out of its catalogue, and `tests/test_shared_words.py` fails when the two stop agreeing.
+RUNS_IN_FLIGHT = "runs in flight"
+
+
 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 +542,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.21.0 → dirigent_cli-0.23.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.21.0 → dirigent_cli-0.23.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.21.0 → dirigent_cli-0.23.0}/src/dirigent_cli/seeding.py

@@ -11,7 +11,7 @@ from pathlib import Path
 from typing import Any, cast
 
 from dirigent_cli.local import ConnectionSpec
-from dirigent_client import Dirigent, DirigentError, PlanAction, ProvenanceSource
+from dirigent_client import Dirigent, DirigentError, PlanAction, ProvenanceSource, declared_label
 from dirigent_common import JsonMap
 from dirigent_core.documents import CARRIED, SUFFIXES, is_document, readable, safe_load
 from dirigent_core.protocol import Record, make
@@ -99,11 +99,21 @@ def _schemas(raw: JsonMap) -> dict[str, JsonMap]:
 
 
 async def _schema(client: Dirigent, code: str, body: JsonMap) -> None:
-    """Store one named schema, replacing the body of one this instance already holds."""
+    """Store one named schema, replacing the shape and the labels of one already held.
+
+    Storing reads the schema's own ``title`` and ``description`` and editing reads neither, so
+    the replacement sends what the document's schema declares about itself; otherwise the same
+    corpus would label a schema one way on a fresh instance and another way on a seeded one.
+    """
     try:
         await client.schemas.create(body, code=code)
     except DirigentError:
-        await client.schemas.update(code, body=body)
+        await client.schemas.update(
+            code,
+            body=body,
+            name=declared_label(body, "title"),
+            description=declared_label(body, "description"),
+        )
 
 
 async def _connections(client: Dirigent, declared: Sequence[ConnectionSpec], origin: str) -> AsyncIterator[Record]:

{dirigent_cli-0.21.0 → dirigent_cli-0.23.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.21.0 → dirigent_cli-0.23.0}/src/dirigent_cli/summaries.py

@@ -52,6 +52,7 @@ BULKY: Final = frozenset(
         "token",
         "preflight",
         "requires",
+        "used_by",
     }
 )
 
@@ -342,6 +343,33 @@ def _created(record: Record) -> RenderableType | None:
     return Group(*parts)
 
 
+#: What a changed shape reaches. The web UI warns in these words before a save, out of its own
+#: catalogue, and `tests/test_shared_words.py` fails when the two stop agreeing. Written without
+#: terminal punctuation, because the rendering puts the pipelines after it.
+SCHEMA_REACHES = "Every pipeline naming this code checks against this shape from its next run"
+
+#: What it does not reach. Said after the pipelines rather than with them: the colon above governs
+#: that list, and a run in flight is not on it. Paired with the web UI's own words by the
+#: same test, and punctuated, because nothing follows it.
+IN_FLIGHT_KEEPS_ITS_SHAPE = "A run in flight keeps the shape it started with."
+
+
+def _schema_edited(record: Record) -> RenderableType | None:
+    """Render whose pipelines the shape that was just changed was changed for.
+
+    An edit is never refused for being depended on, so the pipelines checking against the
+    code are the ones the edit was a decision about, and they are named rather than counted.
+    Where no pipeline names the code, no run checks against it either, so neither line is drawn.
+    """
+    named = _texts(record, "used_by")
+    if not named:
+        return None
+    parts: list[RenderableType] = [f"\n{SCHEMA_REACHES}:"]
+    parts.extend(f"  [yellow]-[/] {escape(one)}" for one in named)
+    parts.append(f"\n{IN_FLIGHT_KEEPS_ITS_SHAPE}")
+    return Group(*parts)
+
+
 def _config(record: Record) -> RenderableType | None:
     """Render the effective configuration as a setting-per-row table."""
     settings = record.get("settings")
@@ -524,4 +552,5 @@ RENDERERS: Final[Mapping[str, Callable[[Record], RenderableType | None]]] = {
     "project.scaffolded": _scaffolded,
     "instance.initialised": _initialised,
     "pipeline.created": _created,
+    "schema.updated": _schema_edited,
 }

{dirigent_cli-0.21.0 → dirigent_cli-0.23.0}/src/dirigent_cli/triggers.py

@@ -28,7 +28,7 @@ from dirigent_cli.output import (
     throttle_note,
     watching,
 )
-from dirigent_client import LOG_NOTIFIER, AlertEvent, AlertScope, WebhookTokenOut
+from dirigent_client import LOG_NOTIFIER, TEST_SUBJECT, AlertEvent, AlertScope, WebhookTokenOut
 from dirigent_common import Message
 
 schedule_app = typer.Typer(
@@ -609,7 +609,7 @@ def alerts_test(
         str | None,
         typer.Option("--connection", help="The connection to deliver through; none delivers to the process log."),
     ] = None,
-    subject: Annotated[str, typer.Option("--subject", help="What the test message says.")] = "dirigent test alert",
+    subject: Annotated[str, typer.Option("--subject", help="What the test message says.")] = TEST_SUBJECT,
 ) -> None:
     """Send a test message to one target, on the same queue a real alert takes."""
     with client_for(state_of(ctx)) as dg: