simplismart-sdk 0.1.0__py3-none-any.whl

simplismart/__init__.py

@@ -0,0 +1,40 @@
+"""Simplismart Python SDK."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .exceptions import SimplismartError
+from .models import (
+    DeploymentCreate,
+    ModelRepoCompileAvatar,
+    ModelRepoCompileCreate,
+    ModelRepoCreate,
+    ModelRepoListParams,
+    ModelRepoProfilesRequest,
+    SecretCreate,
+)
+
+__all__ = [
+    "Simplismart",
+    "SimplismartClient",
+    "SimplismartError",
+    "DeploymentCreate",
+    "ModelRepoCreate",
+    "ModelRepoCompileCreate",
+    "ModelRepoCompileAvatar",
+    "ModelRepoListParams",
+    "ModelRepoProfilesRequest",
+    "SecretCreate",
+]
+
+__version__ = "0.1.0"
+
+
+def __getattr__(name: str) -> Any:
+    """Lazy-load client symbols so model imports stay lightweight."""
+    if name in {"Simplismart", "SimplismartClient"}:
+        from .client import Simplismart, SimplismartClient
+
+        return {"Simplismart": Simplismart, "SimplismartClient": SimplismartClient}[name]
+    raise AttributeError(f"module 'simplismart' has no attribute '{name}'")

simplismart/api/__init__.py

@@ -0,0 +1,9 @@
+from .deployments import DeploymentAPI
+from .model_repos import ModelRepoAPI
+from .secrets import SecretAPI
+
+__all__ = [
+    "DeploymentAPI",
+    "ModelRepoAPI",
+    "SecretAPI",
+]

simplismart/api/deployments.py

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from ..http import HTTPClient
+from ..models.deployment import DeploymentCreate
+
+_MAX_PAGE_SIZE = 20
+_MAX_PAGE_OFFSET = 10_000
+
+
+def _normalize_status_filter(status: str | None) -> str | None:
+    if status is None:
+        return None
+    normalized = status.strip().upper()
+    return normalized or None
+
+
+def _status_matches(value: Any, *, status_filter: str) -> bool:
+    if not isinstance(value, str):
+        return False
+    normalized = value.upper()
+    return normalized == status_filter or normalized.startswith(f"{status_filter}_")
+
+
+class DeploymentAPI:
+    """
+    Deployment operations exposed to PG-authenticated SDK clients.
+
+    - Private deployment create: `/deployments/private/deploy-model/`
+    - Model deployment create (BYOC-oriented): `/deployments/model-deployments/`
+    - Model deployment read/delete: `/deployments/model-deployments/{id}/`
+    - Generic deployment edit: `/deployments/<id>/edit`
+    - Shared lifecycle ops: start/stop/restart/health/autoscaling/delete
+    """
+
+    def __init__(self, http: HTTPClient) -> None:
+        self._http = http
+
+    def list(
+        self,
+        *,
+        model_repo_id: Optional[str] = None,
+        status: str | None = None,
+        offset: int = 0,
+        count: int = 20,
+        trace_id: str | None = None,
+    ) -> Any:
+        """
+        List deployments for the org associated with the token.
+        If model_repo_id is provided, filter to that repo.
+
+        Note: the current backend list endpoint does not expose offset/count query params.
+        SDK applies client-side pagination for consistency with model-repo listing.
+        """
+        normalized_status = _normalize_status_filter(status)
+        safe_offset = max(0, min(offset, _MAX_PAGE_OFFSET))
+        safe_count = max(0, min(count, _MAX_PAGE_SIZE))
+        params: dict[str, Any] = {}
+        if model_repo_id:
+            params["model_repo_id"] = model_repo_id
+        if normalized_status:
+            params["status"] = normalized_status
+        response = self._http.request(
+            "GET",
+            "/deployments/list/model/",
+            params=params or None,
+            trace_id=trace_id,
+        )
+        if isinstance(response, list):
+            if normalized_status:
+                response = [
+                    item
+                    for item in response
+                    if _status_matches(item.get("status"), status_filter=normalized_status)
+                ]
+            end = safe_offset + safe_count
+            return response[safe_offset:end]
+        return response
+
+    def create_private_deployment(
+        self,
+        payload: DeploymentCreate,
+        *,
+        trace_id: str | None = None,
+    ) -> dict[str, Any]:
+        return self._http.request(
+            "POST",
+            "/deployments/private/deploy-model/",
+            json=payload.to_payload(),
+            trace_id=trace_id,
+        )
+
+    def list_model_deployments(
+        self,
+        *,
+        org_id: Optional[str] = None,
+        trace_id: str | None = None,
+    ) -> Any:
+        params = {"org": org_id} if org_id else None
+        return self._http.request(
+            "GET",
+            "/deployments/model-deployments/",
+            params=params,
+            trace_id=trace_id,
+        )
+
+    def create_byoc_deployment(self, payload: dict[str, Any], *, trace_id: str | None = None) -> Any:
+        return self._http.request(
+            "POST",
+            "/deployments/model-deployments/",
+            json=payload,
+            trace_id=trace_id,
+        )
+
+    def get_model_deployment(self, deployment_id: str, *, trace_id: str | None = None) -> Any:
+        return self._http.request(
+            "GET",
+            f"/deployments/model-deployments/{deployment_id}/",
+            trace_id=trace_id,
+        )
+
+    def delete_model_deployment(self, deployment_id: str, *, trace_id: str | None = None) -> bool:
+        self._http.request(
+            "DELETE",
+            f"/deployments/model-deployments/{deployment_id}/",
+            trace_id=trace_id,
+        )
+        return True
+
+    def update_deployment(
+        self,
+        deployment_id: str,
+        payload: dict[str, Any],
+        *,
+        trace_id: str | None = None,
+    ) -> Any:
+        return self._http.request(
+            "POST",
+            f"/deployments/{deployment_id}/edit",
+            json=payload,
+            trace_id=trace_id,
+        )
+
+    def stop(self, deployment_id: str, *, org_id: Optional[str] = None, trace_id: str | None = None) -> Any:
+        body: dict[str, Any] = {"action": "stop"}
+        if org_id:
+            body["org"] = org_id
+        return self._http.request(
+            "POST",
+            f"/deployments/{deployment_id}/startstop/",
+            json=body,
+            trace_id=trace_id,
+        )
+
+    def start(self, deployment_id: str, *, org_id: Optional[str] = None, trace_id: str | None = None) -> Any:
+        body: dict[str, Any] = {"action": "start"}
+        if org_id:
+            body["org"] = org_id
+        return self._http.request(
+            "POST",
+            f"/deployments/{deployment_id}/startstop/",
+            json=body,
+            trace_id=trace_id,
+        )
+
+    def restart(
+        self,
+        deployment_id: str,
+        *,
+        org_id: str,
+        namespace: str,
+        trace_id: str | None = None,
+    ) -> Any:
+        return self._http.request(
+            "POST",
+            f"/deployments/{deployment_id}/restart/",
+            json={"action": "restart", "org": org_id, "namespace": namespace},
+            trace_id=trace_id,
+        )
+
+    def fetch_health(self, deployment_id: str, *, trace_id: str | None = None) -> Any:
+        return self._http.request(
+            "GET",
+            f"/deployments/model-deployment/fetch-status/{deployment_id}/",
+            trace_id=trace_id,
+        )
+
+    def update_autoscaling(
+        self,
+        deployment_id: str,
+        *,
+        min_replicas: int,
+        max_replicas: int,
+        trace_id: str | None = None,
+    ) -> Any:
+        return self._http.request(
+            "POST",
+            f"/deployments/{deployment_id}/update-replicas/",
+            json={"min_replicas": min_replicas, "max_replicas": max_replicas},
+            trace_id=trace_id,
+        )
+
+    def delete(
+        self,
+        deployment_id: str,
+        *,
+        org_id: Optional[str] = None,
+        trace_id: str | None = None,
+    ) -> bool:
+        params = {"org_id": org_id} if org_id else None
+        self._http.request(
+            "DELETE",
+            f"/deployments/{deployment_id}/delete/",
+            params=params,
+            trace_id=trace_id,
+        )
+        return True

simplismart/api/model_repos.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from ..http import HTTPClient
+from ..models.model_repo import (
+    ModelRepoCompileCreate,
+    ModelRepoCreate,
+    ModelRepoListParams,
+    ModelRepoProfilesRequest,
+)
+
+
+class ModelRepoAPI:
+    """
+    Model repository operations: list, create (container/BYOM),
+    create private compile, delete, and profile generation.
+    """
+
+    def __init__(self, http: HTTPClient) -> None:
+        self._http = http
+
+    def list(self, params: ModelRepoListParams, *, trace_id: str | None = None) -> Any:
+        return self._http.request(
+            "GET",
+            "/models/client/model-repos/",
+            params=params.to_params(),
+            trace_id=trace_id,
+        )
+
+    def create(self, model_repo: ModelRepoCreate, *, trace_id: str | None = None) -> Dict[str, Any]:
+        """Create a model repo via client endpoint (container/BYOM flow)."""
+        return self._http.request(
+            "POST",
+            "/models/client/model-repos/",
+            json=model_repo.to_payload(),
+            trace_id=trace_id,
+        )
+
+    def create_private_compile(
+        self,
+        payload: ModelRepoCompileCreate,
+        *,
+        trace_id: str | None = None,
+    ) -> Dict[str, Any]:
+        """
+        Create a private compile model repo.
+
+        This path always sends `use_simplismart_infrastructure=true`.
+        """
+        body = payload.to_payload()
+        body["use_simplismart_infrastructure"] = True
+        return self._http.request(
+            "POST",
+            "/models/client/model-repos/",
+            json=body,
+            trace_id=trace_id,
+        )
+
+    def profiles(self, payload: ModelRepoProfilesRequest, *, trace_id: str | None = None) -> Any:
+        return self._http.request(
+            "POST",
+            "/models/model-profiles/",
+            json=payload.to_payload(),
+            trace_id=trace_id,
+        )
+
+    def delete(self, model_id: str, *, trace_id: str | None = None) -> bool:
+        self._http.request(
+            "DELETE",
+            "/models/client/model-repos/",
+            params={"model_id": model_id},
+            trace_id=trace_id,
+        )
+        return True

simplismart/api/secrets.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from ..http import HTTPClient
+from ..models.secret import SecretCreate
+
+
+class SecretAPI:
+    """
+    Secret operations. Uses PG token auth.
+
+    Notes:
+    - Secret config endpoint derives org context from pgToken.
+    - Secret list endpoint still requires explicit org_id query parameter on backend.
+    """
+
+    def __init__(self, http: HTTPClient) -> None:
+        self._http = http
+
+    def create(self, payload: SecretCreate, *, trace_id: str | None = None) -> Dict[str, Any]:
+        return self._http.request(
+            "POST",
+            "/accounts/secrets/",
+            json=payload.to_payload(),
+            trace_id=trace_id,
+        )
+
+    def list(self, *, org_id: str, trace_id: str | None = None) -> Any:
+        return self._http.request(
+            "GET",
+            "/accounts/secrets/",
+            params={"org_id": org_id},
+            trace_id=trace_id,
+        )
+
+    def get(self, secret_id: str, *, trace_id: str | None = None) -> Any:
+        return self._http.request("GET", f"/accounts/secrets/{secret_id}/", trace_id=trace_id)
+
+    def list_configs(self, *, trace_id: str | None = None) -> Any:
+        return self._http.request("GET", "/accounts/secret/config/", trace_id=trace_id)

simplismart/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package for Simplismart."""

