buildify-cli 1.0.0__py3-none-any.whl

buildify_cli/client.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+
+from buildify_cli.output import body_success
+
+API_PREFIX = "/openapi/v1"
+
+
+class OpenApiClient:
+    """Thin HTTP wrapper: one method per endpoint, no client-side business logic.
+
+    Every method returns ``(http_status, parsed_body)``; the caller decides how to
+    render and which exit code to use.
+    """
+
+    def __init__(self, base_url: str, api_key: Optional[str] = None, timeout: float = 60.0) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self._client = httpx.Client(timeout=timeout, follow_redirects=True)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def __enter__(self) -> "OpenApiClient":
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        self.close()
+
+    def _headers(self, need_auth: bool) -> dict[str, str]:
+        h = {"Accept": "application/json"}
+        if need_auth:
+            if not self.api_key:
+                raise ValueError("api_key required")
+            h["Authorization"] = f"Bearer {self.api_key}"
+        return h
+
+    def _get(self, path: str, params: Optional[dict[str, Any]] = None, *, auth: bool = True) -> tuple[int, Any]:
+        clean = {k: v for k, v in (params or {}).items() if v is not None}
+        r = self._client.get(f"{self.base_url}{path}", headers=self._headers(auth), params=clean)
+        return r.status_code, _parse_body(r)
+
+    def _post(self, path: str, payload: Optional[dict[str, Any]] = None, *, timeout: Optional[float] = None) -> tuple[int, Any]:
+        r = self._client.post(
+            f"{self.base_url}{path}",
+            headers=self._headers(True),
+            json=payload if payload is not None else {},
+            timeout=timeout if timeout is not None else self._client.timeout,
+        )
+        return r.status_code, _parse_body(r)
+
+    def _delete(self, path: str) -> tuple[int, Any]:
+        r = self._client.delete(f"{self.base_url}{path}", headers=self._headers(True))
+        return r.status_code, _parse_body(r)
+
+    # --- health / key ---
+
+    def health(self) -> tuple[int, Any]:
+        return self._get(f"{API_PREFIX}/health", auth=False)
+
+    def key_test(self) -> tuple[int, Any]:
+        return self._get(f"{API_PREFIX}/key/test")
+
+    # --- bundle discovery ---
+
+    def bundle_list(self, keyword: Optional[str] = None) -> tuple[int, Any]:
+        return self._get(f"{API_PREFIX}/bundles", {"keyword": keyword})
+
+    def bundle_nodes(self, bundle_name: str, bundle_version: Optional[str]) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/bundles/nodes",
+            {"bundleName": bundle_name, "bundleVersion": bundle_version},
+        )
+
+    def node_properties(self, bundle_name: str, bundle_version: Optional[str], name: str) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/bundles/nodes/properties",
+            {"bundleName": bundle_name, "bundleVersion": bundle_version, "name": name},
+        )
+
+    def node_relations(self, bundle_name: str, bundle_version: Optional[str], name: str) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/bundles/nodes/relations",
+            {"bundleName": bundle_name, "bundleVersion": bundle_version, "name": name},
+        )
+
+    def bundle_doc(self, bundle_name: str, bundle_version: Optional[str]) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/bundles/doc",
+            {"bundleName": bundle_name, "bundleVersion": bundle_version},
+        )
+
+    def credentials_types(self, bundle_name: str, bundle_version: Optional[str]) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/bundles/credentials/types",
+            {"bundleName": bundle_name, "bundleVersion": bundle_version},
+        )
+
+    def credentials_properties(self, bundle_name: str, bundle_version: Optional[str], type_: str) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/bundles/credentials/properties",
+            {"bundleName": bundle_name, "bundleVersion": bundle_version, "type": type_},
+        )
+
+    # --- projects ---
+
+    def project_list(self) -> tuple[int, Any]:
+        return self._get(f"{API_PREFIX}/projects")
+
+    def project_create(self, name: str, remark: Optional[str]) -> tuple[int, Any]:
+        return self._post(f"{API_PREFIX}/projects", {"projectName": name, "remark": remark})
+
+    def project_get(self, project_id: str) -> tuple[int, Any]:
+        return self._get(f"{API_PREFIX}/projects/{project_id}")
+
+    def project_credentials(self, project_id: str, bundle_name: Optional[str] = None) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/projects/{project_id}/credentials",
+            {"bundleName": bundle_name},
+        )
+
+    def project_create_credential(
+        self,
+        project_id: str,
+        *,
+        bundle_name: str,
+        type_: str,
+        name: str,
+        label: str,
+        data: dict[str, Any],
+        bundle_version: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> tuple[int, Any]:
+        payload: dict[str, Any] = {
+            "bundleName": bundle_name,
+            "type": type_,
+            "name": name,
+            "label": label,
+            "data": data,
+        }
+        if bundle_version:
+            payload["bundleVersion"] = bundle_version
+        if description is not None:
+            payload["description"] = description
+        return self._post(f"{API_PREFIX}/projects/{project_id}/credentials", payload)
+
+    def project_workers(self, project_id: str, online_only: bool = False) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/projects/{project_id}/workers",
+            {"onlineOnly": "true" if online_only else None},
+        )
+
+    # --- workflows ---
+
+    def flow_list(self, project_id: str, keyword: Optional[str] = None) -> tuple[int, Any]:
+        return self._get(f"{API_PREFIX}/projects/{project_id}/workflows", {"keyword": keyword})
+
+    def flow_create(
+        self,
+        project_id: str,
+        *,
+        workflow_name: str,
+        worker_ids: list[str],
+        remark: Optional[str],
+    ) -> tuple[int, Any]:
+        return self._post(
+            f"{API_PREFIX}/projects/{project_id}/workflows",
+            {"workflowName": workflow_name, "workerIds": worker_ids, "remark": remark},
+        )
+
+    def flow_get_draft(self, project_id: str, workflow_id: str) -> tuple[int, Any]:
+        return self._get(f"{API_PREFIX}/projects/{project_id}/workflows/{workflow_id}/draft")
+
+    def flow_save_draft(
+        self,
+        project_id: str,
+        workflow_id: str,
+        *,
+        workflow_json: Any,
+        version: int,
+    ) -> tuple[int, Any]:
+        return self._post(
+            f"{API_PREFIX}/projects/{project_id}/workflows/{workflow_id}/draft",
+            {"workflowJson": workflow_json, "version": version},
+        )
+
+    def flow_validate(self, project_id: str, workflow_json: Any) -> tuple[int, Any]:
+        return self._post(
+            f"{API_PREFIX}/projects/{project_id}/workflows/validate",
+            {"workflowJson": workflow_json},
+        )
+
+    def flow_test_run(
+        self,
+        project_id: str,
+        *,
+        workflow_json: Any,
+        worker_id: str,
+        workflow_id: Optional[str],
+        start_node_id: Optional[str],
+        inputs: Any,
+        timeout_seconds: Optional[int],
+    ) -> tuple[int, Any]:
+        payload = {
+            "workflowJson": workflow_json,
+            "workerId": worker_id,
+            "workflowId": workflow_id,
+            "startNodeId": start_node_id,
+            "inputs": inputs,
+            "timeoutSeconds": timeout_seconds,
+        }
+        # 服务端等待 workflow.completed，HTTP 读超时必须留出余量，否则本地先断开
+        wait = (timeout_seconds or 60) + 30
+        return self._post(f"{API_PREFIX}/projects/{project_id}/workflows/test_runs", payload, timeout=float(wait))
+
+    def flow_cancel_test(self, project_id: str, execution_id: str, worker_id: str) -> tuple[int, Any]:
+        return self._post(
+            f"{API_PREFIX}/projects/{project_id}/workflows/test_runs/{execution_id}/cancel",
+            {"workerId": worker_id},
+        )
+
+    def flow_deploy(
+        self,
+        project_id: str,
+        workflow_id: str,
+        *,
+        worker_ids: list[str],
+        workflow_json: Any = None,
+        version: Optional[int] = None,
+        remark: Optional[str] = None,
+        version_name: Optional[str] = None,
+    ) -> tuple[int, Any]:
+        payload: dict[str, Any] = {"workerIds": worker_ids}
+        if workflow_json is not None:
+            payload["workflowJson"] = workflow_json
+        if version is not None:
+            payload["version"] = version
+        if remark is not None:
+            payload["remark"] = remark
+        if version_name is not None:
+            payload["versionName"] = version_name
+        return self._post(
+            f"{API_PREFIX}/projects/{project_id}/workflows/{workflow_id}/deploy",
+            payload,
+        )
+
+    def flow_published(self, project_id: str, workflow_id: str) -> tuple[int, Any]:
+        return self._get(f"{API_PREFIX}/projects/{project_id}/workflows/{workflow_id}/published")
+
+    def flow_deployment(
+        self,
+        project_id: str,
+        workflow_id: str,
+        deployment_id: str,
+        *,
+        status_only: bool = False,
+    ) -> tuple[int, Any]:
+        return self._get(
+            f"{API_PREFIX}/projects/{project_id}/workflows/{workflow_id}/deployments/{deployment_id}",
+            {"statusOnly": "true"} if status_only else None,
+        )
+
+
+def _parse_body(r: httpx.Response) -> Any:
+    try:
+        return r.json()
+    except Exception:
+        return r.text
+
+
+def interpret_r_body(body: Any) -> tuple[Optional[int], Optional[str], Any]:
+    """Return (business code, msg, data) from server R<T> JSON or None if not shaped."""
+    if not isinstance(body, dict):
+        return None, None, body
+    if "code" in body and ("msg" in body or "message" in body):
+        msg = body.get("msg") or body.get("message")
+        return int(body["code"]), str(msg) if msg is not None else "", body.get("data")
+    return None, None, body
+
+
+def operation_ok(http_status: int, body: Any) -> bool:
+    if http_status < 200 or http_status >= 300:
+        return False
+    code, _, _ = interpret_r_body(body)
+    return body_success(code)