usegradient 1.3.1__py3-none-any.whl

gradient_sdk/models.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field, is_dataclass
+from typing import Any, Mapping
+
+
+JsonMapping = Mapping[str, Any]
+
+
+def to_payload(value: Any) -> Any:
+    """Convert SDK models into JSON-serializable API payloads."""
+
+    if is_dataclass(value):
+        return to_payload(asdict(value))
+    if isinstance(value, Mapping):
+        return {
+            str(k): to_payload(v)
+            for k, v in value.items()
+            if v is not None
+        }
+    if isinstance(value, (list, tuple)):
+        return [to_payload(v) for v in value]
+    return value
+
+
+@dataclass(slots=True)
+class PortEntry:
+    port: int = 443
+    handlers: list[str] | None = None
+
+    @classmethod
+    def default_https(cls) -> "PortEntry":
+        return cls(port=443, handlers=["tls", "http"])
+
+
+@dataclass(slots=True)
+class ServiceConfig:
+    internal_port: int = 8080
+    protocol: str = "tcp"
+    ports: list[PortEntry] | list[dict[str, Any]] | None = None
+
+    @classmethod
+    def default_https(cls) -> "ServiceConfig":
+        return cls(internal_port=8080, protocol="tcp", ports=[PortEntry.default_https()])
+
+
+@dataclass(slots=True)
+class Guest:
+    cpu_kind: str = "shared"
+    cpus: int = 2
+    memory_mb: int = 1024
+
+
+@dataclass(slots=True)
+class Restart:
+    policy: str = "no"
+
+
+@dataclass(slots=True)
+class MachineSpec:
+    image: str
+    guest: Guest | dict[str, Any] | None = None
+    env: dict[str, str] | None = None
+    services: list[ServiceConfig] | list[dict[str, Any]] | None = None
+    restart: Restart | dict[str, Any] | None = None
+    metadata: dict[str, str] | None = None
+    auto_destroy: bool | None = None
+
+
+@dataclass(slots=True)
+class MachineCreateRequest:
+    config: MachineSpec | dict[str, Any]
+    name: str | None = None
+    region: str | None = None
+
+
+@dataclass(slots=True)
+class WhoamiResponse:
+    slug: str
+    name: str
+    fly_app_slug: str
+    registry_url: str
+    proxy_url: str
+    scopes: list[str]
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "WhoamiResponse":
+        return cls(
+            slug=str(data.get("slug", "")),
+            name=str(data.get("name", "")),
+            fly_app_slug=str(data.get("flyAppSlug", data.get("fly_app_slug", ""))),
+            registry_url=str(data.get("registryUrl", data.get("registry_url", ""))),
+            proxy_url=str(data.get("proxyUrl", data.get("proxy_url", ""))),
+            scopes=list(data.get("scopes", [])),
+        )
+
+
+@dataclass(slots=True)
+class CreateMachineResponse:
+    id: str
+    name: str
+    state: str
+    region: str
+    private_ip: str
+    host: str
+    slug: str
+    proxy_url: str
+    proxy_session_token: str = ""
+    proxy_session_expires_at: str = ""
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "CreateMachineResponse":
+        return cls(
+            id=str(data.get("id", "")),
+            name=str(data.get("name", "")),
+            state=str(data.get("state", "")),
+            region=str(data.get("region", "")),
+            private_ip=str(data.get("private_ip", "")),
+            host=str(data.get("host", "")),
+            slug=str(data.get("slug", "")),
+            proxy_url=str(data.get("proxy_url", "")),
+            proxy_session_token=str(data.get("proxy_session_token", "")),
+            proxy_session_expires_at=str(data.get("proxy_session_expires_at", "")),
+        )
+
+
+@dataclass(slots=True)
+class MachineListItem:
+    id: str
+    name: str
+    state: str
+    region: str
+    created_at: str
+    updated_at: str
+    private_ip: str
+    metadata: dict[str, str]
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "MachineListItem":
+        return cls(
+            id=str(data.get("id", "")),
+            name=str(data.get("name", "")),
+            state=str(data.get("state", "")),
+            region=str(data.get("region", "")),
+            created_at=str(data.get("created_at", "")),
+            updated_at=str(data.get("updated_at", "")),
+            private_ip=str(data.get("private_ip", "")),
+            metadata=dict(data.get("metadata", {})),
+        )
+
+
+@dataclass(slots=True)
+class ExecMachineResponse:
+    exit_code: int
+    exit_signal: int
+    stdout: str
+    stderr: str
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "ExecMachineResponse":
+        return cls(
+            exit_code=int(data.get("exit_code", 0)),
+            exit_signal=int(data.get("exit_signal", 0)),
+            stdout=str(data.get("stdout", "")),
+            stderr=str(data.get("stderr", "")),
+        )
+
+
+@dataclass(slots=True)
+class AppSecret:
+    name: str
+    digest: str
+    created_at: str
+    updated_at: str
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "AppSecret":
+        return cls(
+            name=str(data.get("name", "")),
+            digest=str(data.get("digest", "")),
+            created_at=str(data.get("created_at", "")),
+            updated_at=str(data.get("updated_at", "")),
+        )
+
+
+@dataclass(slots=True)
+class TraceRun:
+    id: str
+    machine_id: str
+    trace_mode: str
+    status: str
+    proxy_url: str
+    created_at: str
+    started_at: str
+    ended_at: str
+    metadata: dict[str, Any]
+    capture_policy: dict[str, Any]
+    expires_at: str
+    parent_run_id: str = ""
+    replay_config: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "TraceRun":
+        return cls(
+            id=str(data.get("id", "")),
+            machine_id=str(data.get("machine_id") or ""),
+            trace_mode=str(data.get("trace_mode", "")),
+            status=str(data.get("status", "")),
+            proxy_url=str(data.get("proxy_url") or ""),
+            created_at=str(data.get("created_at", "")),
+            started_at=str(data.get("started_at") or ""),
+            ended_at=str(data.get("ended_at") or ""),
+            metadata=dict(data.get("metadata") or {}),
+            capture_policy=dict(data.get("capture_policy") or {}),
+            expires_at=str(data.get("expires_at") or ""),
+            parent_run_id=str(data.get("parent_run_id") or ""),
+            replay_config=dict(data.get("replay_config") or {}),
+        )
+
+
+@dataclass(slots=True)
+class CreateTraceRunResponse(TraceRun):
+    ingest_token: str = ""
+    ingest_url: str = ""
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "CreateTraceRunResponse":
+        base = TraceRun.from_dict(data)
+        return cls(
+            id=base.id,
+            machine_id=base.machine_id,
+            trace_mode=base.trace_mode,
+            status=base.status,
+            proxy_url=base.proxy_url,
+            created_at=base.created_at,
+            started_at=base.started_at,
+            ended_at=base.ended_at,
+            metadata=base.metadata,
+            capture_policy=base.capture_policy,
+            expires_at=base.expires_at,
+            parent_run_id=base.parent_run_id,
+            replay_config=base.replay_config,
+            ingest_token=str(data.get("ingest_token", "")),
+            ingest_url=str(data.get("ingest_url", "")),
+        )
+
+
+@dataclass(slots=True)
+class ReplayTraceRunResponse(CreateTraceRunResponse):
+    template: dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "ReplayTraceRunResponse":
+        base = CreateTraceRunResponse.from_dict(data)
+        return cls(
+            id=base.id,
+            machine_id=base.machine_id,
+            trace_mode=base.trace_mode,
+            status=base.status,
+            proxy_url=base.proxy_url,
+            created_at=base.created_at,
+            started_at=base.started_at,
+            ended_at=base.ended_at,
+            metadata=base.metadata,
+            capture_policy=base.capture_policy,
+            expires_at=base.expires_at,
+            parent_run_id=base.parent_run_id,
+            replay_config=base.replay_config,
+            ingest_token=base.ingest_token,
+            ingest_url=base.ingest_url,
+            template=dict(data.get("template") or {}),
+        )
+
+
+@dataclass(slots=True)
+class TraceEvent:
+    id: str
+    run_id: str
+    machine_id: str
+    source: str
+    type: str
+    ts: str
+    data: dict[str, Any]
+    created_at: str
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "TraceEvent":
+        return cls(
+            id=str(data.get("id", "")),
+            run_id=str(data.get("run_id", "")),
+            machine_id=str(data.get("machine_id") or ""),
+            source=str(data.get("source", "")),
+            type=str(data.get("type", "")),
+            ts=str(data.get("ts", "")),
+            data=dict(data.get("data") or {}),
+            created_at=str(data.get("created_at", "")),
+        )
+
+
+@dataclass(slots=True)
+class TraceSpan:
+    id: str
+    run_id: str
+    machine_id: str
+    project_name: str
+    session_id: str
+    user_id: str
+    model_name: str
+    provider: str
+    trace_id: str
+    span_id: str
+    parent_span_id: str
+    name: str
+    kind: str
+    start_time: str
+    end_time: str
+    duration_ms: float
+    status_code: str
+    status_message: str
+    prompt_tokens: int | None
+    completion_tokens: int | None
+    total_tokens: int | None
+    total_cost: float | None
+    attributes: dict[str, Any]
+    events: list[dict[str, Any]]
+    resource_attributes: dict[str, Any]
+    scope_name: str
+    scope_version: str
+
+    @classmethod
+    def from_dict(cls, data: JsonMapping) -> "TraceSpan":
+        return cls(
+            id=str(data.get("id", "")),
+            run_id=str(data.get("run_id", "")),
+            machine_id=str(data.get("machine_id") or ""),
+            project_name=str(data.get("project_name", "")),
+            session_id=str(data.get("session_id") or ""),
+            user_id=str(data.get("user_id") or ""),
+            model_name=str(data.get("model_name") or ""),
+            provider=str(data.get("provider") or ""),
+            trace_id=str(data.get("trace_id", "")),
+            span_id=str(data.get("span_id", "")),
+            parent_span_id=str(data.get("parent_span_id") or ""),
+            name=str(data.get("name", "")),
+            kind=str(data.get("kind", "")),
+            start_time=str(data.get("start_time", "")),
+            end_time=str(data.get("end_time", "")),
+            duration_ms=float(data.get("duration_ms") or 0),
+            status_code=str(data.get("status_code", "")),
+            status_message=str(data.get("status_message") or ""),
+            prompt_tokens=(
+                int(data["prompt_tokens"]) if data.get("prompt_tokens") is not None else None
+            ),
+            completion_tokens=(
+                int(data["completion_tokens"])
+                if data.get("completion_tokens") is not None
+                else None
+            ),
+            total_tokens=(
+                int(data["total_tokens"]) if data.get("total_tokens") is not None else None
+            ),
+            total_cost=(
+                float(data["total_cost"]) if data.get("total_cost") is not None else None
+            ),
+            attributes=dict(data.get("attributes") or {}),
+            events=list(data.get("events") or []),
+            resource_attributes=dict(data.get("resource_attributes") or {}),
+            scope_name=str(data.get("scope_name") or ""),
+            scope_version=str(data.get("scope_version") or ""),
+        )

gradient_sdk/py.typed

@@ -0,0 +1 @@
+