gcube-cli 0.1.0__py3-none-any.whl

gcube_cli/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+try:
+    __version__: str = importlib.metadata.version("gcube-cli")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "0.0.0-dev"

gcube_cli/__main__.py

@@ -0,0 +1,4 @@
+from gcube_cli.cli import main
+
+if __name__ == "__main__":
+    main()

gcube_cli/_group.py

@@ -0,0 +1,8 @@
+import click
+
+
+class OrderedGroup(click.Group):
+    """click.Group that lists commands in insertion order instead of alphabetically."""
+
+    def list_commands(self, ctx: click.Context) -> list[str]:  # noqa: ARG002
+        return list(self.commands)

gcube_cli/api/__init__.py

@@ -0,0 +1,16 @@
+"""gcube_cli API package — public re-exports."""
+
+from gcube_cli.api.client import APIError, AuthError, Client, make_client
+from gcube_cli.api.credential import Credential, CredentialAPI
+from gcube_cli.api.workload import Workload, WorkloadAPI
+
+__all__ = [
+    "APIError",
+    "AuthError",
+    "Client",
+    "make_client",
+    "Credential",
+    "CredentialAPI",
+    "Workload",
+    "WorkloadAPI",
+]

gcube_cli/api/client.py

@@ -0,0 +1,225 @@
+"""Base HTTP client for gcube CLI."""
+
+from __future__ import annotations
+
+import functools
+import sys
+from typing import Any, cast
+
+import click
+import httpx
+
+# ---------------------------------------------------------------------------
+# Exceptions
+# ---------------------------------------------------------------------------
+
+
+class AuthError(Exception):
+    """Raised on HTTP 401 — token expired or invalid."""
+
+    MESSAGE = (
+        "Token expired or invalid. "
+        "Please get a new token from https://gcube.ai"
+    )
+
+    def __init__(self) -> None:
+        super().__init__(self.MESSAGE)
+
+
+class APIError(Exception):
+    """Raised when the gcube API returns status != 200 in the response body."""
+
+    def __init__(self, status_code: int, code: str, message: str) -> None:
+        self.status_code = status_code
+        self.code = code
+        self.message = message
+        super().__init__(f"API Error [{code}]: {message}")
+
+
+# ---------------------------------------------------------------------------
+# Command-layer decorator
+# ---------------------------------------------------------------------------
+
+
+def handle_api_errors(func: Any) -> Any:
+    """Decorator that catches AuthError / APIError and exits with the correct code.
+
+    Apply to every Click command that calls the API.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        try:
+            return func(*args, **kwargs)
+        except AuthError as e:
+            click.echo(str(e), err=True)
+            sys.exit(3)
+        except APIError as e:
+            click.echo(f"API Error [{e.code}]: {e.message}", err=True)
+            sys.exit(2)
+
+    return wrapper
+
+
+# ---------------------------------------------------------------------------
+# Client
+# ---------------------------------------------------------------------------
+
+
+def _make_debug_hooks(base_url: str) -> dict[str, list[Any]]:
+    """Return httpx event hooks that print request/response to stderr."""
+    import json as _json
+
+    def _pretty(raw: str) -> str:
+        try:
+            return _json.dumps(_json.loads(raw), ensure_ascii=False, indent=2)
+        except (ValueError, TypeError):
+            return raw
+
+    def _log_request(request: httpx.Request) -> None:
+        click.echo(f"\n[DEBUG] >>> {request.method} {request.url}", err=True)
+        if request.content:
+            click.echo("[DEBUG] >>> Body:", err=True)
+            click.echo(_pretty(request.content.decode("utf-8", errors="replace")), err=True)
+
+    def _log_response(response: httpx.Response) -> None:
+        response.read()
+        click.echo(f"[DEBUG] <<< {response.status_code}", err=True)
+        click.echo("[DEBUG] <<< Body:", err=True)
+        click.echo(_pretty(response.text), err=True)
+
+    return {"request": [_log_request], "response": [_log_response]}
+
+
+class Client:
+    """Synchronous HTTP client with Bearer auth and uniform error handling."""
+
+    def __init__(self, base_url: str, token: str, debug: bool = False) -> None:
+        self.base_url = base_url
+        self.debug = debug
+        init_kwargs: dict[str, Any] = {
+            "base_url": base_url,
+            "headers": {
+                "Authorization": f"Bearer {token}",
+                "Content-Type": "application/json",
+            },
+            "timeout": 30.0,
+        }
+        if debug:
+            init_kwargs["event_hooks"] = _make_debug_hooks(base_url)
+        self._client = httpx.Client(**init_kwargs)
+
+    # ------------------------------------------------------------------
+    # Internal request dispatcher
+    # ------------------------------------------------------------------
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+        """Execute an HTTP request and return the parsed JSON body.
+
+        Error handling order:
+        1. httpx.RequestError (network/timeout)  → sys.exit(4)
+        2. HTTP 401                              → raise AuthError
+        3. raise_for_status() for other 4xx/5xx → wrap as APIError
+        4. body["status"] != 200                 → raise APIError
+        """
+        try:
+            response = self._client.request(method, path, **kwargs)
+        except httpx.RequestError:
+            click.echo(
+                f"Cannot connect to {self.base_url}. Check network.",
+                err=True,
+            )
+            sys.exit(4)
+
+        # 401 — try to parse body first; only raise AuthError for bare token failures
+        if response.status_code == 401:
+            try:
+                err_data = cast(dict[str, Any], response.json())
+                if "error" in err_data and "message" in err_data:
+                    raise APIError(
+                        err_data.get("status", 401),
+                        err_data.get("error", "UNAUTHORIZED"),
+                        err_data.get("message", "Unauthorized"),
+                    )
+            except (ValueError, KeyError):
+                pass
+            raise AuthError()
+
+        # Other unexpected HTTP-level errors (e.g. 500 with no JSON body)
+        try:
+            response.raise_for_status()
+        except httpx.HTTPStatusError as exc:
+            # Try to extract gcube envelope; fall back to generic message
+            try:
+                err_data = cast(dict[str, Any], exc.response.json())
+                raise APIError(
+                    err_data.get("status", exc.response.status_code),
+                    err_data.get("error", str(exc.response.status_code)),
+                    err_data.get("message", exc.response.text),
+                ) from exc
+            except (ValueError, KeyError):
+                raise APIError(
+                    exc.response.status_code,
+                    str(exc.response.status_code),
+                    exc.response.text,
+                ) from exc
+
+        # Parse gcube response envelope
+        data: dict[str, Any] = cast(dict[str, Any], response.json())
+        if data.get("status") != 200:
+            raise APIError(
+                data.get("status", 0),
+                data.get("error", ""),
+                data.get("message", "Unknown error"),
+            )
+
+        return data
+
+    # ------------------------------------------------------------------
+    # Public HTTP methods
+    # ------------------------------------------------------------------
+
+    def get(self, path: str, **kwargs: Any) -> dict[str, Any]:
+        return self._request("GET", path, **kwargs)
+
+    def post(
+        self, path: str, json: dict[str, Any] | None = None, **kwargs: Any
+    ) -> dict[str, Any]:
+        return self._request("POST", path, json=json, **kwargs)
+
+    def put(
+        self, path: str, json: dict[str, Any] | None = None, **kwargs: Any
+    ) -> dict[str, Any]:
+        return self._request("PUT", path, json=json, **kwargs)
+
+    def delete(self, path: str, **kwargs: Any) -> dict[str, Any]:
+        return self._request("DELETE", path, **kwargs)
+
+
+# ---------------------------------------------------------------------------
+# Factory
+# ---------------------------------------------------------------------------
+
+
+def make_client(
+    config: Any,  # gcube_cli.config.config.GcubeConfig — Any to avoid circular import
+    debug: bool = False,
+    platform_url: str | None = None,
+) -> Client:
+    """Create a Client from a loaded GcubeConfig object.
+
+    Exits with code 1 if no token is configured.
+    """
+    token: str | None = None
+    if config.auth:
+        token = config.auth.access_token or None
+
+    if not token:
+        click.echo(
+            "No token configured. Run: gcube configure set --token <token>",
+            err=True,
+        )
+        sys.exit(1)
+
+    base_url = platform_url or config.platform_url or "https://api.gcube.ai"
+    return Client(base_url=base_url, token=token, debug=debug)

gcube_cli/api/credential.py

@@ -0,0 +1,68 @@
+"""Credential management API client for gcube CLI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from gcube_cli.api.client import Client
+
+
+@dataclass
+class Credential:
+    """Container image registry credential."""
+
+    owner: str
+    category: str       # 항상 "repo"
+    cloud: str          # docker | github | harbor | aws | huggingface | quay
+    acc_key: str        # JSON: accKey (username)
+    sec_key: str        # JSON: secKey (token/password)
+    region: str | None = None        # AWS ECR region
+    registry_id: str | None = None   # JSON: registryId (AWS ECR only)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Credential:
+        return cls(
+            owner=data.get("owner", ""),
+            category=data.get("category", ""),
+            cloud=data.get("cloud", ""),
+            acc_key=data.get("accKey", data.get("acc_key", "")),
+            sec_key=data.get("secKey", data.get("sec_key", "")),
+            region=data.get("region") or None,
+            registry_id=data.get("registryId", data.get("registry_id")) or None,
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to camelCase JSON dict for the API request."""
+        return {
+            "owner": self.owner,
+            "category": self.category,
+            "cloud": self.cloud,
+            "accKey": self.acc_key,
+            "secKey": self.sec_key,
+            "region": self.region or "",
+            "registryId": self.registry_id or "",
+        }
+
+
+class CredentialAPI:
+    """High-level Credential API client."""
+
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def list(self, owner: str) -> list[Credential]:
+        """GET /api/credential/list?owner={email}"""
+        data = self._client.get("/api/credential/list", params={"owner": owner})
+        items: list[dict[str, Any]] = data.get("credentials", data.get("data", data.get("items", [])))
+        return [Credential.from_dict(item) for item in items]
+
+    def create(self, cred: Credential) -> Credential:
+        """POST /api/credential/register"""
+        data = self._client.post("/api/credential/register", json=cred.to_dict())
+        item: dict[str, Any] = data.get("data", data)
+        return Credential.from_dict(item) if isinstance(item, dict) and item else cred
+
+    def delete(self, cloud: str) -> None:
+        """DELETE /api/credential/delete/repo/{cloud}"""
+        self._client.delete(f"/api/credential/delete/repo/{cloud}")

gcube_cli/api/logs.py

@@ -0,0 +1,52 @@
+"""WebSocket log streaming for gcube workloads (PBI-016)."""
+
+from __future__ import annotations
+
+import click
+import websockets
+import websockets.exceptions
+
+
+class LogsConnectionError(Exception):
+    """Raised when the WebSocket connection to the log stream fails."""
+
+
+class LogsAuthError(Exception):
+    """Raised when the server rejects the connection due to auth failure."""
+
+
+class LogStreamer:
+    def __init__(self, ws_url: str, token: str) -> None:
+        self.ws_url = ws_url.rstrip("/")
+        self.token = token
+
+    async def stream(self, ser: str, pod_name: str, ct_index: int = 0) -> None:
+        """Open a WebSocket and stream log messages to stdout.
+
+        The server always requires /container/{ct_index} in the URL path.
+        ct_index defaults to 0 for single-container pods.
+        """
+        url = (
+            f"{self.ws_url}/workloads/{ser}/log/{pod_name}"
+            f"/container/{ct_index}?token={self.token}"
+        )
+
+        try:
+            async with websockets.connect(url, close_timeout=0) as ws:
+                async for message in ws:
+                    click.echo(message, nl=False)
+        except websockets.exceptions.ConnectionClosed:
+            pass  # server closed the stream (clean close or proxy timeout)
+        except websockets.exceptions.InvalidStatus as exc:
+            status_code = getattr(getattr(exc, "response", None), "status_code", 0)
+            if status_code in (401, 403):
+                raise LogsAuthError(
+                    "Token expired or invalid. Please get a new token from https://console.gcube.ai"
+                ) from exc
+            raise LogsConnectionError(
+                f"Cannot connect to log stream (HTTP {status_code}). Check ws-url configuration."
+            ) from exc
+        except (OSError, websockets.exceptions.WebSocketException) as exc:
+            raise LogsConnectionError(
+                "Cannot connect to log stream. Check ws-url configuration."
+            ) from exc

gcube_cli/api/point.py

@@ -0,0 +1,173 @@
+"""Point balance and usage API client for gcube CLI (PBI-013)."""
+
+from __future__ import annotations
+
+import calendar
+import datetime
+from dataclasses import dataclass
+from typing import Any
+
+from gcube_cli.api.client import Client
+
+
+@dataclass
+class PointStatus:
+    available_point: int
+    charge_point: int
+    spend_point: int
+    net_point: int
+    is_blocked: bool
+    is_alarm: bool
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PointStatus:
+        points: dict[str, Any] = data.get("points", data)
+        return cls(
+            available_point=int(points.get("availablePoint", 0)),
+            charge_point=int(points.get("chargePoint", 0)),
+            spend_point=int(points.get("spendPoint", 0)),
+            net_point=int(points.get("netPoint", 0)),
+            is_blocked=bool(points.get("isBlocked", False)),
+            is_alarm=bool(points.get("isAlarm", False)),
+        )
+
+
+@dataclass
+class PointSpendSummary:
+    total_spend: int
+    prev_month_spend: int
+    this_month_spend: int
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PointSpendSummary:
+        points: dict[str, Any] = data.get("points", data)
+        total = points.get("totalSpend", {})
+        prev = points.get("prevMonthSpend", {})
+        this = points.get("thisMonthSpend", {})
+        return cls(
+            total_spend=int(total.get("point", 0) if isinstance(total, dict) else total),
+            prev_month_spend=int(prev.get("point", 0) if isinstance(prev, dict) else prev),
+            this_month_spend=int(this.get("point", 0) if isinstance(this, dict) else this),
+        )
+
+
+@dataclass
+class DailySpend:
+    date: str
+    point: float
+    krw_amount: int
+    krw_unit_amount: int
+    krw_usage_amount: int
+    gpu_usage: float
+    net_rx: float
+    net_tx: float
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> DailySpend:
+        return cls(
+            date=str(data.get("date", "")),
+            point=float(data.get("point", 0)),
+            krw_amount=int(data.get("krwAmount", 0)),
+            krw_unit_amount=int(data.get("krwUnitAmount", 0)),
+            krw_usage_amount=int(data.get("krwUsageAmount", 0)),
+            gpu_usage=float(data.get("gpuUsage", 0)),
+            net_rx=float(data.get("netRx", 0)),
+            net_tx=float(data.get("netTx", 0)),
+        )
+
+
+def _month_range(month: str) -> tuple[str, str]:
+    """'YYYY-MM' → ('YYYY-MM-01', 'YYYY-MM-DD') 말일 계산."""
+    year, mon = int(month[:4]), int(month[5:7])
+    last_day = calendar.monthrange(year, mon)[1]
+    return f"{year:04d}-{mon:02d}-01", f"{year:04d}-{mon:02d}-{last_day:02d}"
+
+
+def _current_month_range() -> tuple[str, str]:
+    today = datetime.date.today()
+    return f"{today.year:04d}-{today.month:02d}-01", today.strftime("%Y-%m-%d")
+
+
+# status API (/api/point/status) 에서 표시할 필드만 허용
+_STATUS_ALLOWLIST = frozenset({
+    "availablePoint", "chargePoint", "spendPoint", "netPoint",
+    "isBlocked", "isAlarm",
+})
+
+# daily spends 항목에서 제외할 필드명
+_EXCLUDED_SPENDING_EXACT = frozenset({"gpuPoint", "namespace", "krw", "useTime", "owner"})
+# daily spends 항목에서 제외할 패턴 (substring match, 대소문자 구분)
+# - "Gpu": krwGpuAmount 등 GCUBE 내부 단가
+# - "vram","cpu","mem","disk": resource 커맨드 영역
+_EXCLUDED_SPENDING_PATTERN = ("income", "settle", "refund", "Gpu", "vram", "cpu", "mem", "disk")
+
+
+def _filter_status_json(raw: dict[str, Any]) -> dict[str, Any]:
+    """status JSON: 허용 목록 필드만 출력."""
+    points = raw.get("points", {})
+    return {"points": {k: v for k, v in points.items() if k in _STATUS_ALLOWLIST}}
+
+
+def _filter_spend_summary_json(raw: dict[str, Any]) -> dict[str, Any]:
+    """spend/status JSON: 각 항목의 point 값만 추출하여 flat 구조로 반환."""
+    points = raw.get("points", {})
+
+    def _pt(key: str) -> int:
+        val = points.get(key, {})
+        return int(val.get("point", 0) if isinstance(val, dict) else val)
+
+    return {
+        "totalSpend": _pt("totalSpend"),
+        "prevMonthSpend": _pt("prevMonthSpend"),
+        "thisMonthSpend": _pt("thisMonthSpend"),
+    }
+
+
+def _filter_spending_json(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """daily spends JSON: gpuPoint/namespace/krw + income/settle/refund/*Gpu* 제외."""
+    result = []
+    for item in items:
+        filtered = {
+            k: v for k, v in item.items()
+            if k not in _EXCLUDED_SPENDING_EXACT
+            and not any(ex in k for ex in _EXCLUDED_SPENDING_PATTERN)
+        }
+        result.append(filtered)
+    return result
+
+
+class PointAPI:
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def status(self, owner: str) -> tuple[PointStatus, dict[str, Any]]:
+        """GET /api/point/status?owner={email}. Returns (model, raw_data)."""
+        raw = self._client.get("/api/point/status", params={"owner": owner})
+        data: dict[str, Any] = raw.get("data", raw)
+        return PointStatus.from_dict(data), data
+
+    def spend_summary(self, owner: str) -> tuple[PointSpendSummary, dict[str, Any]]:
+        """GET /api/point/spend/status?owner={email}. Returns (model, raw_data)."""
+        raw = self._client.get("/api/point/spend/status", params={"owner": owner})
+        data: dict[str, Any] = raw.get("data", raw)
+        return PointSpendSummary.from_dict(data), data
+
+    def daily_spends(
+        self,
+        owner: str,
+        workload: int | None = None,
+        start_time: str | None = None,
+        end_time: str | None = None,
+    ) -> tuple[list[DailySpend], list[dict[str, Any]]]:
+        """GET /api/point/daily/spends. Returns (models, raw_items)."""
+        params: dict[str, Any] = {"owner": owner}
+        if workload is not None:
+            params["workload"] = workload
+        if start_time:
+            params["startTime"] = start_time
+        if end_time:
+            params["endTime"] = end_time
+        raw = self._client.get("/api/point/daily/spends", params=params)
+        data: dict[str, Any] = raw.get("data", raw)
+        items: list[dict[str, Any]] = data.get("pointSpends", [])
+        return [DailySpend.from_dict(i) for i in items], items

gcube_cli/api/resource.py

@@ -0,0 +1,108 @@
+"""Resource monitoring API client for gcube CLI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+from gcube_cli.api.client import APIError, Client
+
+_GAI_BASE = "/api/workloads/gai/"
+
+
+def _parse_time_interval(ti: Any) -> str | None:
+    """Convert timeInterval from the API into a human-readable string.
+
+    Handles two formats the API may return:
+    - float/int: Unix timestamp in milliseconds → "YYYY-MM-DD HH:MM"
+    - list [year, month, day, hour, minute]: → "YYYY-MM-DD HH:MM"
+    - str: pass through as-is
+    """
+    if ti is None:
+        return None
+    if isinstance(ti, (int, float)):
+        return datetime.fromtimestamp(ti / 1000).strftime("%Y-%m-%d %H:%M")
+    if isinstance(ti, list) and len(ti) >= 5:
+        y, m, d, h, mi = int(ti[0]), int(ti[1]), int(ti[2]), int(ti[3]), int(ti[4])
+        return f"{y:04d}-{m:02d}-{d:02d} {h:02d}:{mi:02d}"
+    return str(ti)
+
+
+@dataclass
+class ResourceUsage:
+    """Resource usage snapshot for a pod."""
+
+    gpu_name: str       # JSON: gpuName  (시간평균 응답에만 있음)
+    gpu_usage: float    # JSON: gpuUsage,  단위 %
+    vram_usage: float   # JSON: vramUsage, 단위 %
+    vram_cap: int       # JSON: vramCap,   단위 MB
+    cpu_usage: float    # JSON: cpuUsage,  단위 %
+    mem_usage: float    # JSON: memUsage,  단위 %
+    disk_usage: float   # JSON: diskUsage, 단위 %
+    disk_occu: float    # JSON: diskOccu,  단위 MB
+    net_rx: float       # JSON: netRx,     단위 kbps
+    net_tx: float       # JSON: netTx,     단위 kbps
+    time_interval: str | None = None  # JSON: timeInterval
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> ResourceUsage:
+        return cls(
+            gpu_name=data.get("gpuName", ""),
+            gpu_usage=round(float(data.get("gpuUsage", 0.0)), 2),
+            vram_usage=round(float(data.get("vramUsage", 0.0)), 2),
+            vram_cap=int(data.get("vramCap", 0)),
+            cpu_usage=round(float(data.get("cpuUsage", 0.0)), 2),
+            mem_usage=round(float(data.get("memUsage", 0.0)), 2),
+            disk_usage=round(float(data.get("diskUsage", 0.0)), 2),
+            disk_occu=round(float(data.get("diskOccu", 0.0)), 2),
+            net_rx=round(float(data.get("netRx", 0.0)), 2),
+            net_tx=round(float(data.get("netTx", 0.0)), 2),
+            time_interval=_parse_time_interval(data.get("timeInterval")),
+        )
+
+
+class ResourceAPI:
+    """Resource usage API client.
+
+    2-step lookup: workload name → pod list → per-pod resource usage.
+
+    Endpoint: GET /api/usage/avg → response key: ``usages`` (list)
+    """
+
+    def __init__(self, client: Client) -> None:
+        self._client = client
+
+    def get_workload_pods(self, workload_name: str) -> list[str]:
+        """Resolve workload name to a list of running pod names."""
+        data = self._client.get(f"{_GAI_BASE}{workload_name}")
+        item: dict[str, Any] = data.get("workload", data.get("data", data))
+        pods: list[dict[str, Any]] = item.get("pods") or []
+        return [p["name"] for p in pods if p.get("name")]
+
+    def workload(self, workload_name: str) -> dict[str, list[ResourceUsage]]:
+        """Get time-series resource usage grouped by pod name.
+
+        Returns:
+            Mapping of pod_name → list[ResourceUsage].
+
+        Raises:
+            APIError: If workload has no running pods or an API call fails.
+        """
+        pods = self.get_workload_pods(workload_name)
+        if not pods:
+            raise APIError(
+                status_code=404,
+                code="NO_PODS",
+                message=f"Workload '{workload_name}' has no running pods. Is it stopped?",
+            )
+        return {pod: self._get_avg(pod) for pod in pods}
+
+    def _get_avg(self, pod_name: str) -> list[ResourceUsage]:
+        """GET /api/usage/avg?pod={pod}&isPod=true"""
+        data = self._client.get(
+            "/api/usage/avg",
+            params={"pod": pod_name, "isPod": "true"},
+        )
+        items: list[dict[str, Any]] = data.get("usages", [])
+        return [ResourceUsage.from_dict(item) for item in items]