solwyn-cli 0.1.0__py3-none-any.whl

solwyn_cli/commands/config.py

@@ -0,0 +1,110 @@
+"""Commands for inspecting and updating local non-secret configuration."""
+
+from typing import Annotated
+
+import typer
+from pydantic import ValidationError
+
+from solwyn_cli.config import (
+    CONFIG_KEYS,
+    Config,
+    ConfigLoadError,
+    ConfigWriteError,
+    load_config,
+    update_config_value,
+)
+from solwyn_cli.help import help_contract
+
+
+app = typer.Typer(
+    help="Inspect and update local configuration.",
+    epilog=help_contract(
+        endpoint="local configuration router",
+        auth="local (none)",
+        exits="0 success; 2 usage",
+        schema="none (subcommands emit plain text)",
+    ),
+)
+
+
+def _validate_key(key: str) -> str:
+    if key not in CONFIG_KEYS:
+        raise typer.BadParameter(f"Invalid configuration key: {key}", param_hint="key")
+    return key
+
+
+def _load_config_for_command() -> Config:
+    try:
+        return load_config()
+    except ConfigLoadError:
+        raise typer.BadParameter(
+            "Could not load configuration.", param_hint="config"
+        ) from None
+
+
+@app.command(
+    "get",
+    epilog=help_contract(
+        endpoint="local configuration read",
+        auth="local (none)",
+        exits="0 success; 2 usage",
+        schema="none (plain text value)",
+    ),
+)
+def get_config_value(
+    key: Annotated[str, typer.Argument(help="Configuration key to read.")],
+) -> None:
+    """Print one configuration value."""
+    validated_key = _validate_key(key)
+    config = _load_config_for_command()
+    value = getattr(config, validated_key)
+    typer.echo("" if value is None else value)
+
+
+@app.command(
+    "set",
+    epilog=help_contract(
+        endpoint="local configuration write",
+        auth="local (none)",
+        exits="0 success; 2 usage",
+        schema="none (human confirmation on stderr)",
+    ),
+)
+def set_config_value(
+    key: Annotated[str, typer.Argument(help="Configuration key to update.")],
+    value: Annotated[str, typer.Argument(help="New configuration value.")],
+) -> None:
+    """Validate and persist one configuration value."""
+    validated_key = _validate_key(key)
+    try:
+        update_config_value(validated_key, value)
+    except ValidationError:
+        raise typer.BadParameter(
+            f"Invalid value for {validated_key}.", param_hint="value"
+        ) from None
+    except ConfigLoadError:
+        raise typer.BadParameter(
+            "Could not load configuration.", param_hint="config"
+        ) from None
+    except ConfigWriteError:
+        raise typer.BadParameter(
+            "Could not write configuration.", param_hint="config"
+        ) from None
+    typer.echo(f"Set {validated_key}.", err=True)
+
+
+@app.command(
+    "list",
+    epilog=help_contract(
+        endpoint="local configuration read",
+        auth="local (none)",
+        exits="0 success; 2 usage",
+        schema="none (plain text key/value list)",
+    ),
+)
+def list_config_values() -> None:
+    """Print every allowlisted configuration value in deterministic order."""
+    config = _load_config_for_command()
+    for key in sorted(CONFIG_KEYS):
+        value = getattr(config, key)
+        typer.echo(f"{key}={'' if value is None else value}")

solwyn_cli/commands/costs.py

