alloy-runtime-cli 0.1.0__py3-none-any.whl

cli/commands/pipelines/list/presenter.py

@@ -0,0 +1,66 @@
+"""Presenter for pipelines list command output."""
+
+from alloy_runtime_types.dtos.pipeline import ListPipelinesResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def _format_description(description: str | None) -> str:
+    """Format description for display, truncating if too long."""
+    if not description:
+        return "-"
+    if len(description) > 100:
+        return description[:97] + "..."
+    return description
+
+
+def present_pipelines_list(response: ListPipelinesResponse) -> None:
+    """Present list of pipelines with Rich table formatting."""
+    output = OutputService.get()
+
+    if not response.pipelines:
+        output.info("No pipelines found")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="is_public",
+            header_label="Public",
+            formatter=lambda x: "Yes" if x else "No",
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="created_at",
+            header_label="Created",
+            formatter=lambda x: x.strftime("%Y-%m-%d") if x else "-",
+            compact_line=1,
+            compact_style="blue",
+        ),
+        ColumnConfig(
+            source_field="name",
+            header_label="Name",
+            compact_line=2,
+            compact_style="white bold",
+        ),
+        ColumnConfig(
+            source_field="description",
+            header_label="Description",
+            formatter=_format_description,
+            compact_line=2,
+            compact_style="dim",
+        ),
+    ]
+
+    output.table(
+        items=response.pipelines,  # type: ignore[arg-type]
+        title=f"Pipelines ({response.total})",
+        columns=columns,
+    )

cli/commands/pipelines/schedules/__init__.py

@@ -0,0 +1 @@
+# Empty per project convention - import directly from submodules

cli/commands/pipelines/schedules/create_command.py

