plato-sdk-v2 2.0.50__py3-none-any.whl → 2.2.4__py3-none-any.whl

plato/chronos/api/jobs/launch_job.py

@@ -0,0 +1,63 @@
+"""Launch Job"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import LaunchJobRequest, LaunchJobResponse
+
+
+def _build_request_args(
+    body: LaunchJobRequest,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = "/api/jobs/launch"
+
+    headers: dict[str, str] = {}
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "POST",
+        "url": url,
+        "json": body.model_dump(mode="json", exclude_none=True),
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    body: LaunchJobRequest,
+    x_api_key: str | None = None,
+) -> LaunchJobResponse:
+    """Launch a new Chronos job."""
+
+    request_args = _build_request_args(
+        body=body,
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return LaunchJobResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    body: LaunchJobRequest,
+    x_api_key: str | None = None,
+) -> LaunchJobResponse:
+    """Launch a new Chronos job."""
+
+    request_args = _build_request_args(
+        body=body,
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return LaunchJobResponse.model_validate(response.json())

plato/chronos/api/registry/__init__.py

@@ -0,0 +1,19 @@
+"""API endpoints."""
+
+from . import (
+    get_agent_schema_api_registry_agents__agent_name__schema_get,
+    get_agent_versions_api_registry_agents__agent_name__versions_get,
+    get_world_schema_api_registry_worlds__package_name__schema_get,
+    get_world_versions_api_registry_worlds__package_name__versions_get,
+    list_registry_agents_api_registry_agents_get,
+    list_registry_worlds_api_registry_worlds_get,
+)
+
+__all__ = [
+    "list_registry_agents_api_registry_agents_get",
+    "get_agent_versions_api_registry_agents__agent_name__versions_get",
+    "get_agent_schema_api_registry_agents__agent_name__schema_get",
+    "list_registry_worlds_api_registry_worlds_get",
+    "get_world_versions_api_registry_worlds__package_name__versions_get",
+    "get_world_schema_api_registry_worlds__package_name__schema_get",
+]

plato/chronos/api/registry/get_agent_schema_api_registry_agents__agent_name__schema_get.py

@@ -0,0 +1,62 @@
+"""Get Agent Schema"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import AgentSchemaResponse
+
+
+def _build_request_args(
+    agent_name: str,
+    version: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = f"/api/registry/agents/{agent_name}/schema"
+
+    params: dict[str, Any] = {}
+    if version is not None:
+        params["version"] = version
+
+    return {
+        "method": "GET",
+        "url": url,
+        "params": params,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    agent_name: str,
+    version: str | None = None,
+) -> AgentSchemaResponse:
+    """Get schema for an agent version from the registry."""
+
+    request_args = _build_request_args(
+        agent_name=agent_name,
+        version=version,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return AgentSchemaResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    agent_name: str,
+    version: str | None = None,
+) -> AgentSchemaResponse:
+    """Get schema for an agent version from the registry."""
+
+    request_args = _build_request_args(
+        agent_name=agent_name,
+        version=version,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return AgentSchemaResponse.model_validate(response.json())

plato/chronos/api/registry/get_agent_versions_api_registry_agents__agent_name__versions_get.py

@@ -0,0 +1,52 @@
+"""Get Agent Versions"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import AgentVersionsResponse
+
+
+def _build_request_args(
+    agent_name: str,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = f"/api/registry/agents/{agent_name}/versions"
+
+    return {
+        "method": "GET",
+        "url": url,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    agent_name: str,
+) -> AgentVersionsResponse:
+    """Get versions for an agent from the registry."""
+
+    request_args = _build_request_args(
+        agent_name=agent_name,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return AgentVersionsResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    agent_name: str,
+) -> AgentVersionsResponse:
+    """Get versions for an agent from the registry."""
+
+    request_args = _build_request_args(
+        agent_name=agent_name,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return AgentVersionsResponse.model_validate(response.json())

plato/chronos/api/registry/get_world_schema_api_registry_worlds__package_name__schema_get.py

@@ -0,0 +1,68 @@
+"""Get World Schema"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import WorldSchemaResponse
+
+
+def _build_request_args(
+    package_name: str,
+    version: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = f"/api/registry/worlds/{package_name}/schema"
+
+    params: dict[str, Any] = {}
+    if version is not None:
+        params["version"] = version
+
+    return {
+        "method": "GET",
+        "url": url,
+        "params": params,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    package_name: str,
+    version: str | None = None,
+) -> WorldSchemaResponse:
+    """Get schema for a world package from the registry.
+
+    First tries the registry's schema endpoint, then falls back to
+    extracting schema.json directly from the wheel."""
+
+    request_args = _build_request_args(
+        package_name=package_name,
+        version=version,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return WorldSchemaResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    package_name: str,
+    version: str | None = None,
+) -> WorldSchemaResponse:
+    """Get schema for a world package from the registry.
+
+    First tries the registry's schema endpoint, then falls back to
+    extracting schema.json directly from the wheel."""
+
+    request_args = _build_request_args(
+        package_name=package_name,
+        version=version,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return WorldSchemaResponse.model_validate(response.json())

plato/chronos/api/registry/get_world_versions_api_registry_worlds__package_name__versions_get.py

@@ -0,0 +1,52 @@
+"""Get World Versions"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import WorldVersionsResponse
+
+
+def _build_request_args(
+    package_name: str,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = f"/api/registry/worlds/{package_name}/versions"
+
+    return {
+        "method": "GET",
+        "url": url,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    package_name: str,
+) -> WorldVersionsResponse:
+    """Get versions for a world package from the registry."""
+
+    request_args = _build_request_args(
+        package_name=package_name,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return WorldVersionsResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    package_name: str,
+) -> WorldVersionsResponse:
+    """Get versions for a world package from the registry."""
+
+    request_args = _build_request_args(
+        package_name=package_name,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return WorldVersionsResponse.model_validate(response.json())

plato/chronos/api/registry/list_registry_agents_api_registry_agents_get.py

@@ -0,0 +1,44 @@
+"""List Registry Agents"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import ChronosApiRegistryAgentListResponse
+
+
+def _build_request_args() -> dict[str, Any]:
+    """Build request arguments."""
+    url = "/api/registry/agents"
+
+    return {
+        "method": "GET",
+        "url": url,
+    }
+
+
+def sync(
+    client: httpx.Client,
+) -> ChronosApiRegistryAgentListResponse:
+    """List all agents from the registry with their ECR image URIs."""
+
+    request_args = _build_request_args()
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return ChronosApiRegistryAgentListResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+) -> ChronosApiRegistryAgentListResponse:
+    """List all agents from the registry with their ECR image URIs."""
+
+    request_args = _build_request_args()
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return ChronosApiRegistryAgentListResponse.model_validate(response.json())

plato/chronos/api/registry/list_registry_worlds_api_registry_worlds_get.py

@@ -0,0 +1,44 @@
+"""List Registry Worlds"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import WorldCatalogResponse
+
+
+def _build_request_args() -> dict[str, Any]:
+    """Build request arguments."""
+    url = "/api/registry/worlds"
+
+    return {
+        "method": "GET",
+        "url": url,
+    }
+
+
+def sync(
+    client: httpx.Client,
+) -> WorldCatalogResponse:
+    """List all world packages from the registry."""
+
+    request_args = _build_request_args()
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return WorldCatalogResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+) -> WorldCatalogResponse:
+    """List all world packages from the registry."""
+
+    request_args = _build_request_args()
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return WorldCatalogResponse.model_validate(response.json())

plato/chronos/api/runtimes/__init__.py

@@ -0,0 +1,11 @@
+"""API endpoints."""
+
+from . import create_runtime, delete_runtime, get_runtime, list_runtimes, test_runtime
+
+__all__ = [
+    "list_runtimes",
+    "create_runtime",
+    "get_runtime",
+    "delete_runtime",
+    "test_runtime",
+]

plato/chronos/api/runtimes/create_runtime.py

@@ -0,0 +1,63 @@
+"""Create Runtime"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import RuntimeCreate, RuntimeCreateResponse
+
+
+def _build_request_args(
+    body: RuntimeCreate,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = "/api/runtimes"
+
+    headers: dict[str, str] = {}
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "POST",
+        "url": url,
+        "json": body.model_dump(mode="json", exclude_none=True),
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    body: RuntimeCreate,
+    x_api_key: str | None = None,
+) -> RuntimeCreateResponse:
+    """Create a new runtime (starts background job to build)."""
+
+    request_args = _build_request_args(
+        body=body,
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return RuntimeCreateResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    body: RuntimeCreate,
+    x_api_key: str | None = None,
+) -> RuntimeCreateResponse:
+    """Create a new runtime (starts background job to build)."""
+
+    request_args = _build_request_args(
+        body=body,
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return RuntimeCreateResponse.model_validate(response.json())

plato/chronos/api/runtimes/delete_runtime.py

@@ -0,0 +1,61 @@
+"""Delete Runtime"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+
+
+def _build_request_args(
+    artifact_id: str,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = f"/api/runtimes/{artifact_id}"
+
+    headers: dict[str, str] = {}
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "DELETE",
+        "url": url,
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    artifact_id: str,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Delete a runtime."""
+
+    request_args = _build_request_args(
+        artifact_id=artifact_id,
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return response.json()
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    artifact_id: str,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Delete a runtime."""
+
+    request_args = _build_request_args(
+        artifact_id=artifact_id,
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return response.json()

plato/chronos/api/runtimes/get_runtime.py

@@ -0,0 +1,62 @@
+"""Get Runtime"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import RuntimeResponse
+
+
+def _build_request_args(
+    artifact_id: str,
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = f"/api/runtimes/{artifact_id}"
+
+    headers: dict[str, str] = {}
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "GET",
+        "url": url,
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    artifact_id: str,
+    x_api_key: str | None = None,
+) -> RuntimeResponse:
+    """Get a runtime by artifact ID."""
+
+    request_args = _build_request_args(
+        artifact_id=artifact_id,
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return RuntimeResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    artifact_id: str,
+    x_api_key: str | None = None,
+) -> RuntimeResponse:
+    """Get a runtime by artifact ID."""
+
+    request_args = _build_request_args(
+        artifact_id=artifact_id,
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return RuntimeResponse.model_validate(response.json())

plato/chronos/api/runtimes/list_runtimes.py

@@ -0,0 +1,57 @@
+"""List Runtimes"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from plato.chronos.errors import raise_for_status
+from plato.chronos.models import RuntimeListResponse
+
+
+def _build_request_args(
+    x_api_key: str | None = None,
+) -> dict[str, Any]:
+    """Build request arguments."""
+    url = "/api/runtimes"
+
+    headers: dict[str, str] = {}
+    if x_api_key is not None:
+        headers["X-API-Key"] = x_api_key
+
+    return {
+        "method": "GET",
+        "url": url,
+        "headers": headers,
+    }
+
+
+def sync(
+    client: httpx.Client,
+    x_api_key: str | None = None,
+) -> RuntimeListResponse:
+    """List all runtimes for the org."""
+
+    request_args = _build_request_args(
+        x_api_key=x_api_key,
+    )
+
+    response = client.request(**request_args)
+    raise_for_status(response)
+    return RuntimeListResponse.model_validate(response.json())
+
+
+async def asyncio(
+    client: httpx.AsyncClient,
+    x_api_key: str | None = None,
+) -> RuntimeListResponse:
+    """List all runtimes for the org."""
+
+    request_args = _build_request_args(
+        x_api_key=x_api_key,
+    )
+
+    response = await client.request(**request_args)
+    raise_for_status(response)
+    return RuntimeListResponse.model_validate(response.json())