@@ -0,0 +1,186 @@
+"""Aggregated project cost reporting command."""
+
+from enum import StrEnum
+from typing import Annotated, Literal
+from urllib.parse import quote
+
+import typer
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+from solwyn_cli.auth import AuthError, resolve_credential
+from solwyn_cli.client import SolwynClient
+from solwyn_cli.commands._shared import exit_with_error, required_credential
+from solwyn_cli.errors import ApiError
+from solwyn_cli.exit_codes import ErrorSemantic
+from solwyn_cli.help import help_contract
+from solwyn_cli.output import OutputError, TableData
+from solwyn_cli.runtime import command_context, output_engine
+
+
+class CostRange(StrEnum):
+    """Supported aggregate windows frozen for the v1 command."""
+
+    SEVEN_DAYS = "7d"
+    THIRTY_DAYS = "30d"
+    NINETY_DAYS = "90d"
+    YEAR = "365d"
+
+
+class CostGrouping(StrEnum):
+    """Supported aggregate dimensions frozen for the v1 command."""
+
+    DAY = "day"
+    MODEL = "model"
+    PROVIDER = "provider"
+
+
+COSTS_HELP = help_contract(
+    endpoint="GET /api/v1/projects/{project}/costs",
+    auth="any",
+    exits="0 success; 1 generic/API; 2 usage; 3 auth; 5 not found",
+    schema="solwyn.costs.v1",
+)
+
+
+class _CostGroup(BaseModel):
+    model_config = ConfigDict(extra="ignore", hide_input_in_errors=True)
+
+    group_key: str
+    provider: str | None = None
+    total_cost: float
+    total_input_tokens: int
+    total_output_tokens: int
+    call_count: int
+    unpriced_call_count: int = 0
+    local_call_count: int = 0
+
+
+class _CostsData(BaseModel):
+    model_config = ConfigDict(extra="ignore", hide_input_in_errors=True)
+
+    project_id: str
+    range: Literal["7d", "30d", "90d", "365d"]
+    group_by: Literal["day", "model", "provider"]
+    groups: list[_CostGroup]
+
+
+CostsData = _CostsData
+
+
+def fetch_costs(
+    *,
+    client: SolwynClient,
+    project_id: str,
+    time_range: CostRange,
+    group_by: CostGrouping,
+) -> CostsData:
+    """Read and validate one aggregate cost query through a shared client."""
+    project = quote(project_id, safe="")
+    response = client.request(
+        "GET",
+        f"/api/v1/projects/{project}/costs",
+        params={"range": time_range.value, "group_by": group_by.value},
+    )
+    data = _CostsData.model_validate(response.json())
+    if data.project_id != project_id:
+        raise ValueError("Costs response project did not match the request.")
+    return data
+
+
+def _table(data: _CostsData) -> TableData:
+    return TableData(
+        columns=(
+            "Group",
+            "Provider",
+            "Cost",
+            "Input",
+            "Output",
+            "Calls",
+            "Unpriced",
+            "Local",
+        ),
+        rows=tuple(
+            (
+                group.group_key,
+                group.provider or "-",
+                f"{group.total_cost:.6f}",
+                str(group.total_input_tokens),
+                str(group.total_output_tokens),
+                str(group.call_count),
+                str(group.unpriced_call_count),
+                str(group.local_call_count),
+            )
+            for group in data.groups
+        ),
+        right_align=(
+            "Cost",
+            "Input",
+            "Output",
+            "Calls",
+            "Unpriced",
+            "Local",
+        ),
+    )
+
+
+def costs(
+    context: typer.Context,
+    time_range: Annotated[
+        CostRange,
+        typer.Option("--range", help="Aggregation range."),
+    ] = CostRange.SEVEN_DAYS,
+    group_by: Annotated[
+        CostGrouping,
+        typer.Option("--group-by", help="Aggregation dimension."),
+    ] = CostGrouping.MODEL,
+) -> None:
+    """Show aggregate project costs."""
+    runtime = command_context(context)
+    if runtime.project is None:
+        exit_with_error(
+            context,
+            OutputError(
+                code="project_required",
+                message="A project is required.",
+                hint=(
+                    "Choose a project with --project, SOLWYN_PROJECT_ID, "
+                    "or config default_project."
+                ),
+            ),
+            semantic=ErrorSemantic.USAGE,
+        )
+
+    credential = required_credential(context, resolve=resolve_credential)
+    try:
+        with SolwynClient(
+            api_url=runtime.api_url,
+            credential=credential,
+        ) as client:
+            data = fetch_costs(
+                client=client,
+                project_id=runtime.project,
+                time_range=time_range,
+                group_by=group_by,
+            )
+    except ApiError as error:
+        exit_with_error(context, error)
+    except AuthError as error:
+        exit_with_error(
+            context,
+            OutputError(code="authentication_failed", message=str(error)),
+            semantic=ErrorSemantic.AUTH,
+        )
+    except (ValidationError, ValueError, TypeError):
+        exit_with_error(
+            context,
+            OutputError(
+                code="invalid_costs_response",
+                message="The costs response was invalid.",
+            ),
+        )
+
+    output_engine(context).write_success(
+        schema="solwyn.costs.v1",
+        data=data,
+        table=_table(data),
+    )