@@ -0,0 +1,119 @@
+"""Pipeline schedule create command implementation."""
+
+import json
+from typing import Annotated, Any
+from uuid import UUID
+
+import typer
+
+from alloy_runtime_types.dtos.schedule import (
+    CreateScheduleRequest,
+    CronSchedule,
+)
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.schedules.create_presenter import present_create_result
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_schedules_create_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    name: str = typer.Option(
+        ...,
+        "-n",
+        "--name",
+        help="Schedule name",
+    ),
+    cron: str = typer.Option(
+        ...,
+        "--cron",
+        help="Cron expression (5 fields: minute hour day month weekday)",
+    ),
+    description: Annotated[
+        str | None,
+        typer.Option(
+            "-d",
+            "--description",
+            help="Schedule description",
+        ),
+    ] = None,
+    timezone: str = typer.Option(
+        "UTC",
+        "--timezone",
+        "-tz",
+        help="IANA timezone (e.g. America/Chicago, Europe/London)",
+    ),
+    input_params: Annotated[
+        str | None,
+        typer.Option(
+            "--input-params",
+            "-i",
+            help="Input parameters as JSON string",
+        ),
+    ] = None,
+    timeout: int = typer.Option(
+        300,
+        "--timeout",
+        "-t",
+        help="Execution timeout in seconds (1-3600)",
+        min=1,
+        max=3600,
+    ),
+    disabled: bool = typer.Option(
+        False,
+        "--disabled",
+        help="Create schedule in disabled state",
+    ),
+    allow_concurrent: bool = typer.Option(
+        False,
+        "--allow-concurrent",
+        help="Allow concurrent executions",
+    ),
+    max_failures: int = typer.Option(
+        5,
+        "--max-failures",
+        help="Auto-disable after this many consecutive failures (0 = never)",
+        min=0,
+    ),
+) -> None:
+    """Create a recurring schedule for a pipeline.
+
+    Examples:
+        ai pipelines schedules create 123e4567... -n 'Daily Report' --cron '0 9 * * *'
+        ai pipelines schedules create 123e4567... -n 'Weekly' --cron '0 9 * * 1' --timezone America/Chicago
+        ai pipelines schedules create 123e4567... -n 'Hourly' --cron '0 * * * *' -i '{"key": "value"}'
+    """
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+
+    params: dict[str, Any] = {}
+    if input_params:
+        try:
+            params = json.loads(input_params)
+        except json.JSONDecodeError as e:
+            raise typer.BadParameter(f"Invalid JSON for --input-params: {e}")
+
+    schedule_expr = CronSchedule(expression=cron, timezone=timezone)
+
+    request = CreateScheduleRequest(
+        name=name,
+        description=description,
+        schedule=schedule_expr,
+        input_parameters=params,
+        timeout_seconds=timeout,
+        is_enabled=not disabled,
+        allow_concurrent=allow_concurrent,
+        max_consecutive_failures=max_failures,
+    )
+
+    _execute_create(pipeline_id=p_uuid, request=request)
+
+
+@async_command
+async def _execute_create(pipeline_id: UUID, request: CreateScheduleRequest) -> None:
+    """Execute create schedule operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.create_pipeline_schedule(pipeline_id, request)
+
+    present_create_result(response)

cli/commands/pipelines/schedules/create_presenter.py

@@ -0,0 +1,35 @@
+"""Presenter for pipeline schedule create command output."""
+
+from alloy_runtime_types.dtos.schedule import CreateScheduleResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def present_create_result(response: CreateScheduleResponse) -> None:
+    """Present created schedule details."""
+    output = OutputService.get()
+
+    from cli.infrastructure.formatting.fields import format_optional
+
+    fields = [
+        FieldConfig("id", "Schedule ID", str),
+        FieldConfig("pipeline_id", "Pipeline ID", str),
+        FieldConfig("name", "Name"),
+        FieldConfig("description", "Description", format_optional),
+        FieldConfig("schedule_type", "Type"),
+        FieldConfig("timezone", "Timezone"),
+        FieldConfig("is_enabled", "Enabled", lambda v: "Yes" if v else "No"),
+        FieldConfig(
+            "next_run_at",
+            "Next Run",
+            lambda v: v.strftime("%Y-%m-%d %H:%M:%S %Z") if v else "N/A",
+        ),
+        FieldConfig(
+            "created_at",
+            "Created",
+            lambda v: v.strftime("%Y-%m-%d %H:%M:%S %Z") if v else "N/A",
+        ),
+    ]
+
+    output.entity(response, f"Created schedule: {response.name}", fields)

cli/commands/pipelines/schedules/delete_command.py

@@ -0,0 +1,52 @@
+"""Pipeline schedule delete command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.schedules.presenter import present_delete_result
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.console import Confirm
+
+
+def pipelines_schedules_delete_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    schedule_id: str = typer.Argument(
+        ...,
+        help="Schedule UUID",
+    ),
+    yes: bool = typer.Option(
+        False,
+        "-y",
+        "--yes",
+        help="Skip confirmation",
+    ),
+) -> None:
+    """Delete a pipeline schedule.
+
+    Examples:
+        ai pipelines schedules delete 123e4567... 456e7890...
+        ai pipelines schedules delete 123e4567... 456e7890... -y
+    """
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    s_uuid = validate_uuid(schedule_id, "schedule")
+
+    if not yes:
+        confirmed = Confirm.ask(f"[yellow]Delete schedule {schedule_id}?[/yellow]")
+        if not confirmed:
+            raise typer.Abort()
+
+    _execute_delete(pipeline_id=p_uuid, schedule_id=s_uuid)
+
+
+@async_command
+async def _execute_delete(pipeline_id: UUID, schedule_id: UUID) -> None:
+    """Execute delete schedule operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.delete_pipeline_schedule(pipeline_id, schedule_id)
+
+    present_delete_result(response)

cli/commands/pipelines/schedules/env_vars_command.py

@@ -0,0 +1,59 @@
+from uuid import UUID
+from typing import Annotated
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.schedules.env_vars_presenter import (
+    present_set_env_vars_result,
+)
+from cli.infrastructure.command import async_command, authenticated_client
+from cli.infrastructure.kv_parser import parse_kv_pairs
+
+from alloy_runtime_types.dtos.schedule import SetScheduleEnvVarsRequest
+
+
+def pipelines_schedules_env_vars_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    schedule_id: str = typer.Argument(
+        ...,
+        help="Schedule UUID",
+    ),
+    env: Annotated[
+        list[str] | None,
+        typer.Option(
+            "--env",
+            "-e",
+            help="Environment variable in KEY=VALUE format (repeatable). Pass no values to clear all.",
+        ),
+    ] = None,
+) -> None:
+    """Set environment variables on a pipeline schedule.
+
+    Schedule-level env vars override pipeline-level env vars when the
+    schedule triggers execution.
+
+    Examples:
+        ai pipelines schedules env-vars 123e4567... 456e7890... --env API_KEY=secret
+        ai pipelines schedules env-vars 123e4567... 456e7890... -e KEY1=val1 -e KEY2=val2
+        ai pipelines schedules env-vars 123e4567... 456e7890...
+    """
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    s_uuid = validate_uuid(schedule_id, "schedule")
+    env_vars = parse_kv_pairs(env)
+
+    _execute_set(pipeline_id=p_uuid, schedule_id=s_uuid, env_vars=env_vars)
+
+
+@async_command
+async def _execute_set(
+    pipeline_id: UUID, schedule_id: UUID, env_vars: dict[str, str]
+) -> None:
+    async with authenticated_client() as (_config, client):
+        request = SetScheduleEnvVarsRequest(env_vars=env_vars)
+        response = await client.set_schedule_env_vars(pipeline_id, schedule_id, request)
+
+    present_set_env_vars_result(response)

cli/commands/pipelines/schedules/env_vars_presenter.py

@@ -0,0 +1,16 @@
+from alloy_runtime_types.dtos.schedule import SetScheduleEnvVarsResponse
+
+from cli.infrastructure.output import OutputService
+
+
+def present_set_env_vars_result(response: SetScheduleEnvVarsResponse) -> None:
+    output = OutputService.get()
+
+    if not response.env_var_keys:
+        output.success(f"Cleared all env vars for schedule {response.schedule_id}")
+        return
+
+    output.info(f"Set env vars for schedule {response.schedule_id}:")
+    for key in response.env_var_keys:
+        masked = response.masked_values.get(key, "***")
+        output.info(f"  {key}: {masked}")

cli/commands/pipelines/schedules/get_command.py

@@ -0,0 +1,38 @@
+"""Pipeline schedule get command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.schedules.presenter import present_schedule_detail
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_schedules_get_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    schedule_id: str = typer.Argument(
+        ...,
+        help="Schedule UUID",
+    ),
+) -> None:
+    """Get details of a pipeline schedule.
+
+    Examples:
+        ai pipelines schedules get 123e4567... 456e7890...
+    """
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+    s_uuid = validate_uuid(schedule_id, "schedule")
+    _execute_get(pipeline_id=p_uuid, schedule_id=s_uuid)
+
+
+@async_command
+async def _execute_get(pipeline_id: UUID, schedule_id: UUID) -> None:
+    """Execute get schedule operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.get_pipeline_schedule(pipeline_id, schedule_id)
+
+    present_schedule_detail(response)

cli/commands/pipelines/schedules/list_command.py

@@ -0,0 +1,33 @@
+"""Pipeline schedules list command implementation."""
+
+from uuid import UUID
+
+import typer
+
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.schedules.presenter import present_schedules_list
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_schedules_list_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+) -> None:
+    """List schedules for a pipeline.
+
+    Examples:
+        ai pipelines schedules list 123e4567-89ab...
+    """
+    pipeline_uuid = validate_uuid(pipeline_id, "pipeline")
+    _execute_list(pipeline_id=pipeline_uuid)
+
+
+@async_command
+async def _execute_list(pipeline_id: UUID) -> None:
+    """Execute list schedules operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.list_pipeline_schedules(pipeline_id)
+
+    present_schedules_list(response)

