tangle-cli 0.0.1a1__py3-none-any.whl

tangle_cli/generated_model_extensions.py

@@ -0,0 +1,405 @@
+"""Handwritten extensions mixed into generated Tangle API models."""
+
+from __future__ import annotations
+
+import os
+from datetime import datetime, timezone
+from typing import Any, cast
+
+import yaml
+
+import tangle_cli.utils as utils
+
+
+def _strip_text_from_graph(implementation: dict[str, Any]) -> None:
+    """Recursively remove raw component text from graph component references."""
+
+    graph = implementation.get("graph", {})
+    for task_data in graph.get("tasks", {}).values():
+        ref = task_data.get("componentRef")
+        if not ref:
+            continue
+        ref.pop("text", None)
+        spec = ref.get("spec", {})
+        nested_impl = spec.get("implementation")
+        if nested_impl and "graph" in nested_impl:
+            _strip_text_from_graph(nested_impl)
+
+
+def _add_official_prefix(name: str) -> str:
+    """Return the official component name variant used by registry searches."""
+
+    if name and not name.startswith("[Official]"):
+        return f"[Official] {name}"
+    return name
+
+
+class ComponentSpecExtensions:
+    """Legacy YAML-domain conveniences for the generated ComponentSpec model."""
+
+    _STRIP_ANNOTATION_KEYS = {"python_original_code", "python_dependencies"}
+
+    def _extra_get(self, key: str, default: Any = None) -> Any:
+        extra = getattr(self, "__pydantic_extra__", None)
+        if isinstance(extra, dict) and key in extra:
+            return extra[key]
+        return getattr(self, "__dict__", {}).get(key, default)
+
+    def _extra_set(self, key: str, value: Any) -> None:
+        extra = getattr(self, "__pydantic_extra__", None)
+        if isinstance(extra, dict):
+            extra[key] = value
+        else:  # pragma: no cover - pydantic v1 fallback
+            self.__dict__[key] = value
+
+    @property
+    def data(self) -> dict[str, Any]:
+        data = self._extra_get("data")
+        if isinstance(data, dict):
+            return data
+        result: dict[str, Any] = {}
+        if self.name:
+            result["name"] = self.name
+        if self.description is not None:
+            result["description"] = self.description
+        if self.metadata:
+            result["metadata"] = self.metadata
+        if self.inputs:
+            result["inputs"] = self.inputs
+        if self.outputs:
+            result["outputs"] = self.outputs
+        if self.implementation:
+            result["implementation"] = self.implementation
+        return result
+
+    @data.setter
+    def data(self, value: dict[str, Any]) -> None:
+        self._extra_set("data", value)
+
+    @property
+    def digest(self) -> str:
+        return str(self._extra_get("digest", "") or "")
+
+    @digest.setter
+    def digest(self, value: str) -> None:
+        self._extra_set("digest", value)
+
+    @property
+    def text(self) -> str | None:
+        return self._extra_get("text")
+
+    @text.setter
+    def text(self, value: str | None) -> None:
+        self._extra_set("text", value)
+
+    @property
+    def version(self) -> str | None:
+        return self._extra_get("version")
+
+    @version.setter
+    def version(self, value: str | None) -> None:
+        self._extra_set("version", value)
+
+    @property
+    def annotations(self) -> dict[str, str]:
+        annotations = self._extra_get("annotations")
+        if isinstance(annotations, dict):
+            return annotations
+        return (self.metadata or {}).get("annotations", {})
+
+    @annotations.setter
+    def annotations(self, value: dict[str, str]) -> None:
+        self._extra_set("annotations", value)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Any:
+        """Create from a raw component API response.
+
+        ``/api/components/{digest}`` responses carry raw YAML in ``text`` and
+        may carry the parsed YAML in ``spec``. The generated model stores the
+        schema fields while extra fields preserve legacy helpers such as
+        ``data``, ``digest``, ``text``, ``version``, and ``annotations``.
+        """
+
+        spec = data.get("spec")
+        text = data.get("text")
+        if spec is None and text:
+            spec = yaml.safe_load(text)
+        if spec is None and any(
+            key in data
+            for key in ("name", "description", "metadata", "inputs", "outputs", "implementation")
+        ):
+            spec = data
+        spec = spec or {}
+        annotations = spec.get("metadata", {}).get("annotations", {})
+        return cls(
+            digest=data.get("digest", ""),
+            data=spec,
+            text=text,
+            name=spec.get("name", ""),
+            version=annotations.get("version"),
+            description=spec.get("description"),
+            annotations=annotations,
+            inputs=spec.get("inputs", []),
+            outputs=spec.get("outputs", []),
+            implementation=spec.get("implementation"),
+            metadata=spec.get("metadata"),
+        )
+
+    @classmethod
+    def from_yaml_file(cls, yaml_path: str) -> Any:
+        """Load and parse a component YAML file."""
+
+        with open(yaml_path) as f:
+            yaml_content = f.read()
+        return cls.from_yaml(yaml_content)
+
+    @classmethod
+    def from_yaml(
+        cls,
+        yaml_content: str,
+        annotations: dict[str, str] | None = None,
+    ) -> Any:
+        """Create from YAML text, optionally merging annotations first."""
+
+        data = utils.parse_yaml_string(yaml_content)
+        if not data:
+            raise ValueError("Unable to parse YAML content")
+
+        if annotations:
+            data.setdefault("metadata", {}).setdefault("annotations", {}).update(annotations)
+
+        name = data.get("name")
+        if not name:
+            raise ValueError("Component name is required but not found in YAML")
+
+        version = utils.get_version_from_data(data) or None
+        return cls(
+            data=data,
+            version=version,
+            name=name,
+            description=data.get("description"),
+            text=yaml_content,
+            annotations=data.get("metadata", {}).get("annotations", {}),
+            inputs=data.get("inputs", []),
+            outputs=data.get("outputs", []),
+            implementation=data.get("implementation"),
+            metadata=data.get("metadata"),
+        )
+
+    @classmethod
+    def from_spec(cls, spec: dict[str, Any]) -> Any:
+        """Create from an inline component spec dict."""
+
+        annotations = spec.get("metadata", {}).get("annotations", {})
+        return cls(
+            data=spec,
+            name=spec.get("name", ""),
+            description=spec.get("description"),
+            annotations=annotations,
+            inputs=spec.get("inputs", []),
+            outputs=spec.get("outputs", []),
+            implementation=spec.get("implementation"),
+            metadata=spec.get("metadata"),
+        )
+
+    def __bool__(self) -> bool:
+        return bool(getattr(self, "data", None))
+
+    @property
+    def search_names(self) -> list[str]:
+        """Names to use for searching, including the official-name variant."""
+
+        name = getattr(self, "name", "") or ""
+        return [name, _add_official_prefix(name)]
+
+    @property
+    def stripped_spec(self) -> dict[str, Any] | None:
+        """Component data with bulky annotations and implementation removed."""
+
+        data = getattr(self, "data", None)
+        if not data:
+            return None
+        result = dict(data)
+        result.pop("implementation", None)
+        annotations = result.get("metadata", {}).get("annotations", {})
+        if annotations:
+            result["metadata"] = dict(result["metadata"])
+            result["metadata"]["annotations"] = {
+                key: value
+                for key, value in annotations.items()
+                if key not in self._STRIP_ANNOTATION_KEYS
+            }
+        return result
+
+    def strip_implementation(self, *, keep_graph: bool = False) -> None:
+        """Remove implementation details in-place."""
+
+        self.text = None
+        if keep_graph:
+            if self.implementation:
+                _strip_text_from_graph(self.implementation)
+        else:
+            self.implementation = None
+            self.data.pop("implementation", None)
+
+    def to_yaml(self) -> str:
+        """Convert component data back to YAML."""
+
+        return utils.dump_yaml(self.data)
+
+    def save_to_file(self, file_path: str) -> None:
+        """Write component data to a YAML file."""
+
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        with open(file_path, "w") as f:
+            f.write(self.to_yaml())
+
+    def update_fields(
+        self,
+        git_remote_sha: str | None = None,
+        git_remote_branch: str | None = None,
+        git_remote_url: str | None = None,
+        image: str | None = None,
+        component_yaml_path: str | None = None,
+    ) -> Any:
+        """Update publishing metadata in-place and return ``self``."""
+
+        self.data.setdefault("metadata", {}).setdefault("annotations", {})
+        annotations = self.data["metadata"]["annotations"]
+        annotations["published_at"] = datetime.now(timezone.utc).isoformat()
+
+        if git_remote_sha:
+            annotations.setdefault("git_remote_sha", git_remote_sha)
+        if git_remote_branch:
+            annotations.setdefault("git_remote_branch", git_remote_branch)
+        if git_remote_url:
+            annotations.setdefault("git_remote_url", git_remote_url)
+        if component_yaml_path:
+            utils.set_component_yaml_path(component_yaml_path, annotations, overwrite=False)
+
+        if "version" in self.data:
+            annotations["version"] = str(self.data.pop("version"))
+        if "updated_at" in self.data:
+            annotations["updated_at"] = str(self.data.pop("updated_at"))
+
+        if image:
+            self.data.setdefault("implementation", {}).setdefault("container", {})["image"] = image
+            self.implementation = self.data["implementation"]
+        self.metadata = self.data.get("metadata")
+        self.annotations = annotations
+        return self
+
+    def fetch_from_url(self, url: str, timeout: int = 10) -> bool:
+        """Fetch and parse component YAML from a URL into this model."""
+
+        import httpx
+
+        try:
+            response = httpx.get(url, timeout=timeout)
+            response.raise_for_status()
+            self.text = response.text
+            self.data = yaml.safe_load(response.text)
+            self.name = self.data.get("name", "")
+            self.description = self.data.get("description")
+            self.metadata = self.data.get("metadata")
+            self.annotations = self.data.get("metadata", {}).get("annotations", {})
+            self.inputs = self.data.get("inputs", [])
+            self.outputs = self.data.get("outputs", [])
+            self.implementation = self.data.get("implementation")
+            self.version = self.annotations.get("version")
+            return True
+        except Exception:
+            return False
+
+    def ensure_digest(self) -> str | None:
+        """Compute and store a digest if one is not already present."""
+
+        if getattr(self, "digest", None):
+            return self.digest
+        from tangle_cli.utils import compute_spec_digest, compute_text_digest
+
+        if getattr(self, "text", None):
+            self.digest = compute_text_digest(self.text)
+        elif getattr(self, "data", None):
+            self.digest = compute_spec_digest(self.data)
+        return self.digest or None
+
+
+
+class GetExecutionInfoResponseExtensions:
+    """Legacy execution-detail conveniences for generated execution responses."""
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Any:
+        """Create a normalized execution details model from API response data."""
+
+        from tangle_cli.models import TaskSpec
+
+        return cls(
+            id=data.get("id", ""),
+            task_spec=TaskSpec.from_dict(data.get("task_spec", {})),
+            pipeline_run_id=data.get("pipeline_run_id"),
+            parent_execution_id=data.get("parent_execution_id"),
+            child_task_execution_ids=data.get("child_task_execution_ids"),
+            input_artifacts={
+                key: value["id"]
+                for key, value in data.get("input_artifacts", {}).items()
+                if "id" in value
+            },
+            output_artifacts={
+                key: value["id"]
+                for key, value in data.get("output_artifacts", {}).items()
+                if "id" in value
+            },
+            child_executions={},
+            raw=data,
+        )
+
+    def strip_implementations(self) -> None:
+        """Remove implementation blocks from this execution tree in-place."""
+
+        self.task_spec.strip_implementations()
+        for child in self.child_executions.values():
+            child.strip_implementations()
+
+    @property
+    def tasks(self) -> dict[str, Any]:
+        """Shortcut to the root task spec's graph tasks."""
+
+        return self.task_spec.graph_tasks
+
+
+class GetGraphExecutionStateResponseExtensions:
+    """Convenience properties for graph execution state responses."""
+
+    @property
+    def per_execution(self) -> dict[str, dict[str, int]]:
+        return cast(
+            dict[str, dict[str, int]],
+            getattr(self, "child_execution_status_stats", None) or {},
+        )
+
+    @property
+    def status_totals(self) -> dict[str, int]:
+        totals: dict[str, int] = {}
+        for status_counts in self.per_execution.values():
+            for status, count in status_counts.items():
+                totals[status] = totals.get(status, 0) + count
+        return totals
+
+    @property
+    def failed_execution_ids(self) -> list[str]:
+        return [
+            execution_id
+            for execution_id, status_counts in self.per_execution.items()
+            if status_counts.get("FAILED", 0) > 0
+            or status_counts.get("SYSTEM_ERROR", 0) > 0
+        ]
+
+
+MODEL_EXTENSIONS = {
+    "ComponentSpec": "ComponentSpecExtensions",
+    "GetExecutionInfoResponse": "GetExecutionInfoResponseExtensions",
+    "GetGraphExecutionStateResponse": "GetGraphExecutionStateResponseExtensions",
+}