simplismart/cli/common.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+from .. import Simplismart, SimplismartError
+from ..config import DEFAULT_TIMEOUT
+
+
+DEFAULT_BASE_URL = "https://api.app.simplismart.ai"
+
+
+def parse_env_list(items: Optional[List[str]]) -> Optional[Dict[str, str]]:
+    """Convert KEY=VALUE list into a dict."""
+    if not items:
+        return None
+    env: Dict[str, str] = {}
+    for item in items:
+        if "=" not in item:
+            raise argparse.ArgumentTypeError(f"Invalid env entry '{item}', expected KEY=VALUE.")
+        key, value = item.split("=", 1)
+        env[key] = value
+    return env
+
+
+def parse_json_or_file(value: Optional[str]) -> Optional[Any]:
+    """Allow passing JSON string or @path to JSON file."""
+    if value is None:
+        return None
+    if value.startswith("@"):
+        path = value[1:]
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    return json.loads(value)
+
+
+def build_client(args: argparse.Namespace) -> Simplismart:
+    token = args.pg_token or os.getenv("SIMPLISMART_PG_TOKEN")
+    base_url = args.base_url or os.getenv("SIMPLISMART_BASE_URL", DEFAULT_BASE_URL)
+
+    timeout_value = args.timeout
+    if timeout_value is None:
+        env_timeout = os.getenv("SIMPLISMART_TIMEOUT")
+        timeout_value = float(env_timeout) if env_timeout else None
+
+    return Simplismart(
+        pg_token=token,
+        base_url=base_url,
+        timeout=timeout_value,
+    )
+
+
+def handle_cli_errors(func):
+    """Decorator to wrap CLI handlers with consistent error output."""
+
+    def wrapper(args: argparse.Namespace) -> None:
+        try:
+            func(args)
+        except SimplismartError as exc:
+            payload = getattr(exc, "payload", None)
+            status = getattr(exc, "status_code", None)
+            message = str(exc.args[0]) if getattr(exc, "args", None) else str(exc)
+
+            response_body = {
+                "error": message,
+                "status": status,
+            }
+
+            payload_has_only_message = False
+            if isinstance(payload, dict):
+                candidate = (
+                    payload.get("detail")
+                    or payload.get("error")
+                    or payload.get("message")
+                )
+                payload_has_only_message = (
+                    candidate is not None
+                    and str(candidate) == message
+                    and len(payload) == 1
+                )
+
+            if payload and not payload_has_only_message:
+                response_body["payload"] = payload
+
+            print(json.dumps(response_body, indent=2, default=str))
+            raise SystemExit(1)
+        except Exception as exc:  # pragma: no cover - CLI safeguard
+            print(json.dumps({"error": str(exc)}))
+            raise SystemExit(1)
+
+    return wrapper