fleet-python 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

examples/browser_control_example.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Example demonstrating browser control with Fleet Manager Client."""
+
+import asyncio
+import fleet as flt
+
+
+async def main():
+    fleet = flt.AsyncFleet()
+
+    environments = await fleet.list_envs()
+    print("Environments:", len(environments))
+
+    instances = await fleet.instances(status="running")
+    print("Instances:", len(instances))
+
+    instance = await fleet.instance("16fdbc96")
+    print("Instance:", instance.instance_id)
+    print("Instance Environment:", instance.env_key)
+
+    environment = await fleet.environment(instance.env_key)
+    print("Environment Default Version:", environment.default_version)
+
+    response = await instance.env.reset()
+    print("Reset response:", response)
+
+    print(await instance.env.resources())
+
+    sqlite = instance.env.sqlite("current")
+    print("SQLite:", await sqlite.describe())
+
+    print("Query:", await sqlite.query("SELECT * FROM users"))
+
+    sqlite = await instance.env.state("sqlite://current").describe()
+    print("SQLite:", sqlite)
+
+    browser = await instance.env.browser("cdp").describe()
+    print("CDP URL:", browser.url)
+    print("CDP Devtools URL:", browser.devtools_url)
+
+    # Create a new instance
+    instance = await fleet.make(flt.InstanceRequest(env_key=instance.env_key))
+    print("New Instance:", instance.instance_id)
+
+    # Delete the instance
+    instance = await fleet.delete(instance.instance_id)
+    print("Instance deleted:", instance.terminated_at)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fleet/__init__.py

@@ -14,29 +14,17 @@
 
 """Fleet Python SDK - Environment-based AI agent interactions."""
 
-from . import env
 from .exceptions import FleetError, FleetAPIError, FleetTimeoutError, FleetConfigurationError
-from .config import get_config, FleetConfig
-from .client import FleetAPIClient, InstanceRequest, InstanceResponse, EnvDetails as APIEnvironment, HealthResponse, ManagerURLs, InstanceURLs
-from .manager_client import FleetManagerClient, ManagerHealthResponse, TimestampResponse
+from .client import Fleet, AsyncFleet, InstanceRequest
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 __all__ = [
     "env",
     "FleetError",
     "FleetAPIError", 
     "FleetTimeoutError",
     "FleetConfigurationError",
-    "get_config",
-    "FleetConfig",
-    "FleetAPIClient",
+    "Fleet",
+    "AsyncFleet",
     "InstanceRequest",
-    "InstanceResponse",
-    "APIEnvironment",
-    "HealthResponse",
-    "ManagerURLs",
-    "InstanceURLs",
-    "FleetManagerClient",
-    "ManagerHealthResponse",
-    "TimestampResponse",
 ] 

fleet/base.py

@@ -0,0 +1,74 @@
+import httpx
+from typing import Dict, Any, Optional
+
+from .models import InstanceResponse
+
+
+class InstanceBase(InstanceResponse):
+    @property
+    def manager_url(self) -> str:
+        return f"{self.urls.manager.api}"
+
+
+class BaseWrapper:
+    def __init__(self, *, api_key: Optional[str], base_url: Optional[str]):
+        if api_key is None:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        if base_url is None:
+            base_url = "https://fleet.new"
+        self.base_url = base_url
+
+    def get_headers(self) -> Dict[str, str]:
+        headers: Dict[str, str] = {
+            "X-Fleet-SDK-Language": "Python",
+            "X-Fleet-SDK-Version": "1.0.0",
+        }
+        headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+
+class SyncWrapper(BaseWrapper):
+    def __init__(self, *, httpx_client: httpx.Client, **kwargs):
+        super().__init__(**kwargs)
+        self.httpx_client = httpx_client
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        return self.httpx_client.request(
+            method,
+            f"{self.base_url}{url}",
+            headers=self.get_headers(),
+            params=params,
+            json=json,
+            **kwargs,
+        )
+
+
+class AsyncWrapper(BaseWrapper):
+    def __init__(self, *, httpx_client: httpx.AsyncClient, **kwargs):
+        super().__init__(**kwargs)
+        self.httpx_client = httpx_client
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        return await self.httpx_client.request(
+            method,
+            f"{self.base_url}{url}",
+            headers=self.get_headers(),
+            params=params,
+            json=json,
+            **kwargs,
+        )

fleet/client.py

@@ -15,304 +15,140 @@
 """Fleet API Client for making HTTP requests to Fleet services."""
 
 import asyncio
+import os
+import httpx
 import logging
-from typing import Any, Dict, List, Optional, Union
-from datetime import datetime
-import aiohttp
-from pydantic import BaseModel, Field
+from typing import Optional, List
 
-from .config import FleetConfig
-from .exceptions import (
-    FleetAPIError,
-    FleetAuthenticationError,
-    FleetRateLimitError,
-    FleetTimeoutError,
-    FleetError,
-)
+from .base import InstanceBase, AsyncWrapper, SyncWrapper
+from .models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
 
+from .env import Environment, AsyncEnvironment
 
 logger = logging.getLogger(__name__)
 
 
-class InstanceRequest(BaseModel):
-    """Request model for creating instances."""
-    
-    env_key: str = Field(..., description="Environment key to create instance for")
-    version: Optional[str] = Field(None, description="Version of the environment")
-    region: Optional[str] = Field("us-west-1", description="AWS region")
-    seed: Optional[int] = Field(None, description="Random seed for deterministic behavior")
-    timestamp: Optional[int] = Field(None, description="Timestamp for environment state")
-    p_error: Optional[float] = Field(None, description="Error probability")
-    avg_latency: Optional[float] = Field(None, description="Average latency")
-    run_id: Optional[str] = Field(None, description="Run ID for tracking")
-    task_id: Optional[str] = Field(None, description="Task ID for tracking")
+class Instance(InstanceBase):
+    def __init__(self, httpx_client: Optional[httpx.Client] = None, **kwargs):
+        super().__init__(**kwargs)
+        self._httpx_client = httpx_client or httpx.Client()
+        self._env: Optional[Environment] = None
 
+    @property
+    def env(self) -> Environment:
+        if self._env is None:
+            self._env = Environment(self.manager_url, self._httpx_client)
+        return self._env
 
-class ManagerURLs(BaseModel):
-    """Model for manager API URLs."""
-    
-    api: str = Field(..., description="Manager API URL")
-    docs: str = Field(..., description="Manager docs URL")
-    reset: str = Field(..., description="Reset URL")
-    diff: str = Field(..., description="Diff URL")
-    snapshot: str = Field(..., description="Snapshot URL")
-    execute_verifier_function: str = Field(..., description="Execute verifier function URL")
-    execute_verifier_function_with_upload: str = Field(..., description="Execute verifier function with upload URL")
 
+class AsyncInstance(InstanceBase):
+    def __init__(self, httpx_client: Optional[httpx.AsyncClient] = None, **kwargs):
+        super().__init__(**kwargs)
+        self._httpx_client = httpx_client or httpx.AsyncClient()
+        self._env: Optional[AsyncEnvironment] = None
 
-class InstanceURLs(BaseModel):
-    """Model for instance URLs."""
-    
-    root: str = Field(..., description="Root URL")
-    app: str = Field(..., description="App URL")
-    api: Optional[str] = Field(None, description="API URL")
-    health: Optional[str] = Field(None, description="Health check URL")
-    api_docs: Optional[str] = Field(None, description="API documentation URL")
-    manager: ManagerURLs = Field(..., description="Manager API URLs")
+    @property
+    def env(self) -> AsyncEnvironment:
+        if self._env is None:
+            self._env = AsyncEnvironment(self.manager_url, self._httpx_client)
+        return self._env
 
 
-class InstanceResponse(BaseModel):
-    """Response model for instance operations."""
-    
-    instance_id: str = Field(..., description="Instance ID")
-    env_key: str = Field(..., description="Environment key")
-    version: str = Field(..., description="Environment version")
-    status: str = Field(..., description="Instance status")
-    subdomain: str = Field(..., description="Instance subdomain")
-    created_at: str = Field(..., description="Creation timestamp")
-    updated_at: str = Field(..., description="Last update timestamp")
-    terminated_at: Optional[str] = Field(None, description="Termination timestamp")
-    team_id: str = Field(..., description="Team ID")
-    region: str = Field(..., description="AWS region")
-    urls: InstanceURLs = Field(..., description="Instance URLs")
-    health: Optional[bool] = Field(None, description="Health status")
-
+class Fleet:
+    def __init__(
+        self,
+        api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
+        base_url: Optional[str] = None,
+        httpx_client: Optional[httpx.Client] = None,
+    ):
+        self._httpx_client = httpx_client or httpx.Client(timeout=60.0)
+        self.client = SyncWrapper(
+            api_key=api_key,
+            base_url=base_url,
+            httpx_client=self._httpx_client,
+        )
+
+    def environments(self) -> List[EnvironmentModel]:
+        response = self.client.request("GET", "/v1/env/")
+        return [EnvironmentModel(**env_data) for env_data in response.json()]
+
+    def environment(self, env_key: str) -> EnvironmentModel:
+        response = self.client.request("GET", f"/v1/env/{env_key}")
+        return EnvironmentModel(**response.json())
+
+    def make(self, request: InstanceRequest) -> Instance:
+        response = self.client.request(
+            "POST", "/v1/env/instances", json=request.model_dump()
+        )
+        return Instance(**response.json())
+
+    def instances(self, status: Optional[str] = None) -> List[Instance]:
+        params = {}
+        if status:
+            params["status"] = status
 
-class EnvDetails(BaseModel):
-    """Model for environment details and metadata."""
-    
-    env_key: str = Field(..., description="Environment key")
-    name: str = Field(..., description="Environment name")
-    description: Optional[str] = Field(..., description="Environment description")
-    default_version: Optional[str] = Field(..., description="Default version")
-    versions: Dict[str, str] = Field(..., description="Available versions")
+        response = self.client.request("GET", "/v1/env/instances", params=params)
+        return [Instance(**instance_data) for instance_data in response.json()]
 
+    def instance(self, instance_id: str) -> Instance:
+        response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
+        return Instance(**response.json())
 
-class HealthResponse(BaseModel):
-    """Response model for health checks."""
-    
-    status: str = Field(..., description="Health status")
-    timestamp: str = Field(..., description="Timestamp")
-    mode: str = Field(..., description="Operation mode")
-    region: str = Field(..., description="AWS region")
-    docker_status: str = Field(..., description="Docker status")
-    docker_error: Optional[str] = Field(None, description="Docker error if any")
-    instances: int = Field(..., description="Number of instances")
-    regions: Optional[Dict[str, "HealthResponse"]] = Field(None, description="Regional health info")
+    def delete(self, instance_id: str) -> InstanceRecord:
+        response = self.client.request("DELETE", f"/v1/env/instances/{instance_id}")
+        return InstanceRecord(**response.json())
 
 
-class FleetAPIClient:
-    """Client for making requests to the Fleet API."""
-    
-    def __init__(self, config: FleetConfig):
-        """Initialize the Fleet API client.
-        
-        Args:
-            config: Fleet configuration with API key and base URL
-        """
-        self.config = config
-        self._session: Optional[aiohttp.ClientSession] = None
-        self._base_url = config.base_url
-        
-    async def __aenter__(self):
-        """Async context manager entry."""
-        await self._ensure_session()
-        return self
-        
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
-        await self.close()
-        
-    async def _ensure_session(self):
-        """Ensure HTTP session is created."""
-        if self._session is None or self._session.closed:
-            headers = {}
-            if self.config.api_key:
-                headers["Authorization"] = f"Bearer {self.config.api_key}"
-                
-            timeout = aiohttp.ClientTimeout(total=60)
-            self._session = aiohttp.ClientSession(
-                headers=headers,
-                timeout=timeout,
-                connector=aiohttp.TCPConnector(limit=100),
-            )
-            
-    async def close(self):
-        """Close the HTTP session."""
-        if self._session and not self._session.closed:
-            await self._session.close()
-            self._session = None
-            
-    async def _request(
+class AsyncFleet:
+    def __init__(
         self,
-        method: str,
-        path: str,
-        data: Optional[Dict[str, Any]] = None,
-        params: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
-        timeout: Optional[float] = None,
-    ) -> Dict[str, Any]:
-        """Make an HTTP request to the Fleet API.
-        
-        Args:
-            method: HTTP method (GET, POST, DELETE, etc.)
-            path: API endpoint path
-            data: Request body data
-            params: Query parameters
-            headers: Additional headers
-            timeout: Request timeout in seconds
-            
-        Returns:
-            Response data as dictionary
-            
-        Raises:
-            FleetAPIError: If the API returns an error
-            FleetAuthenticationError: If authentication fails
-            FleetRateLimitError: If rate limit is exceeded
-            FleetTimeoutError: If request times out
-        """
-        await self._ensure_session()
-        
-        url = f"{self._base_url}{path}"
-        request_headers = headers or {}
-        
-        try:
-            logger.debug(f"Making {method} request to {url}")
-            
-            async with self._session.request(
-                method=method,
-                url=url,
-                json=data,
-                params=params,
-                headers=request_headers,
-                timeout=aiohttp.ClientTimeout(total=timeout or 60),
-            ) as response:
-                response_data = await response.json() if response.content_type == "application/json" else {}
-                
-                if response.status == 200:
-                    logger.debug(f"Request successful: {response.status}")
-                    return response_data
-                    
-                elif response.status == 401:
-                    raise FleetAuthenticationError("Authentication failed - check your API key")
-                    
-                elif response.status == 429:
-                    raise FleetRateLimitError("Rate limit exceeded - please retry later")
-                    
-                else:
-                    error_message = response_data.get("detail", f"API request failed with status {response.status}")
-                    raise FleetAPIError(
-                        error_message,
-                        status_code=response.status,
-                        response_data=response_data,
-                    )
-                    
-        except asyncio.TimeoutError:
-            raise FleetTimeoutError(f"Request to {url} timed out")
-            
-        except aiohttp.ClientError as e:
-            raise FleetAPIError(f"HTTP client error: {e}")
-            
-    # Environment operations
-    async def list_environments(self) -> List[EnvDetails]:
-        """List all available environments.
-        
-        Returns:
-            List of EnvDetails objects
-        """
-        response = await self._request("GET", "/v1/env/")
-        return [EnvDetails(**env_data) for env_data in response]
-        
-    async def get_environment(self, env_key: str) -> EnvDetails:
-        """Get details for a specific environment.
-        
-        Args:
-            env_key: Environment key
-            
-        Returns:
-            EnvDetails object
-        """
-        response = await self._request("GET", f"/v1/env/{env_key}")
-        return EnvDetails(**response)
-        
-    # Instance operations
-    async def create_instance(self, request: InstanceRequest) -> InstanceResponse:
-        """Create a new environment instance.
-        
-        Args:
-            request: Instance creation request
-            
-        Returns:
-            InstanceResponse object
-        """
-        response = await self._request("POST", "/v1/env/instances", data=request.model_dump(exclude_none=True))
-        return InstanceResponse(**response)
-        
-    async def list_instances(self, status: Optional[str] = None) -> List[InstanceResponse]:
-        """List all instances, optionally filtered by status.
-        
-        Args:
-            status: Optional status filter (pending, running, stopped, error)
-            
-        Returns:
-            List of InstanceResponse objects
-        """
+        api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
+        base_url: Optional[str] = None,
+        httpx_client: Optional[httpx.AsyncClient] = None,
+    ):
+        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=60.0)
+        self.client = AsyncWrapper(
+            api_key=api_key,
+            base_url=base_url,
+            httpx_client=self._httpx_client,
+        )
+
+    async def list_envs(self) -> List[EnvironmentModel]:
+        response = await self.client.request("GET", "/v1/env/")
+        return [EnvironmentModel(**env_data) for env_data in response.json()]
+
+    async def environment(self, env_key: str) -> EnvironmentModel:
+        response = await self.client.request("GET", f"/v1/env/{env_key}")
+        return EnvironmentModel(**response.json())
+
+    async def make(self, request: InstanceRequest) -> AsyncInstance:
+        response = await self.client.request(
+            "POST", "/v1/env/instances", json=request.model_dump()
+        )
+        instance = AsyncInstance(**response.json())
+        await instance.env.load()
+        return instance
+
+    async def instances(self, status: Optional[str] = None) -> List[AsyncInstance]:
         params = {}
         if status:
             params["status"] = status
-            
-        response = await self._request("GET", "/v1/env/instances", params=params)
-        return [InstanceResponse(**instance_data) for instance_data in response]
-        
-    async def get_instance(self, instance_id: str) -> InstanceResponse:
-        """Get details for a specific instance.
-        
-        Args:
-            instance_id: Instance ID
-            
-        Returns:
-            InstanceResponse object
-        """
-        response = await self._request("GET", f"/v1/env/instances/{instance_id}")
-        return InstanceResponse(**response)
-        
-    async def delete_instance(self, instance_id: str) -> Dict[str, Any]:
-        """Delete an instance.
-        
-        Args:
-            instance_id: Instance ID
-            
-        Returns:
-            Deletion response data
-        """
-        response = await self._request("DELETE", f"/v1/env/instances/{instance_id}")
-        return response
-        
-    # Health check operations
-    async def health_check(self) -> HealthResponse:
-        """Check the health of the Fleet API.
-        
-        Returns:
-            HealthResponse object
-        """
-        response = await self._request("GET", "/health")
-        return HealthResponse(**response)
-        
-    async def health_check_simple(self) -> HealthResponse:
-        """Simple health check without authentication.
-        
-        Returns:
-            HealthResponse object
-        """
-        response = await self._request("GET", "/health-check")
-        return HealthResponse(**response) 
+
+        response = await self.client.request("GET", "/v1/env/instances", params=params)
+        instances = [
+            AsyncInstance(**instance_data) for instance_data in response.json()
+        ]
+        await asyncio.gather(*[instance.env.load() for instance in instances])
+        return instances
+
+    async def instance(self, instance_id: str) -> AsyncInstance:
+        response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
+        instance = AsyncInstance(**response.json())
+        await instance.env.load()
+        return instance
+
+    async def delete(self, instance_id: str) -> InstanceRecord:
+        response = await self.client.request(
+            "DELETE", f"/v1/env/instances/{instance_id}"
+        )
+        return InstanceRecord(**response.json())

fleet/env/__init__.py

@@ -1,30 +1,8 @@
 """Fleet SDK Environment Module."""
 
-from .base import Environment, EnvironmentConfig
-from .factory import (
-    make, 
-    get, 
-    list_instances, 
-    list_envs, 
-    list_environments,
-    list_categories,
-    list_names,
-    list_versions,
-    is_environment_supported,
-    EnvironmentInstance
-)
+from .client import Environment, AsyncEnvironment
 
 __all__ = [
     "Environment",
-    "EnvironmentConfig", 
-    "EnvironmentInstance",
-    "make",
-    "get",
-    "list_instances",
-    "list_envs",
-    "list_environments",
-    "list_categories",
-    "list_names",
-    "list_versions",
-    "is_environment_supported",
-] 
+    "AsyncEnvironment",
+]