tangle-cli 0.0.1a1__py3-none-any.whl

tangle_cli/models.py

@@ -0,0 +1,407 @@
+"""
+API-contract dataclasses for the Tangle Cloud Pipelines API.
+
+These dataclasses model the shapes of HTTP request/response bodies on the
+Tangle API — ``PipelineRun``, ``ComponentSpec``, container state, artifacts,
+etc. They are used by wrapper packages and OpenAPI-backed client helpers.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any
+
+from tangle_api.generated.models import ComponentSpec, GetExecutionInfoResponse
+
+from .artifacts import ArtifactComponentQuery, ArtifactInfo
+
+
+# ---- Execution / Run dataclasses -------------------------------------------
+
+
+@dataclass
+class GraphExecutionState:
+    """Response from GET /api/executions/{id}/state.
+
+    Maps each child execution ID to a dict of status -> count.
+    Example::
+
+        GraphExecutionState(child_execution_status_stats={
+            "019c8b46508e751207fc": {"SUCCEEDED": 1},
+            "019c8b46508e76e607fd": {"RUNNING": 2, "SUCCEEDED": 3},
+        })
+    """
+    child_execution_status_stats: dict[str, dict[str, int]] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> GraphExecutionState:
+        return cls(
+            child_execution_status_stats=data.get("child_execution_status_stats", {}),
+        )
+
+    @property
+    def status_totals(self) -> dict[str, int]:
+        """Aggregate counts across all child executions."""
+        totals: dict[str, int] = {}
+        for status_counts in self.child_execution_status_stats.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]:
+        """Execution IDs that have at least one FAILED or SYSTEM_ERROR task."""
+        return [
+            exec_id
+            for exec_id, status_counts in self.child_execution_status_stats.items()
+            if status_counts.get("FAILED", 0) > 0
+            or status_counts.get("SYSTEM_ERROR", 0) > 0
+        ]
+
+
+@dataclass
+class PipelineRun:
+    """Response from GET /api/pipeline_runs/{id}."""
+    id: str
+    root_execution_id: str | None
+    created_at: str | None = None
+    created_by: str | None = None
+    annotations: dict[str, str] | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PipelineRun:
+        return cls(
+            id=data["id"],
+            root_execution_id=data.get("root_execution_id"),
+            created_at=data.get("created_at"),
+            created_by=data.get("created_by"),
+            annotations=data.get("annotations"),
+            raw=data,
+        )
+
+
+@dataclass
+class TaskSpec:
+    """A task within a pipeline execution graph.
+
+    Recursive: a graph task contains child TaskSpecs via ``graph_tasks``.
+    Leaf tasks have a container implementation instead.
+    """
+    name: str | None = None
+    component_spec: ComponentSpec | None = None
+    arguments: dict[str, str] = field(default_factory=dict)
+    graph_tasks: dict[str, TaskSpec] = field(default_factory=dict)
+    annotations: dict[str, str] = field(default_factory=dict)
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> TaskSpec:
+        """Parse a task_spec dict (the shape returned by the API)."""
+        spec = data.get("componentRef", {}).get("spec", {})
+        graph = spec.get("implementation", {}).get("graph", {})
+        raw_tasks = graph.get("tasks", {})
+
+        graph_tasks: dict[str, TaskSpec] = {}
+        for task_name, task_data in raw_tasks.items():
+            graph_tasks[task_name] = TaskSpec.from_dict(task_data)
+
+        return cls(
+            name=spec.get("name"),
+            component_spec=ComponentSpec.from_spec(spec) if spec else None,
+            arguments=data.get("arguments", {}),
+            graph_tasks=graph_tasks,
+            annotations=data.get("annotations", {}),
+            raw=data,
+        )
+
+    @property
+    def digest(self) -> str | None:
+        """Component digest from componentRef."""
+        return self.raw.get("componentRef", {}).get("digest")
+
+    @property
+    def inputs(self) -> list[dict[str, Any]]:
+        """Component inputs."""
+        return self.component_spec.inputs if self.component_spec else []
+
+    @property
+    def outputs(self) -> list[dict[str, Any]]:
+        """Component outputs."""
+        return self.component_spec.outputs if self.component_spec else []
+
+    @property
+    def execution_id(self) -> str | None:
+        """Execution ID injected by ``_enrich_execution_tree``."""
+        return self.raw.get("execution_id")
+
+    @property
+    def execution_input_artifacts(self) -> dict[str, str]:
+        """Input artifact IDs injected by ``_enrich_execution_tree``."""
+        return self.raw.get("input_artifacts", {})
+
+    @property
+    def execution_output_artifacts(self) -> dict[str, str]:
+        """Output artifact IDs injected by ``_enrich_execution_tree``."""
+        return self.raw.get("output_artifacts", {})
+
+    @property
+    def is_graph(self) -> bool:
+        """True if this task is a subgraph (has child tasks)."""
+        return len(self.graph_tasks) > 0
+
+    def strip_implementations(self) -> None:
+        """Remove container implementation blocks recursively.
+
+        Graph structure (tasks, arguments, connections) is preserved.
+        Only leaf container/code blocks are stripped.  ``text`` fields
+        (raw YAML containing full implementations) are stripped at every
+        level to avoid leaking implementation details.
+        """
+        if self.is_graph:
+            # Graph component: keep implementation dict but strip text fields
+            if self.component_spec:
+                self.component_spec.strip_implementation(keep_graph=True)
+            for child in self.graph_tasks.values():
+                child.strip_implementations()
+        else:
+            if self.component_spec:
+                self.component_spec.strip_implementation()
+
+
+# ---- Container state -------------------------------------------------------
+
+
+@dataclass
+class KubernetesDebugInfo:
+    """Kubernetes debug info from container state."""
+    pod_name: str | None = None
+    namespace: str | None = None
+    log_uri: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> KubernetesDebugInfo:
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+
+@dataclass
+class KubernetesJobInfo:
+    """Kubernetes job info from container state (debug_info.kubernetes_job)."""
+    job_name: str | None = None
+    namespace: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> KubernetesJobInfo:
+        return cls(**{k: v for k, v in data.items() if k in cls.__dataclass_fields__})
+
+
+@dataclass
+class DebugInfo:
+    """Debug info from container state (mirrors debug_info in the API response)."""
+    kubernetes: KubernetesDebugInfo | None = None
+    kubernetes_job: KubernetesJobInfo | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> DebugInfo:
+        k8s_data = data.get("kubernetes", {})
+        job_data = data.get("kubernetes_job", {})
+        return cls(
+            kubernetes=KubernetesDebugInfo.from_dict(k8s_data) if k8s_data else None,
+            kubernetes_job=KubernetesJobInfo.from_dict(job_data) if job_data else None,
+        )
+
+
+@dataclass
+class ContainerState:
+    """Response from GET /api/executions/{id}/container_state.
+
+    Extracts key fields for debugging; the full Kubernetes debug info
+    (pod spec, status, etc.) is available via ``debug_info.kubernetes`` and ``raw``.
+    """
+    status: str = "UNKNOWN"
+    exit_code: int | None = None
+    started_at: str | None = None
+    ended_at: str | None = None
+    pod_name: str | None = None
+    namespace: str | None = None
+    debug_info: DebugInfo | None = None
+    raw: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ContainerState:
+        debug_data = data.get("debug_info", {})
+        fields = {k: v for k, v in data.items() if k in cls.__dataclass_fields__}
+        if debug_data:
+            fields["debug_info"] = DebugInfo.from_dict(debug_data)
+        fields["raw"] = data
+
+        # Resolve pod_name: debug_info.kubernetes.pod_name > debug_info.kubernetes_job.job_name
+        if not fields.get("pod_name"):
+            di = fields.get("debug_info")
+            k8s = di.kubernetes if di else None
+            if k8s and k8s.pod_name:
+                fields["pod_name"] = k8s.pod_name
+                if not fields.get("namespace"):
+                    fields["namespace"] = k8s.namespace
+            else:
+                job = di.kubernetes_job if di else None
+                if job and job.job_name:
+                    fields["pod_name"] = job.job_name
+
+        return cls(**fields)
+
+
+# ---- Composite -------------------------------------------------------------
+
+
+@dataclass
+class RunDetails:
+    """Combined pipeline run + execution details from get_run_details."""
+    run: PipelineRun
+    execution: GetExecutionInfoResponse | None = None
+    annotations: dict[str, str | None] | None = None
+    execution_state: GraphExecutionState | None = None
+
+
+# ---- Users / secrets -------------------------------------------------------
+
+
+@dataclass
+class UserInfo:
+    """Current authenticated user from /api/users/me."""
+    id: str
+    permissions: list[str]
+
+
+@dataclass
+class SecretInfo:
+    """Secret metadata from /api/secrets/ endpoints."""
+    secret_name: str
+    created_at: str
+    updated_at: str
+    expires_at: str | None = None
+    description: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> SecretInfo:
+        return cls(
+            secret_name=data["secret_name"],
+            created_at=data["created_at"],
+            updated_at=data["updated_at"],
+            expires_at=data.get("expires_at"),
+            description=data.get("description"),
+        )
+
+
+# ---- Components ------------------------------------------------------------
+
+
+# ``ComponentSpec`` is generated from OpenAPI and extended in
+# ``tangle_cli.generated_model_extensions.ComponentSpecExtensions``. Re-export
+# it from this module for compatibility with callers that import domain models
+# from ``tangle_cli.models``.
+
+
+@dataclass
+class ComponentInfo:
+    """Merged view of a published component: spec + publication metadata."""
+
+    name: str = ""
+    digest: str | None = None
+    version: str | None = None
+    published_by: str | None = None
+    deprecated: bool = False
+    superseded_by: str | None = None
+    description: str = ""
+    component_spec: ComponentSpec | None = None
+    spec_error: str | None = None
+
+    @classmethod
+    def from_dict(cls, pub: dict[str, Any]) -> ComponentInfo:
+        """Create from a published_components API response entry."""
+        return cls(
+            name=pub.get("name", ""),
+            digest=pub.get("digest"),
+            version=pub.get("version"),
+            published_by=pub.get("published_by"),
+            deprecated=pub.get("deprecated", False),
+            superseded_by=pub.get("superseded_by"),
+            description=pub.get("description", ""),
+        )
+
+    def to_dict(self, strip_spec: bool = True) -> dict[str, Any]:
+        """Serialize to a dict, omitting None/empty optional fields.
+
+        Args:
+            strip_spec: If True (default), strip bulky annotations and
+                implementation blocks from the component spec.
+        """
+        d: dict[str, Any] = {"digest": self.digest, "version": self.version}
+        if self.published_by is not None:
+            d["published_by"] = self.published_by
+        d["deprecated"] = self.deprecated
+        if self.superseded_by is not None:
+            d["superseded_by"] = self.superseded_by
+        if self.description:
+            d["description"] = self.description
+        if self.component_spec is not None:
+            spec = self.component_spec.stripped_spec if strip_spec else self.component_spec.data
+            if spec is not None:
+                d["spec"] = spec
+        if self.spec_error is not None:
+            d["spec_error"] = self.spec_error
+        return d
+
+
+# ---- Pagination ------------------------------------------------------------
+
+
+@dataclass
+class PageChunk:
+    """Metadata for a single page of search results."""
+
+    rows: list[dict[str, Any]]
+    page_token: str | None
+    next_page_token: str | None
+    ui_filter_url: str
+    next_ui_filter_url: str | None
+
+
+# ---- Dict-like compatibility ----------------------------------------------
+
+
+def _dataclass_to_dict(self) -> dict[str, Any]:
+    return asdict(self)
+
+
+def _dataclass_get(self, key: str, default: Any = None) -> Any:
+    return _dataclass_to_dict(self).get(key, default)
+
+
+def _dataclass_getitem(self, key: str) -> Any:
+    return _dataclass_to_dict(self)[key]
+
+
+for _dict_like_cls in (
+    GraphExecutionState,
+    PipelineRun,
+    TaskSpec,
+    KubernetesDebugInfo,
+    KubernetesJobInfo,
+    DebugInfo,
+    ContainerState,
+    RunDetails,
+    ArtifactComponentQuery,
+    ArtifactInfo,
+    UserInfo,
+    SecretInfo,
+    ComponentInfo,
+    PageChunk,
+):
+    if not hasattr(_dict_like_cls, "to_dict"):
+        setattr(_dict_like_cls, "to_dict", _dataclass_to_dict)
+    setattr(_dict_like_cls, "get", _dataclass_get)
+    setattr(_dict_like_cls, "__getitem__", _dataclass_getitem)
+
+
+del _dict_like_cls