fix(cli)

- refactor typer app context as a pydantic model
- ensure campaign name and id is always available in commands

Author: tcjennings

packages/cm-commandline/src/lsst/cmservice/commandline/arguments.py

@@ -1,26 +1,41 @@
+import re
 from typing import Annotated, Literal
-from uuid import UUID, uuid5
+from uuid import uuid5
 
 import typer
 
+from .models import TypedContext
 from .settings import settings
 
 
-def preprocess_campaign_name(campaign: str) -> str:
-    """Preprocesses a campaign NAME by translating it to a campaign ID"""
-    try:
-        campaign_id = UUID(campaign)
-        return str(campaign_id)
-    except ValueError:
-        return str(uuid5(settings.default_namespace, campaign))
+def as_snake_case(s: str) -> str:
+    """Preprocesses a string by sanitizing it and producing snake case."""
+    # TODO clean up unicode characters and etc
+    return re.sub(r"\W+?", "_", s)
 
 
-campaign_name = Annotated[str, typer.Argument()]
+def preprocess_campaign_name(ctx: TypedContext, campaign: str) -> str:
+    """Preprocesses a campaign NAME by translating it to a campaign ID and
+    storing the result in the application context
+    """
+    ctx.obj.campaign_name = campaign
+    ctx.obj.campaign_id = str(uuid5(settings.default_namespace, campaign))
+    return campaign
+
+
+campaign_name = Annotated[
+    str,
+    typer.Argument(
+        envvar="CM_CAMPAIGN",
+        callback=preprocess_campaign_name,
+        help="A campaign name that is coerced into a UUID, or a UUID.",
+    ),
+]
 
-campaign_id = Annotated[str, typer.Argument(envvar="CM_CAMPAIGN", callback=preprocess_campaign_name)]
 
 campaign_status = Annotated[
     Literal["paused", "rejected", "accepted", "failed"], typer.Argument(help="Campaign status name")
 ]
 
-node_id = Annotated[str, typer.Argument()]
+
+node_id = Annotated[str, typer.Argument(help="An id for a node, as a UUID value.")]

packages/cm-commandline/src/lsst/cmservice/commandline/campaigns/app.py

@@ -18,15 +18,16 @@
 
 from .. import arguments, formatters
 from ..client import http_client
+from ..models import TypedContext
 
 app = typer.Typer()
 console = Console()
 
 
 @app.command()
-def list(ctx: typer.Context) -> None:
+def list(ctx: TypedContext) -> None:
     """list all campaigns"""
-    output_format = formatters.Formatters[ctx.obj.get("output_format")]
+    output_format = formatters.Formatters[ctx.obj.output_format]
     with http_client(ctx) as session:
         try:
             r = session.get("/campaigns")
@@ -48,11 +49,11 @@ def list(ctx: typer.Context) -> None:
 
 @app.command(name="new")
 def new_campaign(
-    ctx: typer.Context,
+    ctx: TypedContext,
     campaign: arguments.campaign_name,
 ) -> None:
-    """create a new empty campaign"""
-    output_format = formatters.Formatters[ctx.obj.get("output_format")]
+    """Create a new empty campaign"""
+    output_format = formatters.Formatters[ctx.obj.output_format]
     data = {
         "apiVersion": "io.lsst.cmservice/v1",
         "kind": "campaign",
@@ -67,7 +68,7 @@ def new_campaign(
 
     match output_format:
         case formatters.Formatters.table:
-            t = formatters.as_table(r.json())
+            t = formatters.as_table([r.json()])
             Console().print(t)
         case formatters.Formatters.json:
             pretty = JSONHighlighter()
@@ -78,12 +79,12 @@ def new_campaign(
 
 @app.command(name="describe")
 def describe_campaign(
-    ctx: typer.Context,
-    campaign: arguments.campaign_id,
+    ctx: TypedContext,
+    campaign: arguments.campaign_name,
 ) -> None:
     """describe a specific campaign"""
     with http_client(ctx) as session:
-        r = session.get(f"/campaigns/{campaign}/summary")
+        r = session.get(f"/campaigns/{ctx.obj.campaign_id}/summary")
         r.raise_for_status()
         # edges_url = r.headers["Edges"]
         # nodes_url = r.headers["Nodes"]
@@ -145,14 +146,14 @@ def describe_campaign(
 
 
 @app.command(name="start")
-def start_campaign(ctx: typer.Context, campaign: arguments.campaign_id) -> None:
+def start_campaign(ctx: TypedContext, campaign: arguments.campaign_name) -> None:
     """start a campaign"""
     data = {"status": "running"}
     status_update_url = None
 
     with http_client(ctx) as session:
         r = session.patch(
-            f"/campaigns/{campaign}",
+            f"/campaigns/{ctx.obj.campaign_id}",
             json=data,
             headers={"Content-Type": "application/merge-patch+json"},
         )
@@ -195,8 +196,8 @@ def start_campaign(ctx: typer.Context, campaign: arguments.campaign_id) -> None:
 
 @app.command(name="set")
 def set_campaign_status(
-    ctx: typer.Context,
-    campaign: arguments.campaign_id,
+    ctx: TypedContext,
+    campaign: arguments.campaign_name,
     desired_state: arguments.campaign_status,
     *,
     force: Annotated[
@@ -213,7 +214,7 @@ def set_campaign_status(
 
     with http_client(ctx) as session:
         r = session.patch(
-            f"/campaigns/{campaign}",
+            f"/campaigns/{ctx.obj.campaign_id}",
             json=data,
             headers={"Content-Type": "application/merge-patch+json"},
         )
@@ -254,15 +255,15 @@ def set_campaign_status(
 
 
 @app.command(name="advance")
-def advance_campaign(ctx: typer.Context, campaign: arguments.campaign_id) -> None:
+def advance_campaign(ctx: TypedContext, campaign: arguments.campaign_name) -> None:
     """advances a paused campaign"""
 
     status_update_url = None
 
     with http_client(ctx) as session:
         r = session.post(
             "/rpc/process",
-            json={"campaign_id": campaign},
+            json={"campaign_id": ctx.obj.campaign_id},
             headers={},
         )
         r.raise_for_status()

packages/cm-commandline/src/lsst/cmservice/commandline/cli.py

@@ -4,6 +4,7 @@
 from .campaigns.app import app as campaigns_app
 from .loader.app import app as loader_app
 from .manifests.app import app as manifests_app
+from .models import AppContext, TypedContext
 from .nodes.app import app as nodes_app
 from .settings import settings
 
@@ -16,14 +17,12 @@
 
 @app.callback()
 def build_context(
-    ctx: typer.Context,
+    ctx: TypedContext,
     output: options.output = "table",
     endpoint: options.endpoint = settings.endpoint,
     token: options.token = settings.token,
 ) -> None:
-    ctx.ensure_object(dict)
-    ctx.obj["output_format"] = output
-    ctx.obj["cm_endpoint_url"] = endpoint
+    ctx.obj = AppContext(output_format=output, endpoint_url=endpoint, auth_token=token)
 
 
 if __name__ == "__main__":

packages/cm-commandline/src/lsst/cmservice/commandline/client.py

@@ -4,25 +4,24 @@
 from contextlib import contextmanager
 from uuid import uuid4
 
-import typer
 from httpx import Client, HTTPStatusError, HTTPTransport
 
 from .logging import LOGGER
-from .settings import settings
+from .models import TypedContext
 
 logger = LOGGER.bind(module=__name__)
 
 
 @contextmanager
-def http_client(ctx: typer.Context) -> Generator[Client]:
+def http_client(ctx: TypedContext) -> Generator[Client]:
     """Generate a client session for cmclient API operations."""
     transport = HTTPTransport(
         verify=False,
         retries=3,
     )
-    endpoint_url = ctx.obj.get("endpoint_url", settings.endpoint)
-    api_version = ctx.obj.get("api_version", settings.api_version)
-    auth_token = ctx.obj.get("auth_token", settings.token)
+    endpoint_url = ctx.obj.endpoint_url
+    api_version = ctx.obj.api_version
+    auth_token = ctx.obj.auth_token
 
     with Client(
         base_url=f"{endpoint_url}/{api_version}",

packages/cm-commandline/src/lsst/cmservice/commandline/loader/app.py

@@ -5,26 +5,42 @@
 from rich.console import Console
 from rich.table import Table
 
+from .. import arguments
+from ..campaigns.app import start_campaign
+from ..models import TypedContext
 from .loader import load_selected_file
 
 app = typer.Typer()
 
 
 @app.command(name="yaml")
 def load_from_yaml(
-    ctx: typer.Context,
+    ctx: TypedContext,
     filename: str,
-    campaign_name: Annotated[str | None, typer.Argument(envvar="CM_CAMPAIGN")] = None,
+    campaign: arguments.campaign_name,
+    *,
+    auto_run: Annotated[
+        bool,
+        typer.Option(
+            "--start",
+            help="Start campaign automatically after loading",
+        ),
+    ] = False,
 ) -> None:
     """Load manifests from a YAML file"""
-    headers = load_selected_file(ctx, Path(filename), campaign_name)
+    headers = load_selected_file(ctx, Path(filename), campaign)
 
     if headers:
-        table = Table(title=campaign_name)
+        table = Table(title=ctx.obj.campaign_name)
         table.add_column("Link Name")
         table.add_column("Link")
 
         for k, v in headers.items():
             table.add_row(k, v)
 
         Console().print(table)
+
+    # If argument "auto-start" is set, try to set campaign status after loading
+    if auto_run:
+        typer.echo(f"Starting campaign {ctx.obj.campaign_name}")
+        ctx.invoke(start_campaign, ctx=ctx, campaign=campaign)

packages/cm-commandline/src/lsst/cmservice/commandline/loader/loader.py

@@ -4,9 +4,9 @@
 import typer
 import yaml
 from httpx import Headers, HTTPStatusError
-from rich import print
 
 from ..client import http_client
+from ..models import TypedContext
 
 
 def yaml_to_json(yaml_docs: str) -> Any:
@@ -15,7 +15,7 @@ def yaml_to_json(yaml_docs: str) -> Any:
     yield from _yamls
 
 
-def load_selected_file(ctx: typer.Context, yaml_file: Path, campaign_name: str | None) -> Headers | None:
+def load_selected_file(ctx: TypedContext, yaml_file: Path, campaign: str | None) -> Headers | None:
     """Load a collection of Manifests from a YAML file.
 
     If `campaign_name` is None, the campaign name must be set in the YAML file.
@@ -31,26 +31,31 @@ def load_selected_file(ctx: typer.Context, yaml_file: Path, campaign_name: str |
             match yaml["kind"]:
                 case "campaign":
                     uri = "/campaigns"
-                    yaml["metadata"]["name"] = campaign_name or yaml["metadata"]["name"]
+                    yaml["metadata"]["name"] = yaml["metadata"]["name"] if campaign is None else campaign
                     capture_headers = True
                 case "node":
                     uri = "/nodes"
-                    yaml["metadata"]["namespace"] = campaign_name or yaml["metadata"]["namespace"]
+                    yaml["metadata"]["namespace"] = (
+                        yaml["metadata"]["namespace"] if campaign is None else ctx.obj.campaign_id
+                    )
                 case "edge":
                     uri = "/edges"
-                    yaml["metadata"]["namespace"] = campaign_name or yaml["metadata"]["namespace"]
+                    yaml["metadata"]["namespace"] = (
+                        yaml["metadata"]["namespace"] if campaign is None else ctx.obj.campaign_id
+                    )
                 case _:
                     uri = "/manifests"
-                    yaml["metadata"]["namespace"] = campaign_name or yaml["metadata"]["namespace"]
+                    yaml["metadata"]["namespace"] = (
+                        yaml["metadata"]["namespace"] if campaign is None else ctx.obj.campaign_id
+                    )
 
             try:
                 r = session.post(uri, json=yaml)
                 r.raise_for_status()
                 if capture_headers:
                     headers = r.headers
             except HTTPStatusError:
-                print(f"Failed to create manifests: {r.text}")
-                print(r.headers)
-                break
+                typer.echo(f"Failed to create manifests: {r.text}", err=True)
+                raise typer.Exit(1)
 
     return headers

packages/cm-commandline/src/lsst/cmservice/commandline/models.py

@@ -0,0 +1,17 @@
+import typer
+from pydantic import BaseModel
+
+from .settings import settings
+
+
+class AppContext(BaseModel):
+    auth_token: str = settings.token
+    campaign_name: str | None = None
+    campaign_id: str | None = None
+    endpoint_url: str = settings.endpoint
+    output_format: str
+    api_version: str = settings.api_version
+
+
+class TypedContext(typer.Context):
+    obj: AppContext