ocmo-cli 0.8.19__py3-none-any.whl

ocmo_cli/_import_plan.py

@@ -0,0 +1,221 @@
+"""Import plan building and validation."""
+
+from __future__ import annotations
+
+import fnmatch
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from ._import_metadata import import_file_text, metadata_tree_path, read_file_metadata
+
+if TYPE_CHECKING:
+    from ocmo import NamespaceView
+
+VALID_IMPORT_TYPES = frozenset({"config", "template", "secret", "resolver"})
+
+
+def try_parse_config_document(content_bytes: bytes) -> tuple[dict[str, Any] | None, bool]:
+    """Return ``(document, is_json)`` when *content_bytes* is a YAML/JSON object."""
+    text = content_bytes.decode("utf-8", errors="replace")
+    try:
+        doc = json.loads(text)
+        if isinstance(doc, dict):
+            return doc, True
+    except json.JSONDecodeError:
+        pass
+
+    import yaml  # deferred
+
+    try:
+        doc = yaml.safe_load(text)
+    except Exception:
+        return None, False
+    if isinstance(doc, dict):
+        return doc, False
+    return None, False
+
+
+def classify_file_kind(content_bytes: bytes) -> str:
+    """Classify a source file as ``config`` or ``template`` by parsing content."""
+    doc, _ = try_parse_config_document(content_bytes)
+    return "config" if doc is not None else "template"
+
+
+def parse_type_override(spec: str) -> tuple[str, str]:
+    """Parse ``GLOB=TYPE`` from ``--type-override``."""
+    if "=" not in spec:
+        raise ValueError(f"expected GLOB=TYPE, got {spec!r}")
+    pattern, item_type = spec.split("=", 1)
+    pattern = pattern.strip()
+    item_type = item_type.strip().lower()
+    if not pattern:
+        raise ValueError(f"type override pattern must not be empty in {spec!r}")
+    _validate_import_type(item_type)
+    return pattern, item_type
+
+
+def load_type_map(path: Path) -> list[tuple[str, str]]:
+    """Load glob → item-type mappings from a YAML file."""
+    import yaml  # deferred
+
+    raw = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    if isinstance(raw, dict) and "types" in raw:
+        raw = raw["types"]
+    if not isinstance(raw, dict):
+        raise ValueError(f"type map {path} must be a YAML mapping")
+
+    mappings: list[tuple[str, str]] = []
+    for pattern, item_type in raw.items():
+        pattern = str(pattern).strip()
+        item_type = str(item_type).strip().lower()
+        if not pattern:
+            raise ValueError(f"type map {path} contains an empty pattern")
+        _validate_import_type(item_type)
+        mappings.append((pattern, item_type))
+    return mappings
+
+
+def explicit_import_type(
+    rel_str: str,
+    *,
+    type_map: list[tuple[str, str]],
+    type_overrides: list[tuple[str, str]],
+) -> str | None:
+    """Return the explicitly mapped type for *rel_str*, if any."""
+    resolved: str | None = None
+    for pattern, item_type in [*type_map, *type_overrides]:
+        if _matches_glob(rel_str, pattern):
+            resolved = item_type
+    return resolved
+
+
+def resolve_import_type(
+    rel_str: str,
+    *,
+    type_map: list[tuple[str, str]],
+    type_overrides: list[tuple[str, str]],
+    metadata_type: str | None,
+    content_bytes: bytes,
+) -> str:
+    """Pick the import item type for a source file."""
+    resolved = explicit_import_type(
+        rel_str,
+        type_map=type_map,
+        type_overrides=type_overrides,
+    )
+    if resolved:
+        return resolved
+    if metadata_type:
+        _validate_import_type(metadata_type)
+        return metadata_type
+    return classify_file_kind(content_bytes)
+
+
+def _validate_import_type(item_type: str) -> None:
+    if item_type not in VALID_IMPORT_TYPES:
+        allowed = ", ".join(sorted(VALID_IMPORT_TYPES))
+        raise ValueError(f"invalid item type {item_type!r}; expected one of: {allowed}")
+
+
+def _matches_glob(rel_str: str, pattern: str) -> bool:
+    return fnmatch.fnmatch(rel_str, pattern) or fnmatch.fnmatch(Path(rel_str).name, pattern)
+
+
+def annotate_plan_conflicts(
+    plan: list[dict[str, Any]],
+    *,
+    namespace: str,
+    update: bool,
+    view: NamespaceView | None = None,
+) -> list[str]:
+    """Mark conflicting entries and return human-readable conflict messages."""
+    messages: list[str] = []
+    seen_paths: dict[str, str] = {}
+
+    for entry in plan:
+        entry.setdefault("status", "ok")
+        entry.setdefault("action", "create")
+        entry.pop("conflict", None)
+
+        if entry.get("conflict_reason"):
+            entry["status"] = "conflict"
+            entry["conflict"] = entry["conflict_reason"]
+            messages.append(f"{entry['source_rel']}: {entry['conflict_reason']}")
+            continue
+
+        tree_path = entry["tree_path"]
+        rel = str(entry["source_rel"])
+        if tree_path in seen_paths:
+            reason = f"tree path {tree_path!r} is already mapped from {seen_paths[tree_path]!r}"
+            entry["status"] = "conflict"
+            entry["conflict"] = reason
+            messages.append(f"{rel}: {reason}")
+            continue
+        seen_paths[tree_path] = rel
+
+        meta_ns = entry.get("metadata_namespace")
+        if meta_ns and meta_ns != namespace:
+            reason = f"metadata namespace {meta_ns!r} does not match {namespace!r}"
+            entry["status"] = "conflict"
+            entry["conflict"] = reason
+            messages.append(f"{rel}: {reason}")
+
+        if view is not None:
+            exists = _item_exists(view, tree_path)
+            if exists:
+                entry["action"] = "update"
+                if not update:
+                    reason = f"item {tree_path!r} already exists (use --update)"
+                    entry["status"] = "conflict"
+                    entry["conflict"] = reason
+                    messages.append(f"{rel}: {reason}")
+
+    return messages
+
+
+def build_metadata_entry(
+    *,
+    file_path: Path,
+    rel: Path,
+    rel_str: str,
+    target_prefix: str,
+    content_bytes: bytes,
+    type_map: list[tuple[str, str]],
+    type_overrides: list[tuple[str, str]],
+) -> dict[str, Any] | None:
+    """Build one import plan entry from export metadata on *file_path*."""
+    meta = read_file_metadata(file_path)
+    item_path = meta.get("path", "").strip()
+    if not item_path:
+        return None
+
+    metadata_type = meta.get("node_type", "").strip() or None
+    node_type = resolve_import_type(
+        rel_str,
+        type_map=type_map,
+        type_overrides=type_overrides,
+        metadata_type=metadata_type,
+        content_bytes=content_bytes,
+    )
+    tree_path = metadata_tree_path(item_path, target_prefix)
+    body = import_file_text(content_bytes)
+
+    entry: dict[str, Any] = {
+        "kind": node_type,
+        "source_rel": rel,
+        "source_abs": file_path,
+        "tree_path": tree_path,
+        "metadata_namespace": meta.get("namespace", "").strip() or None,
+        "content": body,
+    }
+
+    return entry
+
+
+def _item_exists(view: NamespaceView, path: str) -> bool:
+    try:
+        view.get_item(path=path)
+        return True
+    except Exception:
+        return False

