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

plato/_generated/api/v2/interfaces/v2_interface_close.py

@@ -1,59 +0,0 @@
-"""Close Interface"""
-
-from __future__ import annotations
-
-from typing import Any
-
-import httpx
-
-
-def sync(
-    client: httpx.Client,
-    job_id: str,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> dict[str, Any]:
-    """Close an interface."""
-
-    url = f"/api/v2/interface/{job_id}/close"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = client.request(
-        "POST",
-        url,
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return response.json()
-
-
-async def asyncio(
-    client: httpx.AsyncClient,
-    job_id: str,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> dict[str, Any]:
-    """Close an interface."""
-
-    url = f"/api/v2/interface/{job_id}/close"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = await client.request(
-        "POST",
-        url,
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return response.json()

plato/_generated/api/v2/interfaces/v2_interface_computer_create.py

@@ -1,68 +0,0 @@
-"""Create Computer Interface"""
-
-from __future__ import annotations
-
-import httpx
-
-from plato._generated.models.computer_interface_option import ComputerInterfaceOption
-from plato._generated.models.interface_info import InterfaceInfo
-
-
-def sync(
-    client: httpx.Client,
-    body: ComputerInterfaceOption,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> InterfaceInfo:
-    """Create a computer interface.
-
-    Computer interfaces provide click, type, screenshot, and keyboard/mouse
-    control for computer-use scenarios."""
-
-    url = "/api/v2/interface/computer/create"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return InterfaceInfo.from_dict(response.json())
-
-
-async def asyncio(
-    client: httpx.AsyncClient,
-    body: ComputerInterfaceOption,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> InterfaceInfo:
-    """Create a computer interface.
-
-    Computer interfaces provide click, type, screenshot, and keyboard/mouse
-    control for computer-use scenarios."""
-
-    url = "/api/v2/interface/computer/create"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = await client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return InterfaceInfo.from_dict(response.json())

plato/_generated/api/v2/interfaces/v2_interface_cursor.py

@@ -1,64 +0,0 @@
-"""Interface Cursor"""
-
-from __future__ import annotations
-
-import httpx
-
-from plato._generated.models.cursor_position_request import CursorPositionRequest
-from plato._generated.models.cursor_position_response import CursorPositionResponse
-
-
-def sync(
-    client: httpx.Client,
-    job_id: str,
-    body: CursorPositionRequest,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> CursorPositionResponse:
-    """Move the cursor to a position without clicking."""
-
-    url = f"/api/v2/interface/{job_id}/cursor"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return CursorPositionResponse.from_dict(response.json())
-
-
-async def asyncio(
-    client: httpx.AsyncClient,
-    job_id: str,
-    body: CursorPositionRequest,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> CursorPositionResponse:
-    """Move the cursor to a position without clicking."""
-
-    url = f"/api/v2/interface/{job_id}/cursor"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = await client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return CursorPositionResponse.from_dict(response.json())

plato/_generated/api/v2/interfaces/v2_interface_key.py

@@ -1,68 +0,0 @@
-"""Interface Key"""
-
-from __future__ import annotations
-
-import httpx
-
-from plato._generated.models.key_request import KeyRequest
-from plato._generated.models.key_response import KeyResponse
-
-
-def sync(
-    client: httpx.Client,
-    job_id: str,
-    body: KeyRequest,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> KeyResponse:
-    """Press a key or key combination.
-
-    Examples: 'Enter', 'Tab', 'ctrl+c', 'alt+tab', 'shift+a'"""
-
-    url = f"/api/v2/interface/{job_id}/key"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return KeyResponse.from_dict(response.json())
-
-
-async def asyncio(
-    client: httpx.AsyncClient,
-    job_id: str,
-    body: KeyRequest,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> KeyResponse:
-    """Press a key or key combination.
-
-    Examples: 'Enter', 'Tab', 'ctrl+c', 'alt+tab', 'shift+a'"""
-
-    url = f"/api/v2/interface/{job_id}/key"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = await client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return KeyResponse.from_dict(response.json())

plato/_generated/api/v2/interfaces/v2_interface_screenshot.py

@@ -1,65 +0,0 @@
-"""Interface Screenshot"""
-
-from __future__ import annotations
-
-import httpx
-
-from plato._generated.models.screenshot_response import ScreenshotResponse
-
-
-def sync(
-    client: httpx.Client,
-    job_id: str,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> ScreenshotResponse:
-    """Take a screenshot of the interface.
-
-    Available for both browser and computer interfaces.
-    Returns base64 encoded PNG image."""
-
-    url = f"/api/v2/interface/{job_id}/screenshot"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = client.request(
-        "GET",
-        url,
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return ScreenshotResponse.from_dict(response.json())
-
-
-async def asyncio(
-    client: httpx.AsyncClient,
-    job_id: str,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> ScreenshotResponse:
-    """Take a screenshot of the interface.
-
-    Available for both browser and computer interfaces.
-    Returns base64 encoded PNG image."""
-
-    url = f"/api/v2/interface/{job_id}/screenshot"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = await client.request(
-        "GET",
-        url,
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return ScreenshotResponse.from_dict(response.json())

plato/_generated/api/v2/interfaces/v2_interface_scroll.py

@@ -1,70 +0,0 @@
-"""Interface Scroll"""
-
-from __future__ import annotations
-
-import httpx
-
-from plato._generated.models.scroll_request import ScrollRequest
-from plato._generated.models.scroll_response import ScrollResponse
-
-
-def sync(
-    client: httpx.Client,
-    job_id: str,
-    body: ScrollRequest,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> ScrollResponse:
-    """Scroll the interface.
-
-    Positive y scrolls down, negative y scrolls up.
-    Positive x scrolls right, negative x scrolls left."""
-
-    url = f"/api/v2/interface/{job_id}/scroll"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return ScrollResponse.from_dict(response.json())
-
-
-async def asyncio(
-    client: httpx.AsyncClient,
-    job_id: str,
-    body: ScrollRequest,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> ScrollResponse:
-    """Scroll the interface.
-
-    Positive y scrolls down, negative y scrolls up.
-    Positive x scrolls right, negative x scrolls left."""
-
-    url = f"/api/v2/interface/{job_id}/scroll"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = await client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return ScrollResponse.from_dict(response.json())

plato/_generated/api/v2/interfaces/v2_interface_type.py

@@ -1,64 +0,0 @@
-"""Interface Type"""
-
-from __future__ import annotations
-
-import httpx
-
-from plato._generated.models.type_request import TypeRequest
-from plato._generated.models.type_response import TypeResponse
-
-
-def sync(
-    client: httpx.Client,
-    job_id: str,
-    body: TypeRequest,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> TypeResponse:
-    """Type text on the interface."""
-
-    url = f"/api/v2/interface/{job_id}/type"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return TypeResponse.from_dict(response.json())
-
-
-async def asyncio(
-    client: httpx.AsyncClient,
-    job_id: str,
-    body: TypeRequest,
-    authorization: str | None = None,
-    x_internal_service: str | None = None,
-) -> TypeResponse:
-    """Type text on the interface."""
-
-    url = f"/api/v2/interface/{job_id}/type"
-
-    headers: dict[str, str] = {}
-    if authorization is not None:
-        headers["authorization"] = authorization
-    if x_internal_service is not None:
-        headers["X-Internal-Service"] = x_internal_service
-
-    response = await client.request(
-        "POST",
-        url,
-        json=body.to_dict(),
-        headers=headers,
-    )
-    response.raise_for_status()
-
-    return TypeResponse.from_dict(response.json())

plato/world/__init__.py

@@ -1,44 +0,0 @@
-"""World module - OpenAI Gym-like interface for Plato simulators.
-
-Provides an abstract World base class that manages Plato sessions and
-exposes simulator URLs for agents to interact with via plato.sims SDK.
-
-Usage:
-    from plato.world import World, WorldConfig, EnvSpec, Observation, StepResult
-
-    class MyWorld(World):
-        async def _on_reset(self) -> Observation:
-            return Observation(step=0, date=self.config.start_date, data={})
-
-        async def _on_step(self) -> StepResult:
-            return StepResult(observation=obs, reward=100.0)
-
-        def get_prompt(self) -> str:
-            return f"Day {self._current_step}: Do something..."
-
-    config = WorldConfig(
-        name="my-world",
-        envs=[EnvSpec(alias="store", simulator="spree")],
-        num_steps=30,
-    )
-
-    async with MyWorld(config) as world:
-        obs = await world.reset()
-        for _ in range(config.num_steps):
-            # Agent takes turn using world.get_env_vars()
-            result = await world.step()
-            if result.done:
-                break
-"""
-
-from plato.world.base import World
-from plato.world.config import EnvSpec, WorldConfig
-from plato.world.types import Observation, StepResult
-
-__all__ = [
-    "World",
-    "WorldConfig",
-    "EnvSpec",
-    "Observation",
-    "StepResult",
-]