cli/commands/pipelines/schedules/once_command.py

@@ -0,0 +1,90 @@
+"""Pipeline schedule once command implementation."""
+
+import json
+from typing import Annotated, Any
+from uuid import UUID
+
+import typer
+
+from alloy_runtime_types.dtos.schedule import ScheduleOnceRequest
+from cli.commands.flag_utils import validate_uuid
+from cli.commands.pipelines.schedules.once_presenter import present_once_result
+from cli.infrastructure.command import async_command, authenticated_client
+
+
+def pipelines_schedules_once_command(
+    pipeline_id: str = typer.Argument(
+        ...,
+        help="Pipeline UUID",
+    ),
+    scheduled_for: str = typer.Option(
+        ...,
+        "--scheduled-for",
+        "-s",
+        help="When to execute (ISO 8601 datetime, e.g. 2026-03-01T15:00:00)",
+    ),
+    timezone: str = typer.Option(
+        "UTC",
+        "--timezone",
+        "-tz",
+        help="IANA timezone for interpreting scheduled_for",
+    ),
+    input_params: Annotated[
+        str | None,
+        typer.Option(
+            "--input-params",
+            "-i",
+            help="Input parameters as JSON string",
+        ),
+    ] = None,
+    timeout: int = typer.Option(
+        300,
+        "--timeout",
+        "-t",
+        help="Execution timeout in seconds (1-3600)",
+        min=1,
+        max=3600,
+    ),
+) -> None:
+    """Schedule a one-time pipeline execution.
+
+    Examples:
+        ai pipelines schedules once 123e4567... --scheduled-for 2026-03-01T15:00:00
+        ai pipelines schedules once 123e4567... -s 2026-03-01T15:00:00 --timezone America/New_York
+        ai pipelines schedules once 123e4567... -s 2026-03-01T15:00:00 -i '{"key": "value"}'
+    """
+    from datetime import datetime as dt
+
+    p_uuid = validate_uuid(pipeline_id, "pipeline")
+
+    try:
+        scheduled_dt = dt.fromisoformat(scheduled_for)
+    except ValueError:
+        raise typer.BadParameter(
+            f"Invalid datetime format: '{scheduled_for}'. Use ISO 8601 (e.g. 2026-03-01T15:00:00)"
+        )
+
+    params: dict[str, Any] = {}
+    if input_params:
+        try:
+            params = json.loads(input_params)
+        except json.JSONDecodeError as e:
+            raise typer.BadParameter(f"Invalid JSON for --input-params: {e}")
+
+    request = ScheduleOnceRequest(
+        scheduled_for=scheduled_dt,
+        timezone=timezone,
+        input_parameters=params,
+        timeout_seconds=timeout,
+    )
+
+    _execute_once(pipeline_id=p_uuid, request=request)
+
+
+@async_command
+async def _execute_once(pipeline_id: UUID, request: ScheduleOnceRequest) -> None:
+    """Execute schedule-once operation."""
+    async with authenticated_client() as (_config, client):
+        response = await client.schedule_pipeline_once(pipeline_id, request)
+
+    present_once_result(response)