ocmo_cli/_item_output.py

@@ -0,0 +1,223 @@
+"""Tree item output formatting (config, template, secret, resolver)."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from ._output import (
+    _parse_path,
+    _print_jsonpath_value,
+    _resolve_path,
+    as_dict,
+    format_datetime,
+    sanitize_for_output,
+    yaml_dumps,
+)
+from ._resolve_output import _err_meta, resolve_output_format
+
+DOCUMENT_NODE_TYPES = frozenset({"config", "template", "secret", "resolver"})
+
+DOCUMENT_OUTPUT_RESOURCES = frozenset(
+    {
+        "config",
+        "template",
+        "secret",
+        "resolver",
+        "globalpermission",
+    }
+)
+
+_METADATA_KEYS = ("path", "name", "node_type", "author")
+_VERSION_METADATA_KEYS = ("version", "updater", "updated_at")
+
+
+def uses_item_output(op_id: str, action: str, resource: str, result: Any | None) -> bool:
+    """True when API result should use resolve-style raw/json/yaml output."""
+    if action in ("create", "update") and resource in DOCUMENT_OUTPUT_RESOURCES:
+        return True
+    if op_id == "get_item" and result is not None:
+        return node_type_of(result) in DOCUMENT_NODE_TYPES
+    return False
+
+
+def node_type_of(result: Any) -> str | None:
+    if hasattr(result, "node_type"):
+        value = result.node_type
+        return str(value) if value else None
+    if isinstance(result, dict):
+        value = result.get("node_type")
+        return str(value) if value else None
+    return None
+
+
+def _get_field(obj: Any, key: str) -> Any:
+    if isinstance(obj, dict):
+        return obj.get(key)
+    return getattr(obj, key, None)
+
+
+def _version_data(obj: Any) -> Any | None:
+    return _get_field(obj, "version_data")
+
+
+def item_version_is_deleted(result: Any) -> bool:
+    """True when the fetched item points at a soft-deleted version."""
+    version_data = _version_data(result)
+    if version_data is None:
+        return False
+    return bool(_get_field(version_data, "deleted_at"))
+
+
+def deleted_version_edit_error(path: str, item: Any) -> str:
+    """Human-readable error for attempting to edit a deleted version."""
+    version_data = _version_data(item)
+    version = _get_field(version_data, "version") if version_data else None
+    if version is not None:
+        return f"Cannot edit deleted version {version} of {path!r}."
+    return f"Cannot edit deleted version of {path!r}."
+
+
+def item_metadata_rows(result: Any, *, resource: str | None = None) -> list[tuple[str, Any]]:
+    rows: list[tuple[str, Any]] = []
+
+    if resource == "namespace":
+        for key in ("name", "description", "permissions_tag", "webhooks_tag", "git_sync_tag"):
+            value = _get_field(result, key)
+            if value is not None and value != "":
+                rows.append((key, value))
+        return rows
+
+    if resource == "lock":
+        for key in ("path", "reason", "locked_by"):
+            value = _get_field(result, key)
+            if value is not None and value != "":
+                rows.append((key, value))
+        expires_at = _get_field(result, "expires_at")
+        if expires_at:
+            rows.append(("expires_at", format_datetime(expires_at)))
+        return rows
+
+    if resource == "globalpermission":
+        for key in ("id", "position", "created_at", "updated_at"):
+            value = _get_field(result, key)
+            if value is not None and value != "":
+                if key in ("created_at", "updated_at"):
+                    value = format_datetime(value) or value
+                rows.append((key, value))
+        return rows
+
+    for key in _METADATA_KEYS:
+        value = _get_field(result, key)
+        if value is not None and value != "":
+            rows.append((key, value))
+
+    version_data = _version_data(result)
+    if version_data is not None:
+        deleted_at = _get_field(version_data, "deleted_at")
+        version = _get_field(version_data, "version")
+        if version is not None and version != "":
+            rows.append(("version", version))
+
+        if deleted_at:
+            formatted_deleted_at = format_datetime(deleted_at)
+            if formatted_deleted_at:
+                rows.append(("deleted_at", formatted_deleted_at))
+            deleted_by = _get_field(version_data, "updater")
+            if deleted_by:
+                rows.append(("deleted_by", deleted_by))
+        else:
+            for key in _VERSION_METADATA_KEYS[1:]:
+                value = _get_field(version_data, key)
+                if value is not None and value != "":
+                    if key == "updated_at":
+                        value = format_datetime(value) or value
+                    rows.append((key, value))
+
+    description = _get_field(result, "description")
+    if description:
+        rows.append(("description", description))
+
+    return rows
+
+
+def item_body(result: Any, *, resource: str | None = None) -> str:
+    """Return the document body for stdout in raw mode."""
+    if resource == "globalpermission":
+        rule = _get_field(result, "rule")
+        if rule is None:
+            return ""
+        payload = sanitize_for_output(as_dict(rule, fallback_vars=False) or rule)
+        return yaml_dumps(payload)
+
+    if resource in ("namespace", "lock"):
+        payload = sanitize_for_output(as_dict(result, fallback_vars=False) or result)
+        return yaml_dumps(payload)
+
+    node_type = node_type_of(result)
+    if node_type == "resolver":
+        body = _get_field(result, "configuration")
+        return body if isinstance(body, str) else ""
+    version_data = _version_data(result)
+    if version_data is not None:
+        data = _get_field(version_data, "data")
+        return data if isinstance(data, str) else ""
+    return ""
+
+
+def emit_item_metadata(result: Any, *, no_color: bool = False, resource: str | None = None) -> None:
+    for key, value in item_metadata_rows(result, resource=resource):
+        _err_meta(f"# {key}: {value}", no_color=no_color)
+
+
+def emit_item_raw(result: Any, *, no_color: bool = False, resource: str | None = None) -> None:
+    emit_item_metadata(result, no_color=no_color, resource=resource)
+    text = item_body(result, resource=resource)
+    print(text, end="" if text.endswith("\n") else "\n")
+
+
+def emit_item_result(
+    result: Any,
+    fmt: str,
+    *,
+    no_color: bool = False,
+    resource: str | None = None,
+) -> None:
+    """Emit one tree item in resolve-compatible output formats."""
+    if fmt == "raw":
+        emit_item_raw(result, no_color=no_color, resource=resource)
+        return
+
+    if fmt == "name":
+        name = _get_field(result, "path") or _get_field(result, "name")
+        if name:
+            print(name)
+        return
+
+    payload = sanitize_for_output(as_dict(result, fallback_vars=False) or result)
+
+    if fmt == "json":
+        print(json.dumps(payload, default=str, indent=2))
+    elif fmt == "yaml":
+        print(yaml_dumps(payload), end="")
+    elif fmt.startswith("jsonpath="):
+        value = _resolve_path(payload, _parse_path(fmt[9:]))
+        _print_jsonpath_value(value)
+    else:
+        print(payload)
+
+
+def item_output_format(
+    cli_fmt: str | None,
+    ctx_fmt: str | None,
+    *,
+    command_key: str = "get item",
+) -> str:
+    """Effective output format for tree item commands (default: raw)."""
+    return resolve_output_format(cli_fmt, ctx_fmt, command_key=command_key)
+
+
+def item_output_includes_token_in_payload(fmt: str, field: str | None) -> bool:
+    if field:
+        return field in ("token1", "token")
+    return fmt in ("yaml", "json")

ocmo_cli/_lazy_mixin.py

@@ -0,0 +1,29 @@
+"""Shared lazy-delegation helpers for startup-safe Click stubs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+
+class ClickLazyMixin:
+    """Delegate common Click entry points to a lazily loaded target."""
+
+    def _lazy_target(self) -> click.Command | click.Group:
+        raise NotImplementedError
+
+    def make_context(
+        self,
+        info_name: str | None,
+        args: list[str],
+        parent: click.Context | None = None,
+        **extra: Any,
+    ) -> click.Context:
+        return self._lazy_target().make_context(info_name, args, parent=parent, **extra)
+
+    def invoke(self, ctx: click.Context) -> Any:
+        return self._lazy_target().invoke(ctx)
+
+    def shell_complete(self, ctx: click.Context, incomplete: str) -> list[click.shell_completion.CompletionItem]:
+        return self._lazy_target().shell_complete(ctx, incomplete)