fleet-python 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

fleet/_async/instance/client.py

@@ -0,0 +1,278 @@
+"""Fleet SDK Async Instance Client."""
+
+from typing import Any, Callable, Dict, List, Optional, Tuple
+import asyncio
+import httpx
+import inspect
+import time
+import logging
+from urllib.parse import urlparse
+
+from ..resources.sqlite import AsyncSQLiteResource
+from ..resources.browser import AsyncBrowserResource
+from ..resources.base import Resource
+
+from ...verifiers import DatabaseSnapshot
+
+from ..exceptions import FleetEnvironmentError, FleetAPIError
+
+from .base import AsyncWrapper
+from .models import (
+    ResetRequest,
+    ResetResponse,
+    Resource as ResourceModel,
+    ResourceType,
+    HealthResponse,
+    ExecuteFunctionRequest,
+    ExecuteFunctionResponse,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+RESOURCE_TYPES = {
+    ResourceType.db: AsyncSQLiteResource,
+    ResourceType.cdp: AsyncBrowserResource,
+}
+
+ValidatorType = Callable[
+    [DatabaseSnapshot, DatabaseSnapshot, Optional[str]],
+    int,
+]
+
+
+class AsyncInstanceClient:
+    def __init__(
+        self,
+        url: str,
+        httpx_client: Optional[httpx.AsyncClient] = None,
+    ):
+        self.base_url = url
+        self.client = AsyncWrapper(
+            url=self.base_url,
+            httpx_client=httpx_client or httpx.AsyncClient(timeout=60.0),
+        )
+        self._resources: Optional[List[ResourceModel]] = None
+        self._resources_state: Dict[str, Dict[str, Resource]] = {
+            resource_type.value: {} for resource_type in ResourceType
+        }
+
+    async def load(self) -> None:
+        await self._load_resources()
+
+    async def reset(
+        self, reset_request: Optional[ResetRequest] = None
+    ) -> ResetResponse:
+        response = await self.client.request(
+            "POST", "/reset", json=reset_request.model_dump() if reset_request else None
+        )
+        return ResetResponse(**response.json())
+
+    def state(self, uri: str) -> Resource:
+        url = urlparse(uri)
+        return self._resources_state[url.scheme][url.netloc]
+
+    def db(self, name: str) -> AsyncSQLiteResource:
+        """
+        Returns an AsyncSQLiteResource object for the given SQLite database name.
+
+        Args:
+            name: The name of the SQLite database to return
+
+        Returns:
+            An AsyncSQLiteResource object for the given SQLite database name
+        """
+        return AsyncSQLiteResource(
+            self._resources_state[ResourceType.db.value][name], self.client
+        )
+
+    def browser(self, name: str) -> AsyncBrowserResource:
+        return AsyncBrowserResource(
+            self._resources_state[ResourceType.cdp.value][name], self.client
+        )
+
+    async def resources(self) -> List[Resource]:
+        await self._load_resources()
+        return [
+            resource
+            for resources_by_name in self._resources_state.values()
+            for resource in resources_by_name.values()
+        ]
+
+    async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
+        function_code = inspect.getsource(validator)
+        function_name = validator.__name__
+        return await self.verify_raw(function_code, function_name)
+
+    async def verify_raw(
+        self, function_code: str, function_name: str
+    ) -> ExecuteFunctionResponse:
+        response = await self.client.request(
+            "POST",
+            "/execute_verifier_function",
+            json=ExecuteFunctionRequest(
+                function_code=function_code,
+                function_name=function_name,
+            ).model_dump(),
+        )
+        return ExecuteFunctionResponse(**response.json())
+
+    async def _load_resources(self) -> None:
+        if self._resources is None:
+            response = await self.client.request("GET", "/resources")
+            if response.status_code != 200:
+                self._resources = []
+                return
+
+            # Handle both old and new response formats
+            response_data = response.json()
+            if isinstance(response_data, dict) and "resources" in response_data:
+                # Old format: {"resources": [...]}
+                resources_list = response_data["resources"]
+            else:
+                # New format: [...]
+                resources_list = response_data
+
+            self._resources = [ResourceModel(**resource) for resource in resources_list]
+            for resource in self._resources:
+                if resource.type not in self._resources_state:
+                    self._resources_state[resource.type.value] = {}
+                self._resources_state[resource.type.value][resource.name] = (
+                    RESOURCE_TYPES[resource.type](resource, self.client)
+                )
+
+    async def step(self, action: Dict[str, Any]) -> Tuple[Dict[str, Any], float, bool]:
+        """Execute one step in the environment."""
+        if not self._instance_id:
+            raise FleetEnvironmentError(
+                "Environment not initialized. Call reset() first."
+            )
+
+        try:
+            # Increment step count
+            self._increment_step()
+
+            # Execute action through instance manager API
+            # This is a placeholder - actual implementation depends on the manager API spec
+            state, reward, done = await self._execute_action(action)
+
+            return state, reward, done
+
+        except Exception as e:
+            raise FleetEnvironmentError(f"Failed to execute step: {e}")
+
+    async def close(self) -> None:
+        """Close the environment and clean up resources."""
+        try:
+            # Delete instance if it exists
+            if self._instance_id:
+                try:
+                    await self._client.delete_instance(self._instance_id)
+                    logger.info(f"Deleted instance: {self._instance_id}")
+                except FleetAPIError as e:
+                    logger.warning(f"Failed to delete instance: {e}")
+                finally:
+                    self._instance_id = None
+                    self._instance_response = None
+
+            # Close manager client
+            if self._manager_client:
+                await self._manager_client.close()
+                self._manager_client = None
+
+            # Close API client
+            await self._client.close()
+
+        except Exception as e:
+            logger.error(f"Error closing environment: {e}")
+
+    async def manager_health_check(self) -> Optional[HealthResponse]:
+        response = await self.client.request("GET", "/health")
+        return HealthResponse(**response.json())
+
+    async def _wait_for_instance_ready(self, timeout: float = 300.0) -> None:
+        """Wait for instance to be ready.
+
+        Args:
+            timeout: Maximum time to wait in seconds
+        """
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            try:
+                instance = await self._client.get_instance(self._instance_id)
+                self._instance_response = instance
+
+                if instance.status == "running":
+                    logger.info(f"Instance {self._instance_id} is ready")
+                    return
+
+                elif instance.status == "error":
+                    raise FleetEnvironmentError(
+                        f"Instance {self._instance_id} failed to start"
+                    )
+
+                # Wait before checking again
+                await asyncio.sleep(5)
+
+            except FleetAPIError as e:
+                if time.time() - start_time >= timeout:
+                    raise FleetEnvironmentError(
+                        f"Timeout waiting for instance to be ready: {e}"
+                    )
+                await asyncio.sleep(5)
+
+        raise FleetEnvironmentError(
+            f"Timeout waiting for instance {self._instance_id} to be ready"
+        )
+
+    async def _execute_action(
+        self, action: Dict[str, Any]
+    ) -> Tuple[Dict[str, Any], float, bool]:
+        """Execute an action through the instance manager API.
+
+        This is a placeholder implementation that should be extended based on
+        the actual manager API specification.
+
+        Args:
+            action: The action to execute as a dictionary
+
+        Returns:
+            Tuple of (state, reward, done)
+        """
+        # Ensure manager client is available
+        await self._ensure_manager_client()
+
+        # TODO: In the future, this would use the manager API to execute actions
+        # For example: await self._manager_client.log_action(action)
+        # For now, return placeholder values
+
+        # Create a placeholder state
+        state = self._create_state_from_action(action)
+
+        # Create a placeholder reward
+        reward = 0.0
+
+        # Determine if episode is done (placeholder logic)
+        done = self._step_count >= 100  # Example: done after 100 steps
+
+        return state, reward, done
+
+    def _create_state_from_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
+        """Create state based on executed action."""
+        return {
+            "instance_id": self._instance_id,
+            "step": self._step_count,
+            "last_action": action,
+            "timestamp": time.time(),
+            "status": "running",
+        }
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()

fleet/_async/instance/models.py

@@ -0,0 +1,141 @@
+# generated by datamodel-codegen:
+#   filename:  openapi (2).json
+#   timestamp: 2025-07-09T20:11:31+00:00
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class CDPDescribeResponse(BaseModel):
+    success: bool = Field(..., title="Success")
+    cdp_page_url: str = Field(..., title="Url")
+    cdp_browser_url: str = Field(..., title="Browser Url")
+    cdp_devtools_url: str = Field(..., title="Devtools Url")
+
+
+class ChromeStartRequest(BaseModel):
+    resolution: Optional[str] = Field("1920x1080", title="Resolution")
+
+
+class ChromeStartResponse(BaseModel):
+    success: bool = Field(..., title="Success")
+    message: str = Field(..., title="Message")
+
+
+class ChromeStatusResponse(BaseModel):
+    running: bool = Field(..., title="Running")
+    message: str = Field(..., title="Message")
+
+
+class CreateSnapshotsResponse(BaseModel):
+    success: bool = Field(..., title="Success")
+    initial_snapshot_path: Optional[str] = Field(None, title="Initial Snapshot Path")
+    final_snapshot_path: Optional[str] = Field(None, title="Final Snapshot Path")
+    message: str = Field(..., title="Message")
+
+
+class HealthResponse(BaseModel):
+    status: str = Field(..., title="Status")
+    timestamp: str = Field(..., title="Timestamp")
+    service: str = Field(..., title="Service")
+
+
+class LogActionRequest(BaseModel):
+    action_type: str = Field(..., title="Action Type")
+    sql: Optional[str] = Field(None, title="Sql")
+    args: Optional[str] = Field(None, title="Args")
+    path: Optional[str] = Field(None, title="Path")
+    raw_payload: Optional[str] = Field(None, title="Raw Payload")
+
+
+class LogActionResponse(BaseModel):
+    success: bool = Field(..., title="Success")
+    message: str = Field(..., title="Message")
+
+
+class QueryRequest(BaseModel):
+    query: str = Field(..., title="Query")
+    args: Optional[List] = Field(None, title="Args")
+    read_only: Optional[bool] = Field(True, title="Read Only")
+
+
+class QueryResponse(BaseModel):
+    success: bool = Field(..., title="Success")
+    columns: Optional[List[str]] = Field(None, title="Columns")
+    rows: Optional[List[List]] = Field(None, title="Rows")
+    rows_affected: Optional[int] = Field(None, title="Rows Affected")
+    last_insert_id: Optional[int] = Field(None, title="Last Insert Id")
+    error: Optional[str] = Field(None, title="Error")
+    message: str = Field(..., title="Message")
+
+
+class ResetRequest(BaseModel):
+    timestamp: Optional[int] = Field(None, title="Timestamp")
+    seed: Optional[int] = Field(None, title="Seed")
+
+
+class ResetResponse(BaseModel):
+    success: bool = Field(..., title="Success")
+    message: str = Field(..., title="Message")
+
+
+class ResourceMode(Enum):
+    ro = "ro"
+    rw = "rw"
+
+
+class ResourceType(Enum):
+    db = "sqlite"
+    cdp = "cdp"
+
+
+class TableSchema(BaseModel):
+    name: str = Field(..., title="Name")
+    sql: str = Field(..., title="Sql")
+    columns: List[Dict[str, Any]] = Field(..., title="Columns")
+
+
+class TimestampResponse(BaseModel):
+    timestamp: str = Field(..., title="Timestamp")
+
+
+class ValidationError(BaseModel):
+    loc: List[Union[str, int]] = Field(..., title="Location")
+    msg: str = Field(..., title="Message")
+    type: str = Field(..., title="Error Type")
+
+
+class DescribeResponse(BaseModel):
+    success: bool = Field(..., title="Success")
+    resource_name: str = Field(..., title="Resource Name")
+    tables: Optional[List[TableSchema]] = Field(None, title="Tables")
+    error: Optional[str] = Field(None, title="Error")
+    message: str = Field(..., title="Message")
+
+
+class HTTPValidationError(BaseModel):
+    detail: Optional[List[ValidationError]] = Field(None, title="Detail")
+
+
+class Resource(BaseModel):
+    name: str = Field(..., title="Name")
+    type: ResourceType
+    mode: ResourceMode
+    label: Optional[str] = Field(None, title="Label")
+
+
+class ExecuteFunctionRequest(BaseModel):
+    function_code: str
+    function_name: str
+    text_solution: Optional[str] = None
+
+
+class ExecuteFunctionResponse(BaseModel):
+    success: bool
+    result: Optional[Any] = None
+    error: Optional[str] = None
+    message: str

fleet/_async/models.py

@@ -0,0 +1,109 @@
+# generated by datamodel-codegen:
+#   filename:  openapi.json
+#   timestamp: 2025-07-08T18:21:47+00:00
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field
+
+
+class Environment(BaseModel):
+    env_key: str = Field(..., title="Env Key")
+    name: str = Field(..., title="Name")
+    description: Optional[str] = Field(..., title="Description")
+    default_version: Optional[str] = Field(..., title="Default Version")
+    versions: Dict[str, str] = Field(..., title="Versions")
+
+
+class Instance(BaseModel):
+    instance_id: str = Field(..., title="Instance Id")
+    env_key: str = Field(..., title="Env Key")
+    version: str = Field(..., title="Version")
+    status: str = Field(..., title="Status")
+    subdomain: str = Field(..., title="Subdomain")
+    created_at: str = Field(..., title="Created At")
+    updated_at: str = Field(..., title="Updated At")
+    terminated_at: Optional[str] = Field(None, title="Terminated At")
+    team_id: str = Field(..., title="Team Id")
+    region: str = Field(..., title="Region")
+
+
+class InstanceRequest(BaseModel):
+    env_key: str = Field(..., title="Env Key")
+    version: Optional[str] = Field(None, title="Version")
+    region: Optional[str] = Field("us-east-2", title="Region")
+    seed: Optional[int] = Field(None, title="Seed")
+    timestamp: Optional[int] = Field(None, title="Timestamp")
+    p_error: Optional[float] = Field(None, title="P Error")
+    avg_latency: Optional[float] = Field(None, title="Avg Latency")
+    run_id: Optional[str] = Field(None, title="Run Id")
+    task_id: Optional[str] = Field(None, title="Task Id")
+
+
+class InstanceStatus(Enum):
+    pending = "pending"
+    running = "running"
+    stopped = "stopped"
+    error = "error"
+
+
+class ManagerURLs(BaseModel):
+    api: str = Field(..., title="Api")
+    docs: str = Field(..., title="Docs")
+    reset: str = Field(..., title="Reset")
+    diff: str = Field(..., title="Diff")
+    snapshot: str = Field(..., title="Snapshot")
+    execute_verifier_function: str = Field(..., title="Execute Verifier Function")
+    execute_verifier_function_with_upload: str = Field(
+        ..., title="Execute Verifier Function With Upload"
+    )
+
+
+class ValidationError(BaseModel):
+    loc: List[Union[str, int]] = Field(..., title="Location")
+    msg: str = Field(..., title="Message")
+    type: str = Field(..., title="Error Type")
+
+
+class HTTPValidationError(BaseModel):
+    detail: Optional[List[ValidationError]] = Field(None, title="Detail")
+
+
+class InstanceURLs(BaseModel):
+    root: str = Field(..., title="Root")
+    app: str = Field(..., title="App")
+    api: Optional[str] = Field(None, title="Api")
+    health: Optional[str] = Field(None, title="Health")
+    api_docs: Optional[str] = Field(None, title="Api Docs")
+    manager: ManagerURLs
+
+
+class InstanceResponse(BaseModel):
+    instance_id: str = Field(..., title="Instance Id")
+    env_key: str = Field(..., title="Env Key")
+    version: str = Field(..., title="Version")
+    status: str = Field(..., title="Status")
+    subdomain: str = Field(..., title="Subdomain")
+    created_at: str = Field(..., title="Created At")
+    updated_at: str = Field(..., title="Updated At")
+    terminated_at: Optional[str] = Field(None, title="Terminated At")
+    team_id: str = Field(..., title="Team Id")
+    region: str = Field(..., title="Region")
+    urls: InstanceURLs
+    health: Optional[bool] = Field(None, title="Health")
+
+
+class InstanceRecord(BaseModel):
+    instance_id: str
+    env_key: str
+    version: str
+    status: str
+    subdomain: str
+    created_at: str
+    updated_at: str
+    terminated_at: Optional[str] = None
+    team_id: str
+    region: str