cli/commands/pipelines/schedules/once_presenter.py

@@ -0,0 +1,30 @@
+"""Presenter for pipeline schedule once command output."""
+
+from alloy_runtime_types.dtos.schedule import ScheduleOnceResponse
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+
+def present_once_result(response: ScheduleOnceResponse) -> None:
+    """Present scheduled one-time execution details."""
+    output = OutputService.get()
+
+    fields = [
+        FieldConfig("id", "Execution ID", str),
+        FieldConfig("pipeline_id", "Pipeline ID", str),
+        FieldConfig(
+            "scheduled_for",
+            "Scheduled For",
+            lambda v: v.strftime("%Y-%m-%d %H:%M:%S %Z") if v else "N/A",
+        ),
+        FieldConfig("timezone", "Timezone"),
+        FieldConfig("status", "Status", lambda v: v.capitalize()),
+        FieldConfig(
+            "created_at",
+            "Created",
+            lambda v: v.strftime("%Y-%m-%d %H:%M:%S %Z") if v else "N/A",
+        ),
+    ]
+
+    output.entity(response, "Scheduled one-time execution", fields)

cli/commands/pipelines/schedules/presenter.py

@@ -0,0 +1,104 @@
+"""Presenters for pipeline schedules command output."""
+
+from datetime import datetime
+
+from alloy_runtime_types.dtos.schedule import (
+    DeleteScheduleResponse,
+    GetScheduleResponse,
+    ListSchedulesResponse,
+)
+
+from cli.infrastructure.output import OutputService
+from cli.infrastructure.renderers.list_renderer import ColumnConfig
+
+
+def present_schedules_list(response: ListSchedulesResponse) -> None:
+    """Present list of schedules with Rich table formatting."""
+    output = OutputService.get()
+
+    if not response.schedules:
+        output.info("No schedules found")
+        return
+
+    columns = [
+        ColumnConfig(
+            source_field="id",
+            header_label="ID",
+            compact_line=1,
+            compact_style="cyan",
+        ),
+        ColumnConfig(
+            source_field="is_enabled",
+            header_label="Enabled",
+            formatter=lambda x: "Yes" if x else "No",
+            compact_line=1,
+            compact_style="green",
+        ),
+        ColumnConfig(
+            source_field="schedule_type",
+            header_label="Type",
+            compact_line=1,
+            compact_style="yellow",
+        ),
+        ColumnConfig(
+            source_field="name",
+            header_label="Name",
+            compact_line=2,
+            compact_style="white bold",
+        ),
+        ColumnConfig(
+            source_field="next_run_at",
+            header_label="Next Run",
+            formatter=lambda x: x.strftime("%Y-%m-%d %H:%M") if x else "Never",
+            compact_line=2,
+            compact_style="blue",
+        ),
+    ]
+
+    output.table(
+        items=response.schedules,  # type: ignore[arg-type]
+        title=f"Schedules ({response.total})",
+        columns=columns,
+    )
+
+
+def present_schedule_detail(response: GetScheduleResponse) -> None:
+    """Present schedule details with Rich formatting."""
+    output = OutputService.get()
+
+    from cli.infrastructure.formatting.fields import format_optional
+    from cli.infrastructure.renderers.entity_renderer import FieldConfig
+
+    def _format_datetime_with_tz(dt: datetime | None) -> str:
+        """Format datetime with timezone."""
+        return format_optional(dt, lambda x: x.strftime("%Y-%m-%d %H:%M:%S %Z"))
+
+    fields = [
+        FieldConfig("id", "Schedule ID", str),
+        FieldConfig("pipeline_id", "Pipeline ID", str),
+        FieldConfig("name", "Name"),
+        FieldConfig("description", "Description", format_optional),
+        FieldConfig("schedule_type", "Type"),
+        FieldConfig("timezone", "Timezone"),
+        FieldConfig("is_enabled", "Enabled", lambda v: "Yes" if v else "No"),
+        FieldConfig("cron_expression", "Cron Expression", format_optional),
+        FieldConfig("rrule_freq", "RRULE Freq", format_optional),
+        FieldConfig(
+            "rrule_interval", "RRULE Interval", lambda v: str(v) if v and v > 1 else "-"
+        ),
+        FieldConfig("next_run_at", "Next Run", _format_datetime_with_tz),
+        FieldConfig("last_run_at", "Last Run", _format_datetime_with_tz),
+        FieldConfig("consecutive_failures", "Consecutive Failures", str),
+        FieldConfig(
+            "allow_concurrent", "Allow Concurrent", lambda v: "Yes" if v else "No"
+        ),
+        FieldConfig("max_consecutive_failures", "Max Failures", str),
+    ]
+
+    output.entity(response, f"Schedule: {response.name}", fields)
+
+
+def present_delete_result(response: DeleteScheduleResponse) -> None:
+    """Present schedule deletion result."""
+    output = OutputService.get()
+    output.success(f"Deleted schedule {response.id}")