tangle_cli/generated_runtime.py

@@ -0,0 +1,43 @@
+"""Runtime helpers shared by generated Tangle API model packages."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel
+
+try:
+    from pydantic import ConfigDict
+except ImportError:  # pragma: no cover - pydantic v1 fallback
+    ConfigDict = None  # type: ignore[assignment]
+
+
+class TangleGeneratedModel(BaseModel):
+    """Base for generated response models with dict-like conveniences."""
+
+    if ConfigDict is not None:
+        model_config = ConfigDict(extra="allow", populate_by_name=True)
+    else:  # pragma: no cover - pydantic v1 fallback
+        class Config:
+            extra = "allow"
+            allow_population_by_field_name = True
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self.to_dict().get(key, default)
+
+    def __getitem__(self, key: str) -> Any:
+        return self.to_dict()[key]
+
+    def to_dict(self) -> dict[str, Any]:
+        if hasattr(self, "model_dump"):
+            return self.model_dump(by_alias=True)
+        return self.dict(by_alias=True)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Any:
+        if hasattr(cls, "model_validate"):
+            return cls.model_validate(data)
+        return cls.parse_obj(data)
+
+
+__all__ = ["TangleGeneratedModel"]

tangle_cli/handler.py

@@ -0,0 +1,96 @@
+"""Shared base classes for Tangle CLI service handlers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from .api_transport import default_base_url
+from .logger import Logger, get_default_logger
+
+
+def _client_base_url_without_materializing(client: Any | None) -> Any | None:
+    """Return a client's configured base URL without triggering lazy proxies."""
+
+    if client is None:
+        return None
+
+    try:
+        client_vars = object.__getattribute__(client, "__dict__")
+    except AttributeError:
+        client_vars = {}
+    if isinstance(client_vars, Mapping):
+        if client_vars.get("base_url"):
+            return client_vars["base_url"]
+        client_kwargs = client_vars.get("client_kwargs")
+        if isinstance(client_kwargs, Mapping):
+            return client_kwargs.get("base_url")
+
+    try:
+        return object.__getattribute__(client, "base_url")
+    except AttributeError:
+        return None
+
+
+class TangleCliHandler:
+    """Base class for CLI/services that use logging and lazy Tangle API clients."""
+
+    _required_client_error_type: type[Exception] = RuntimeError
+    _required_client_error_message = "Failed to create TangleApiClient"
+
+    def __init__(
+        self,
+        *,
+        dry_run: bool = False,
+        client: Any = None,
+        client_factory: Callable[[], Any] | None = None,
+        logger: Logger | None = None,
+        base_url: str | None = None,
+    ) -> None:
+        self.dry_run = dry_run
+        client_base_url = _client_base_url_without_materializing(client)
+        self.base_url = str(base_url or client_base_url or default_base_url())
+        self.client = client
+        self._client = client
+        self._client_factory = client_factory
+        self.log = logger or get_default_logger()
+
+    def _create_client(self) -> Any | None:
+        """Create the default OSS Tangle API client."""
+
+        try:
+            from .client import TangleApiClient
+        except ModuleNotFoundError as exc:
+            if exc.name == "tangle_api":
+                self.log.error(
+                    "❌ Native generated Tangle API bindings are required for Tangle API operations. "
+                    "Install tangle-cli[native] or provide a local tangle_api.generated package."
+                )
+                return None
+            raise
+        return TangleApiClient(logger=self.log)
+
+    def _set_client(self, client: Any | None) -> Any | None:
+        self.client = client
+        self._client = client
+        client_base_url = _client_base_url_without_materializing(client)
+        if client_base_url:
+            self.base_url = str(client_base_url)
+        return client
+
+    def _get_client(self) -> Any | None:
+        """Get or lazily create a Tangle API client instance."""
+
+        if self._client is None and not self.dry_run:
+            if self._client_factory is not None:
+                return self._set_client(self._client_factory())
+            return self._set_client(self._create_client())
+        return self._client
+
+    def _require_client(self) -> Any:
+        """Return a Tangle API client, raising if one cannot be created."""
+
+        client = self._get_client()
+        if client is None:
+            raise self._required_client_error_type(self._required_client_error_message)
+        return client