ocmo-cli 0.8.19__py3-none-any.whl

ocmo_cli/_resolve_series_chart.py

@@ -0,0 +1,409 @@
+"""ASCII resolve-series chart output (simplified frontend ResolveStatsChart)."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import sys
+from dataclasses import dataclass
+from typing import Any, cast
+
+from ._output import format_datetime
+from ._resolve_series import bucket_values
+
+CHART_HEIGHT = 18
+Y_AXIS_WIDTH = 5
+
+_SERIES_MARKERS = {
+    "cyan": "●",
+    "yellow": "◆",
+    "red": "✕",
+}
+_COLLISION_MARKER = "⊕"
+_COLLISION_STYLE = "bold white"
+
+
+@dataclass(frozen=True)
+class _Cell:
+    char: str
+    style: str = ""
+
+
+def _chart_width() -> int:
+    try:
+        columns = shutil.get_terminal_size(fallback=(80, 24)).columns
+    except OSError:
+        columns = 80
+    return max(24, min(columns - Y_AXIS_WIDTH - 2, 96))
+
+
+def _resample(values: list[int], width: int) -> list[int]:
+    if width <= 0:
+        return []
+    if not values:
+        return [0] * width
+    if len(values) <= width:
+        return list(values)
+    result: list[int] = []
+    for index in range(width):
+        start = index * len(values) // width
+        end = (index + 1) * len(values) // width
+        chunk = values[start:end] or [0]
+        result.append(max(chunk))
+    return result
+
+
+def _bucket_x(index: int, count: int, width: int) -> int:
+    """Map bucket index to plot column (spread across full chart width)."""
+    if count <= 1:
+        return width // 2
+    return int(round(index * (width - 1) / (count - 1)))
+
+
+def _series_plot_points(values: list[int], width: int) -> list[tuple[int, int]]:
+    """Return (x, value) pairs covering the full plot width."""
+    if not values or width <= 0:
+        return []
+    if len(values) > width:
+        sampled = _resample(values, width)
+        return [(index, value) for index, value in enumerate(sampled)]
+    return [(_bucket_x(index, len(values), width), value) for index, value in enumerate(values)]
+
+
+def _value_to_row(value: int, *, peak: int, height: int) -> int:
+    if peak <= 0 or value <= 0:
+        return height - 1
+    ratio = value / peak
+    return height - 1 - int(round(ratio * (height - 1)))
+
+
+def _draw_line(
+    grid: list[list[_Cell]],
+    x0: int,
+    y0: int,
+    x1: int,
+    y1: int,
+    *,
+    style: str,
+) -> None:
+    width = len(grid[0])
+    height = len(grid)
+    dx = abs(x1 - x0)
+    dy = -abs(y1 - y0)
+    sx = 1 if x0 < x1 else -1
+    sy = 1 if y0 < y1 else -1
+    err = dx + dy
+    x, y = x0, y0
+    while True:
+        if 0 <= x < width and 0 <= y < height:
+            current = grid[y][x]
+            if current.char in (" ", "·"):
+                grid[y][x] = _Cell("·", style)
+        if x == x1 and y == y1:
+            break
+        e2 = 2 * err
+        if e2 >= dy:
+            err += dy
+            x += sx
+        if e2 <= dx:
+            err += dx
+            y += sy
+
+
+def _place_marker(
+    grid: list[list[_Cell]],
+    x: int,
+    y: int,
+    *,
+    style: str,
+    marker: str,
+) -> None:
+    height = len(grid)
+    width = len(grid[0])
+    if not (0 <= x < width and 0 <= y < height):
+        return
+    current = grid[y][x]
+    if current.char in (" ", "·"):
+        grid[y][x] = _Cell(marker, style)
+        return
+    if current.char == marker and current.style == style:
+        return
+    grid[y][x] = _Cell(_COLLISION_MARKER, _COLLISION_STYLE)
+
+
+def _plot_series(
+    grid: list[list[_Cell]],
+    values: list[int],
+    *,
+    width: int,
+    height: int,
+    peak: int,
+    style: str,
+    marker: str,
+) -> None:
+    plot_points = _series_plot_points(values, width)
+    points = [(x, _value_to_row(value, peak=peak, height=height)) for x, value in plot_points]
+    if not points:
+        return
+    for (x0, y0), (x1, y1) in zip(points, points[1:], strict=False):
+        _draw_line(grid, x0, y0, x1, y1, style=style)
+    for x, value in plot_points:
+        if value <= 0:
+            continue
+        y = _value_to_row(value, peak=peak, height=height)
+        _place_marker(grid, x, y, style=style, marker=marker)
+
+
+def _empty_grid(width: int, height: int) -> list[list[_Cell]]:
+    return [[_Cell(" ") for _ in range(width)] for _ in range(height)]
+
+
+def _y_axis_labels(peak: int, height: int) -> list[str]:
+    if peak <= 0:
+        return ["0"] * height
+    labels: list[str] = []
+    for row in range(height):
+        value = int(round(peak * (height - 1 - row) / max(height - 1, 1)))
+        labels.append(str(value))
+    return labels
+
+
+def _build_chart_grid(
+    direct: list[int],
+    nested: list[int],
+    errors: list[int],
+    *,
+    width: int,
+    show_nested: bool,
+) -> tuple[list[list[_Cell]], int]:
+    peak = max(1, *direct, *nested, *errors)
+    grid = _empty_grid(width, CHART_HEIGHT)
+    _plot_series(
+        grid,
+        errors,
+        width=width,
+        height=CHART_HEIGHT,
+        peak=peak,
+        style="red",
+        marker=_SERIES_MARKERS["red"],
+    )
+    if show_nested:
+        _plot_series(
+            grid,
+            nested,
+            width=width,
+            height=CHART_HEIGHT,
+            peak=peak,
+            style="yellow",
+            marker=_SERIES_MARKERS["yellow"],
+        )
+    _plot_series(
+        grid,
+        direct,
+        width=width,
+        height=CHART_HEIGHT,
+        peak=peak,
+        style="cyan",
+        marker=_SERIES_MARKERS["cyan"],
+    )
+    return grid, peak
+
+
+def _x_axis_tick_row(bucket_count: int, width: int) -> list[_Cell]:
+    """One tick per bucket column; duplicate x positions share a single tick."""
+    row = [_Cell("─", "dim") for _ in range(width)]
+    if bucket_count <= 0:
+        return row
+    for index in range(bucket_count):
+        x = _bucket_x(index, bucket_count, width)
+        if 0 <= x < width:
+            row[x] = _Cell("┴", "dim")
+    return row
+
+
+def _bucket_axis_labels(buckets: list[dict[str, Any]]) -> tuple[str, str]:
+    if not buckets:
+        return "", ""
+    left = format_datetime(buckets[0].get("start"))
+    right = format_datetime(buckets[-1].get("start"))
+    return left, right
+
+
+def _direct_label(node_type: str) -> str:
+    return "Resolves" if node_type == "resolver" else "Direct"
+
+
+def _use_color() -> bool:
+    if os.environ.get("NO_COLOR") or os.environ.get("OCMO_NO_COLOR"):
+        return False
+    return sys.stdout.isatty()
+
+
+def _format_bucket_rows(
+    buckets: list[dict[str, Any]],
+) -> list[tuple[str, str, str, str]]:
+    rows: list[tuple[str, str, str, str]] = []
+    for bucket in buckets:
+        rows.append(
+            (
+                format_datetime(bucket.get("start")),
+                str(int(bucket.get("direct") or 0)),
+                str(int(bucket.get("nested") or 0)),
+                str(int(bucket.get("errors") or 0)),
+            )
+        )
+    return rows
+
+
+def _print_plain_bucket_table(
+    rows: list[tuple[str, str, str, str]],
+    *,
+    show_nested: bool,
+    direct_label: str,
+) -> None:
+    if show_nested:
+        headers: tuple[str, ...] = ("When", direct_label, "Nested", "Errors")
+        data_rows = cast(list[tuple[str, ...]], rows)
+    else:
+        headers = ("When", direct_label, "Errors")
+        data_rows = [(when, direct, errors) for when, direct, _nested, errors in rows]
+
+    widths = [len(header) for header in headers]
+    for row in data_rows:
+        for index, cell in enumerate(row):
+            widths[index] = max(widths[index], len(cell))
+
+    def _line(cells: tuple[str, ...]) -> str:
+        parts = [
+            cells[0].ljust(widths[0]),
+            *[cells[i].rjust(widths[i]) for i in range(1, len(cells))],
+        ]
+        return "  ".join(parts)
+
+    print(_line(headers))
+    print(_line(tuple("-" * width for width in widths)))
+    for row in data_rows:
+        print(_line(row))
+
+
+def print_resolve_series_chart(
+    data: dict[str, Any],
+    *,
+    node_type: str,
+    range_start: Any,
+    range_end: Any,
+) -> None:
+    """Print a coloured line chart and per-bucket value table to stdout."""
+    buckets, direct, nested, errors = bucket_values(data)
+    width = _chart_width()
+    show_nested = node_type != "resolver"
+    direct_label = _direct_label(node_type)
+
+    totals = {
+        "direct": sum(direct),
+        "nested": sum(nested),
+        "errors": sum(errors),
+    }
+    has_activity = any(value > 0 for series in (direct, nested, errors) for value in series)
+
+    start_label = format_datetime(range_start)
+    end_label = format_datetime(range_end)
+    grid, peak = _build_chart_grid(
+        direct,
+        nested,
+        errors,
+        width=width,
+        show_nested=show_nested,
+    )
+    y_labels = _y_axis_labels(peak, CHART_HEIGHT)
+    tick_row = _x_axis_tick_row(len(buckets), width)
+    axis_left, axis_right = _bucket_axis_labels(buckets)
+    bucket_rows = _format_bucket_rows(buckets)
+
+    if _use_color():
+        from rich.console import Console
+        from rich.table import Table
+        from rich.text import Text
+
+        console = Console()
+        header = Text()
+        header.append("Resolves  ", style="bold")
+        header.append(f"{start_label} – {end_label}")
+        console.print(header)
+
+        legend = Text("  ")
+        legend.append("● ", style="bold cyan")
+        legend.append(f"{direct_label} {totals['direct']}  ")
+        if show_nested:
+            legend.append("◆ ", style="bold yellow")
+            legend.append(f"Nested {totals['nested']}  ")
+        legend.append("✕ ", style="bold red")
+        legend.append(f"Errors {totals['errors']}  ")
+        legend.append("⊕ ", style="bold white")
+        legend.append("overlap")
+        console.print(legend)
+
+        for row_index in range(CHART_HEIGHT):
+            line = Text()
+            line.append(f"{y_labels[row_index]:>{Y_AXIS_WIDTH}} ", style="dim")
+            for cell in grid[row_index]:
+                line.append(cell.char, style=cell.style or None)
+            console.print(line)
+
+        tick_line = Text()
+        tick_line.append(" " * (Y_AXIS_WIDTH + 1))
+        for cell in tick_row:
+            tick_line.append(cell.char, style=cell.style or "dim")
+        console.print(tick_line)
+
+        axis = Text(" " * (Y_AXIS_WIDTH + 1))
+        axis.append(axis_left, style="dim")
+        if axis_right and axis_right != axis_left:
+            axis.append(" " * max(1, width - len(axis_left) - len(axis_right)), style="dim")
+            axis.append(axis_right, style="dim")
+        console.print(axis)
+
+        if buckets and not has_activity:
+            console.print("No resolve activity in this range", style="dim")
+        elif bucket_rows:
+            table = Table(show_header=True, header_style="bold", pad_edge=False)
+            table.add_column("When", style="dim", no_wrap=True)
+            table.add_column(direct_label, justify="right", style="cyan")
+            if show_nested:
+                table.add_column("Nested", justify="right", style="yellow")
+            table.add_column("Errors", justify="right", style="red")
+            for when, d_val, n_val, e_val in bucket_rows:
+                if show_nested:
+                    table.add_row(when, d_val, n_val, e_val)
+                else:
+                    table.add_row(when, d_val, e_val)
+            console.print()
+            console.print(table)
+        return
+
+    print(f"Resolves  {start_label} – {end_label}")
+    legend_parts = [f"{direct_label} {totals['direct']}"]
+    if show_nested:
+        legend_parts.append(f"Nested {totals['nested']}")
+    legend_parts.append(f"Errors {totals['errors']}")
+    print("  " + "  ".join(legend_parts) + "  ⊕ overlap")
+
+    for row_index in range(CHART_HEIGHT):
+        body = "".join(cell.char for cell in grid[row_index])
+        print(f"{y_labels[row_index]:>{Y_AXIS_WIDTH}} {body}")
+    print(f"{' ' * Y_AXIS_WIDTH} {''.join(cell.char for cell in tick_row)}")
+    print(f"{' ' * (Y_AXIS_WIDTH + 1)}{axis_left}", end="")
+    if axis_right and axis_right != axis_left:
+        print(f"{' ' * max(1, width - len(axis_left) - len(axis_right))}{axis_right}")
+    else:
+        print()
+
+    if buckets and not has_activity:
+        print("No resolve activity in this range")
+    elif bucket_rows:
+        print()
+        _print_plain_bucket_table(
+            bucket_rows,
+            show_nested=show_nested,
+            direct_label=direct_label,
+        )

ocmo_cli/_resolve_write.py

@@ -0,0 +1,185 @@
+"""Filesystem output for ``ocmo resolve``."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Literal
+
+from ._typing import ResolvedArtifact
+
+WriteResult = Literal["created", "skipped", "rewritten", "failed"]
+
+
+@dataclass(frozen=True)
+class ResolveWriteOutcome:
+    item: ResolvedArtifact
+    path: Path
+    result: WriteResult
+    detail: str | None = None
+
+
+def _absolute_path(path: Path) -> Path:
+    return path.resolve()
+
+
+def _outcome(
+    item: ResolvedArtifact,
+    dest: Path,
+    result: WriteResult,
+    detail: str | None = None,
+) -> ResolveWriteOutcome:
+    return ResolveWriteOutcome(item, _absolute_path(dest), result, detail)
+
+
+def parse_checksum(checksum: str | None) -> tuple[str, str] | None:
+    if not checksum:
+        return None
+    if ":" in checksum:
+        algo, expected = checksum.split(":", 1)
+        return algo, expected
+    return "sha256", checksum
+
+
+def digest_bytes(data: bytes, algo: str = "sha256") -> str:
+    return hashlib.new(algo, data).hexdigest()
+
+
+def _file_digest(path: Path, algo: str) -> str:
+    return digest_bytes(path.read_bytes(), algo)
+
+
+def file_matches_checksum(path: Path, checksum: str | None) -> bool:
+    parsed = parse_checksum(checksum)
+    if parsed is None or not path.is_file():
+        return False
+    algo, expected = parsed
+    return _file_digest(path, algo) == expected
+
+
+def _safe_join(base: Path, name: str) -> Path:
+    if os.path.isabs(name):
+        raise ValueError(f"Absolute path in server response: {name!r}")
+    resolved = (base / name).resolve()
+    if not str(resolved).startswith(str(base.resolve())):
+        raise ValueError(f"Path traversal detected: {name!r} escapes {base}")
+    return base / name
+
+
+def atomic_write(path: Path, data: bytes) -> None:
+    tmp = Path(str(path) + ".tmp")
+    try:
+        with tmp.open("wb") as f:
+            f.write(data)
+        tmp.replace(path)
+    except Exception:
+        tmp.unlink(missing_ok=True)
+        raise
+
+
+def save_resolve_item(
+    item: ResolvedArtifact,
+    dest: Path,
+    *,
+    rewrite: bool,
+    skip_existing: bool,
+    data: bytes | None = None,
+    skip_checksum: bool = False,
+) -> ResolveWriteOutcome:
+    """Save one resolved artifact with checksum-aware idempotency."""
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    checksum = None if skip_checksum else getattr(item, "checksum", None)
+
+    if not skip_checksum and dest.is_file() and file_matches_checksum(dest, checksum):
+        return _outcome(item, dest, "skipped", "unchanged")
+
+    payload = data if data is not None else item.bytes
+
+    if dest.is_file():
+        if payload == dest.read_bytes():
+            return _outcome(item, dest, "skipped", "unchanged")
+        if skip_existing:
+            return _outcome(item, dest, "skipped", "exists")
+        if not rewrite:
+            return _outcome(item, dest, "failed", "file exists and differs")
+        atomic_write(dest, payload)
+        return _outcome(item, dest, "rewritten")
+
+    atomic_write(dest, payload)
+    return _outcome(item, dest, "created")
+
+
+def resolve_item_dest(
+    item: ResolvedArtifact,
+    *,
+    output_file: str | None,
+    output_dir: str,
+) -> Path:
+    if output_file:
+        return Path(output_file)
+    name = getattr(item, "name", None) or str(item)
+    return _safe_join(Path(output_dir), name)
+
+
+def write_resolve_items(
+    items: Sequence[ResolvedArtifact],
+    *,
+    output_file: str | None = None,
+    output_dir: str | None = None,
+    rewrite: bool = False,
+    skip_existing: bool = False,
+    item_data: Callable[[ResolvedArtifact], tuple[bytes, bool]] | None = None,
+) -> list[ResolveWriteOutcome]:
+    if output_file and output_dir:
+        raise ValueError("Specify only one of output_file or output_dir")
+    if output_file:
+        if len(items) != 1:
+            raise ValueError("output_file requires exactly one resolved item")
+        item = items[0]
+        data, skip_checksum = _item_write_options(item, item_data)
+        return [
+            save_resolve_item(
+                item,
+                resolve_item_dest(item, output_file=output_file, output_dir="."),
+                rewrite=rewrite,
+                skip_existing=skip_existing,
+                data=data,
+                skip_checksum=skip_checksum,
+            )
+        ]
+
+    if not output_dir:
+        raise ValueError("output_dir is required when output_file is not set")
+
+    out = Path(output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    outcomes: list[ResolveWriteOutcome] = []
+    for item in items:
+        data, skip_checksum = _item_write_options(item, item_data)
+        dest = resolve_item_dest(item, output_file=None, output_dir=output_dir)
+        outcomes.append(
+            save_resolve_item(
+                item,
+                dest,
+                rewrite=rewrite,
+                skip_existing=skip_existing,
+                data=data,
+                skip_checksum=skip_checksum,
+            )
+        )
+    return outcomes
+
+
+def _item_write_options(
+    item: ResolvedArtifact,
+    item_data: Callable[[ResolvedArtifact], tuple[bytes, bool]] | None,
+) -> tuple[bytes, bool]:
+    if item_data is None:
+        return item.bytes, False
+    if not callable(item_data):
+        raise TypeError("item_data must be callable")
+    data, skip_checksum = item_data(item)
+    return data, skip_checksum

ocmo_cli/_resolver_output.py

@@ -0,0 +1,34 @@
+"""Print resolver tokens returned once on create or rotation."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ._output import as_dict
+
+_TOKEN_FIELDS = ("token1", "token")
+
+
+def resolver_token_from_result(result: Any) -> str | None:
+    """Return a full resolver token from a create/rotate API response."""
+    if result is None:
+        return None
+
+    data = as_dict(result, fallback_vars=False)
+    if not data:
+        return None
+
+    for key in _TOKEN_FIELDS:
+        value = data.get(key)
+        if isinstance(value, str) and value and not value.startswith("ocmo***"):
+            return value
+    return None
+
+
+def print_resolver_token(result: Any) -> bool:
+    """Print a resolver token to stdout when present. Returns whether anything was printed."""
+    token = resolver_token_from_result(result)
+    if not token:
+        return False
+    print(token)
+    return True

ocmo_cli/_resource_aliases.py

@@ -0,0 +1,22 @@
+"""Canonical resource name aliases for CLI command groups."""
+
+from __future__ import annotations
+
+RESOURCE_ALIASES: dict[str, list[str]] = {
+    "namespace": ["ns", "namespaces"],
+    "config": ["cfg", "configs"],
+    "template": ["tpl", "templates"],
+    "secret": ["sec", "secrets"],
+    "resolver": ["rsv", "resolvers"],
+    "folder": ["dir", "folders"],
+    "item": [],
+    "lock": ["locks"],
+    "version": ["ver", "versions"],
+    "audit": ["events"],
+    "globalpermission": ["gp", "globalpermissions"],
+    "cast": [],
+    "tree": [],
+    "parameters": [],
+    "draft": [],
+    "token": [],
+}