ocmo-cli 0.8.19__py3-none-any.whl

ocmo_cli/_config_content.py

@@ -0,0 +1,43 @@
+"""Normalize config document bodies before upload."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from ._output import yaml_dumps
+
+_CONFIG_METADATA_KEY = "_ocmo"
+
+
+def prepare_config_apply_content(content: str, *, source_name: str) -> str:
+    """Convert JSON config sources to YAML syntax for storage."""
+    if not _is_json_config_source(source_name, content):
+        return content
+
+    try:
+        doc = json.loads(content)
+    except json.JSONDecodeError:
+        return content
+
+    if isinstance(doc, dict):
+        _inject_json_cast_metadata(doc)
+
+    return yaml_dumps(doc)
+
+
+def _is_json_config_source(source_name: str, content: str) -> bool:
+    if source_name != "<stdin>":
+        return source_name.lower().endswith(".json")
+    stripped = content.lstrip()
+    return stripped.startswith("{") or stripped.startswith("[")
+
+
+def _inject_json_cast_metadata(doc: dict[str, Any]) -> None:
+    """Preserve JSON resolve semantics when the on-disk source was JSON."""
+    existing = doc.get(_CONFIG_METADATA_KEY)
+    cast_block = {"format": "json"}
+    if existing is None:
+        doc[_CONFIG_METADATA_KEY] = {"cast": cast_block}
+    elif isinstance(existing, dict) and "cast" not in existing:
+        doc[_CONFIG_METADATA_KEY] = {**existing, "cast": cast_block}

ocmo_cli/_delete_item_output.py

@@ -0,0 +1,129 @@
+"""Output formatting for ``ocmo delete item``."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ._output import emit, emit_table
+from ._output_manifest import get_command_spec, resolve_effective_format
+
+_DELETE_PREVIEW_RE = re.compile(r"^[^:]+::\s*(\w+)::\s*(.+)$")
+
+_TYPE_BY_LABEL = {
+    "folder": "folder",
+    "config": "config",
+    "template": "template",
+    "secret": "secret",
+    "resolver": "resolver",
+}
+
+
+def _split_path_version(raw_path: str) -> tuple[str, int | None]:
+    if "@" not in raw_path:
+        return raw_path, None
+    path, suffix = raw_path.rsplit("@", 1)
+    if suffix.isdigit():
+        return path, int(suffix)
+    return raw_path, None
+
+
+def parse_delete_preview_line(line: str) -> dict[str, Any]:
+    """Parse API delete lines like ``my-ns:: Config:: app/foo``."""
+    trimmed = line.strip()
+    match = _DELETE_PREVIEW_RE.match(trimmed)
+    if not match:
+        path = trimmed
+        node_type = "config"
+    else:
+        node_type = _TYPE_BY_LABEL.get(match[1].lower(), "config")
+        path = match[2]
+
+    path, version_number = _split_path_version(path)
+    name = path.rsplit("/", 1)[-1] if path else path
+    entry: dict[str, Any] = {"path": path, "name": name, "node_type": node_type}
+    if version_number is not None:
+        entry["version"] = version_number
+    return entry
+
+
+def parse_delete_preview_lines(lines: list[str]) -> list[dict[str, Any]]:
+    return [parse_delete_preview_line(line) for line in lines]
+
+
+def _normalize_path(path: str) -> str:
+    return path.strip("/")
+
+
+def is_folder_delete(entries: list[dict[str, Any]], target_path: str | None) -> bool:
+    if not target_path:
+        return False
+    norm = _normalize_path(target_path)
+    return any(
+        entry.get("node_type") == "folder" and _normalize_path(entry.get("path") or "") == norm for entry in entries
+    )
+
+
+def delete_item_table_rows(entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for entry in entries:
+        row: dict[str, Any] = {
+            "type": entry.get("node_type") or "",
+            "path": entry.get("path") or "",
+        }
+        if entry.get("version") is not None:
+            row["version"] = entry["version"]
+        rows.append(row)
+    rows.sort(key=lambda row: (row["path"], row.get("version") or 0))
+    return rows
+
+
+def delete_item_table_columns(rows: list[dict[str, Any]]) -> list[str]:
+    if any(row.get("version") is not None for row in rows):
+        return ["type", "version", "path"]
+    return ["type", "path"]
+
+
+def emit_delete_item_output(
+    result: Any,
+    *,
+    target_path: str | None,
+    version: str | None,
+    output_fmt: str | None,
+    ctx_fmt: str | None,
+) -> None:
+    """Render delete results as ``ocmo tree`` (folders) or ``ocmo ls`` (other items)."""
+    from .commands.ls import _build_tree_hierarchy, _render_plain_tree
+
+    command_key = "delete item"
+    spec = get_command_spec(command_key)
+    effective_fmt = resolve_effective_format(output_fmt, ctx_fmt, spec)
+
+    delete_lines = list(getattr(result, "delete", None) or [])
+    entries = parse_delete_preview_lines(delete_lines)
+
+    use_tree = effective_fmt == "table" and version is None and is_folder_delete(entries, target_path)
+
+    if use_tree:
+        tree_rows = _build_tree_hierarchy(entries)
+        _render_plain_tree(tree_rows, prefix="", connector="", use_emoji=False)
+        return
+
+    rows = delete_item_table_rows(entries)
+
+    if effective_fmt == "table":
+        emit_table(rows, delete_item_table_columns(rows))
+        return
+
+    if effective_fmt == "name":
+        for entry in entries:
+            print(entry.get("path") or "")
+        return
+
+    if effective_fmt == "path":
+        for entry in entries:
+            print(entry.get("path") or "")
+        return
+
+    payload = {"delete": entries}
+    emit(payload, effective_fmt)

ocmo_cli/_diff_input.py

@@ -0,0 +1,144 @@
+"""Parse ``ocmo diff`` addresses and render unified diff output."""
+
+from __future__ import annotations
+
+import difflib
+from dataclasses import dataclass
+from typing import Any
+
+from ocmo._generated.types import UNSET
+
+from ._address import AddressError, _validate_path, parse_address
+
+
+@dataclass(frozen=True)
+class DiffSpec:
+    path: str
+    from_ref: str | None = None
+    to_ref: str | None = None
+    to_path: str | None = None
+
+
+def diff_sdk_kwargs(spec: DiffSpec, *, reveal: bool = False) -> tuple[str, dict[str, Any]]:
+    """Return ``(path, kwargs)`` for ``NamespaceView.diff_item``."""
+    kwargs: dict[str, Any] = {}
+    if spec.from_ref is not None:
+        kwargs["from_"] = spec.from_ref
+    if spec.to_ref is not None:
+        kwargs["to"] = spec.to_ref
+    if spec.to_path is not None:
+        kwargs["to_path"] = spec.to_path
+    if reveal:
+        kwargs["reveal"] = True
+    return spec.path, kwargs
+
+
+def parse_diff_spec(
+    addresses: tuple[str, ...],
+    *,
+    version_flag: str | None = None,
+    from_version: str | None = None,
+    to_version: str | None = None,
+) -> DiffSpec:
+    """Resolve diff operands from positional addresses and version flags."""
+    if not addresses:
+        raise AddressError("At least one address is required.")
+    if len(addresses) > 2:
+        raise AddressError("Expected one or two addresses.")
+
+    if len(addresses) == 2:
+        if version_flag:
+            raise AddressError(
+                "Cannot use --version with two addresses; " "use @suffix or --from-version / --to-version."
+            )
+        if ".." in addresses[0] or ".." in addresses[1]:
+            raise AddressError("Version range (..) is only supported with a single address.")
+        from_path, from_ref = parse_address(addresses[0])
+        to_path, to_ref = parse_address(addresses[1])
+        return DiffSpec(
+            path=from_path,
+            from_ref=from_version or from_ref,
+            to_ref=to_version or to_ref,
+            to_path=to_path if to_path != from_path else None,
+        )
+
+    raw = addresses[0]
+    if "@" in raw:
+        path, version_part = raw.split("@", 1)
+        if ".." in version_part:
+            if version_flag:
+                raise AddressError(
+                    f"Conflicting version specifications: address suffix '@{version_part}' "
+                    f"and --version '{version_flag}'. Provide only one."
+                )
+            _validate_path(path)
+            range_from, range_to = _parse_version_range(version_part)
+            return DiffSpec(
+                path=path,
+                from_ref=from_version or range_from,
+                to_ref=to_version or range_to,
+            )
+
+    path, version = parse_address(raw, version_flag=version_flag)
+    return DiffSpec(
+        path=path,
+        from_ref=from_version,
+        to_ref=to_version or version,
+    )
+
+
+def _parse_version_range(version_part: str) -> tuple[str, str]:
+    left, sep, right = version_part.partition("..")
+    if not sep or not left or not right:
+        raise AddressError(f"Invalid version range '@{version_part}'; expected path@FROM..TO.")
+    return left, right
+
+
+def diff_side_label(side: Any) -> str:
+    requested = getattr(side, "requested", None) or ""
+    path = getattr(side, "path", "")
+    if requested:
+        return f"{path}@{requested}"
+    version = getattr(side, "version", None)
+    if version is not None:
+        return f"{path}@v{version}"
+    return path
+
+
+def _side_text(side: Any) -> str:
+    data = getattr(side, "data", UNSET)
+    if data is UNSET or data is None:
+        return ""
+    return str(data)
+
+
+def render_unified_diff(from_text: str, to_text: str, *, from_label: str, to_label: str) -> str:
+    if from_text == to_text:
+        return "No differences\n"
+    lines = difflib.unified_diff(
+        from_text.splitlines(keepends=True),
+        to_text.splitlines(keepends=True),
+        fromfile=from_label,
+        tofile=to_label,
+    )
+    rendered = "".join(lines)
+    return rendered or "No differences\n"
+
+
+def render_diff_response(result: Any) -> str:
+    """Build unified diff text from an SDK ``DiffResponseSchema``."""
+    if getattr(result, "decryption_required", False):
+        return ""
+
+    from_text = _side_text(result.from_side)
+    to_text = _side_text(result.to_side)
+
+    if getattr(result, "identical", False) is True:
+        return "No differences\n"
+
+    return render_unified_diff(
+        from_text,
+        to_text,
+        from_label=diff_side_label(result.from_side),
+        to_label=diff_side_label(result.to_side),
+    )

ocmo_cli/_dry_run.py

@@ -0,0 +1,292 @@
+"""User-facing dry-run plan messages for CLI commands."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def quote(value: str) -> str:
+    return f"'{value}'"
+
+
+def namespace_clause(namespace: str | None, *, client_scope: bool) -> str:
+    if client_scope or not namespace:
+        return ""
+    return f" in namespace {quote(namespace)}"
+
+
+def versioned_path(path: str | None, version: str | None) -> str:
+    if not path:
+        return "?"
+    if version:
+        return f"{quote(path)}@{version}"
+    return quote(path)
+
+
+def file_clause(file_path: str | None) -> str:
+    if not file_path:
+        return ""
+    label = "<stdin>" if file_path == "-" else file_path
+    return f" from {quote(label)}"
+
+
+def body_dict(kwargs: dict[str, Any]) -> dict[str, Any]:
+    body = kwargs.get("body")
+    return body if isinstance(body, dict) else {}
+
+
+def primary_target(
+    op_id: str,
+    *,
+    path: str | None,
+    args: list[Any],
+    kwargs: dict[str, Any],
+) -> str | None:
+    if path:
+        return path
+    if args:
+        return str(args[0])
+    for key in ("path", "name", "id", "namespace"):
+        value = kwargs.get(key)
+        if value not in (None, ""):
+            return str(value)
+    payload = body_dict(kwargs)
+    for key in ("name", "id", "path"):
+        value = payload.get(key)
+        if value not in (None, ""):
+            return str(value)
+    return None
+
+
+def format_generated_dry_run(
+    *,
+    op_id: str,
+    action: str,
+    resource: str,
+    path: str | None,
+    version: str | None,
+    namespace: str | None,
+    args: list[Any],
+    kwargs: dict[str, Any],
+    client_scope: bool,
+    file_path: str | None = None,
+    gp_create_position: float | None = None,
+    cast_format: str | None = None,
+) -> list[str]:
+    """Return human-readable dry-run plan lines (without the ``[dry-run]`` prefix)."""
+    ns = namespace_clause(namespace, client_scope=client_scope)
+    target = primary_target(op_id, path=path, args=args, kwargs=kwargs)
+    payload = body_dict(kwargs)
+    lines: list[str] = []
+
+    if op_id == "create_namespace":
+        name = target or "?"
+        line = f"Would create namespace {quote(name)}."
+        description = payload.get("description")
+        if description:
+            line += f" Description: {description!r}."
+        lines.append(line)
+        return lines
+
+    if op_id == "update_namespace":
+        lines.append(f"Would update namespace {quote(target or '?')}.")
+        return lines
+
+    if op_id == "delete_namespace":
+        lines.append(f"Would delete namespace {quote(target or '?')}.")
+        return lines
+
+    if op_id == "create_global_permission":
+        rule_id = target or payload.get("id") or "?"
+        lines.append(f"Would create global permission rule {quote(str(rule_id))}{file_clause(file_path)}.")
+        if gp_create_position is not None:
+            lines.append(f"Would set rule position to {gp_create_position}.")
+        return lines
+
+    if op_id == "update_global_permission":
+        lines.append(f"Would update global permission rule {quote(target or '?')}{file_clause(file_path)}.")
+        return lines
+
+    if op_id == "delete_global_permission":
+        lines.append(f"Would delete global permission rule {quote(target or '?')}.")
+        return lines
+
+    if op_id == "move_global_permission":
+        position = payload.get("position", kwargs.get("position"))
+        pos_text = f" to position {position}" if position is not None else ""
+        lines.append(f"Would move global permission rule {quote(target or '?')}{pos_text}.")
+        return lines
+
+    if op_id == "move_item":
+        destination = payload.get("target_path") or kwargs.get("target_path")
+        dest = str(destination or "?")
+        lines.append(f"Would move item {quote(target or '?')} to {quote(dest)}{ns}.")
+        lines.append(f"After move, item will be available at {quote(dest)}.")
+        return lines
+
+    if op_id == "copy_item":
+        destination = payload.get("target_path") or kwargs.get("target_path")
+        dest = str(destination or "?")
+        tag = kwargs.get("tag_to_copy")
+        tag_text = f" (tag {quote(str(tag))})" if tag else ""
+        lines.append(f"Would copy item {quote(target or '?')} to {quote(dest)}" f"{tag_text}{ns}.")
+        lines.append(f"After copy, item will be available at {quote(dest)}.")
+        return lines
+
+    if op_id == "set_tag":
+        if action == "untag":
+            tag = kwargs.get("tag")
+            body = kwargs.get("body")
+            if tag is None and isinstance(body, dict):
+                tag = body.get("tag")
+            lines.append(f"Would remove tag {quote(str(tag or '?'))} from item {quote(target or '?')}{ns}.")
+            return lines
+        tag = kwargs.get("tag")
+        body = kwargs.get("body")
+        if tag is None and isinstance(body, dict):
+            tag = body.get("tag")
+        lines.append(f"Would tag item {quote(target or '?')} as {quote(str(tag or '?'))}{ns}.")
+        return lines
+
+    if op_id == "rotate_resolver_token":
+        token_number = kwargs.get("token_number")
+        token_text = f" (token #{token_number})" if token_number is not None else ""
+        lines.append(f"Would rotate resolver token for {quote(target or '?')}{token_text}{ns}.")
+        return lines
+
+    if op_id == "create_lock":
+        reason = payload.get("reason") or kwargs.get("reason")
+        reason_text = f" (reason: {reason!r})" if reason else ""
+        expires = payload.get("expires_at") or kwargs.get("expires_at")
+        expires_text = f", expires {expires}" if expires else ""
+        lines.append(f"Would create lock on {quote(target or '?')}{reason_text}{expires_text}{ns}.")
+        return lines
+
+    if op_id == "replace_lock":
+        reason = payload.get("reason") or kwargs.get("reason")
+        reason_text = f" (reason: {reason!r})" if reason else ""
+        expires = payload.get("expires_at") or kwargs.get("expires_at")
+        expires_text = f", expires {expires}" if expires else ""
+        lines.append(f"Would update lock on {quote(target or '?')}{reason_text}{expires_text}{ns}.")
+        return lines
+
+    if op_id == "delete_lock":
+        lines.append(f"Would remove lock on {quote(target or '?')}{ns}.")
+        return lines
+
+    if op_id == "search_root" and resource == "item":
+        types = kwargs.get("types") or []
+        limit = kwargs.get("limit")
+        type_text = f" (types: {', '.join(types)})" if types else ""
+        limit_text = f", limit {limit}" if limit is not None else ""
+        lines.append(f"Would list items{type_text}{limit_text}{ns}.")
+        return lines
+
+    if op_id == "list_cast_formats" and resource == "cast":
+        if cast_format:
+            lines.append(f"Would show cast format schema for {quote(cast_format)}{ns}.")
+        else:
+            lines.append(f"Would list cast formats{ns}.")
+        return lines
+
+    if op_id == "propagate_config":
+        lines.append(f"Would propagate config {versioned_path(target, version)} to descendants{ns}.")
+        return lines
+
+    if op_id == "delete_item":
+        if version:
+            lines.append(
+                f"Would delete version {quote(version)} of item {quote(target or '?')}{ns} " f"(not the item itself)."
+            )
+        else:
+            lines.append(f"Would delete item {quote(target or '?')}{ns}.")
+        return lines
+
+    resource_label = _RESOURCE_LABELS.get(resource, resource)
+    if action == "create":
+        lines.append(
+            f"Would create {resource_label} {versioned_path(target, version)}" f"{file_clause(file_path)}{ns}."
+        )
+        return lines
+
+    if action == "update":
+        lines.append(
+            f"Would update {resource_label} {versioned_path(target, version)}" f"{file_clause(file_path)}{ns}."
+        )
+        return lines
+
+    if action == "delete":
+        lines.append(f"Would delete {resource_label} {versioned_path(target, version)}{ns}.")
+        return lines
+
+    lines.append(f"Would {action} {resource_label} {versioned_path(target, version)}{ns}.")
+    return lines
+
+
+def format_apply_dry_run(
+    *,
+    kind: str,
+    path: str,
+    source_name: str,
+    namespace: str | None,
+) -> str:
+    ns = namespace_clause(namespace, client_scope=False)
+    return f"Would create or update {kind} {quote(path)} from {quote(source_name)}{ns}."
+
+
+def format_resolve_dry_run(
+    *,
+    path: str,
+    namespace: str,
+    cast: str | None = None,
+    parameters: dict[str, Any] | None = None,
+) -> list[str]:
+    lines = [f"Would resolve {quote(path)} in namespace {quote(namespace)}."]
+    if cast:
+        lines.append(f"Cast output as {cast}.")
+    if parameters:
+        params = ", ".join(f"{key}={value!r}" for key, value in sorted(parameters.items()))
+        lines.append(f"Parameters: {params}.")
+    return lines
+
+
+def format_describe_dry_run(*, path: str, namespace: str | None, char_count: int) -> str:
+    ns = namespace_clause(namespace, client_scope=False)
+    return f"Would update description for {quote(path)}{ns} ({char_count} characters)."
+
+
+def format_edit_dry_run(*, resource: str, path: str, namespace: str | None) -> str:
+    ns = namespace_clause(namespace, client_scope=False)
+    label = _RESOURCE_LABELS.get(resource, resource)
+    return f"Would edit {label} {quote(path)} via $EDITOR{ns}."
+
+
+def format_export_dry_run(*, item_path: str, dest_file: str, namespace: str) -> str:
+    return f"Would export {quote(item_path)} from namespace {quote(namespace)} " f"to {quote(dest_file)}."
+
+
+def format_import_dry_run_header(count: int) -> str:
+    return f"Would import {count} item{'s' if count != 1 else ''}:"
+
+
+_RESOURCE_LABELS: dict[str, str] = {
+    "namespace": "namespace",
+    "globalpermission": "global permission rule",
+    "config": "config",
+    "template": "template",
+    "secret": "secret",
+    "resolver": "resolver",
+    "item": "item",
+    "lock": "lock",
+    "token": "resolver token",
+}
+
+
+def emit_dry_run_plan(lines: list[str] | str) -> None:
+    """Print one or more dry-run plan lines to stderr."""
+    from ._output import status  # deferred
+
+    if isinstance(lines, str):
+        lines = [lines]
+    for line in lines:
+        status(f"[dry-run] {line}")