fleet-python 0.2.66b2__py3-none-any.whl → 0.2.105__py3-none-any.whl

fleet/config.py

@@ -1,5 +1,5 @@
 DEFAULT_MAX_RETRIES = 3
-DEFAULT_TIMEOUT = 180.0
+DEFAULT_TIMEOUT = 300.0
 
 GLOBAL_BASE_URL = "https://orchestrator.fleetai.com"
 REGION_BASE_URL = {

fleet/env/__init__.py

@@ -7,6 +7,10 @@ from .client import (
     list_regions,
     get,
     list_instances,
+    close,
+    close_all,
+    list_runs,
+    heartbeat,
     account,
 )
 
@@ -17,6 +21,10 @@ from .._async.env.client import (
     list_regions_async,
     get_async,
     list_instances_async,
+    close_async,
+    close_all_async,
+    list_runs_async,
+    heartbeat_async,
     account_async,
 )
 
@@ -27,11 +35,19 @@ __all__ = [
     "list_regions",
     "list_instances",
     "get",
+    "close",
+    "close_all",
+    "list_runs",
+    "heartbeat",
     "make_async",
     "list_envs_async",
     "list_regions_async",
     "list_instances_async",
     "get_async",
+    "close_async",
+    "close_all_async",
+    "list_runs_async",
+    "heartbeat_async",
     "account",
     "account_async",
 ]

fleet/env/client.py

@@ -1,5 +1,5 @@
 from ..client import Fleet, SyncEnv, Task
-from ..models import Environment as EnvironmentModel, AccountResponse
+from ..models import Environment as EnvironmentModel, AccountResponse, InstanceResponse, Run, HeartbeatResponse
 from typing import List, Optional, Dict, Any
 
 
@@ -10,6 +10,8 @@ def make(
     env_variables: Optional[Dict[str, Any]] = None,
     image_type: Optional[str] = None,
     ttl_seconds: Optional[int] = None,
+    run_id: Optional[str] = None,
+    heartbeat_interval: Optional[int] = None,
 ) -> SyncEnv:
     return Fleet().make(
         env_key,
@@ -18,6 +20,8 @@ def make(
         env_variables=env_variables,
         image_type=image_type,
         ttl_seconds=ttl_seconds,
+        run_id=run_id,
+        heartbeat_interval=heartbeat_interval,
     )
 
 
@@ -34,14 +38,67 @@ def list_regions() -> List[str]:
 
 
 def list_instances(
-    status: Optional[str] = None, region: Optional[str] = None
+    status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None, profile_id: Optional[str] = None
 ) -> List[SyncEnv]:
-    return Fleet().instances(status=status, region=region)
+    return Fleet().instances(status=status, region=region, run_id=run_id, profile_id=profile_id)
 
 
 def get(instance_id: str) -> SyncEnv:
     return Fleet().instance(instance_id)
 
 
+def close(instance_id: str) -> InstanceResponse:
+    """Close (delete) a specific instance by ID.
+    
+    Args:
+        instance_id: The instance ID to close
+        
+    Returns:
+        InstanceResponse containing the deleted instance details
+    """
+    return Fleet().close(instance_id)
+
+
+def close_all(run_id: Optional[str] = None, profile_id: Optional[str] = None) -> List[InstanceResponse]:
+    """Close (delete) instances using the batch delete endpoint.
+    
+    Args:
+        run_id: Optional run ID to filter instances by
+        profile_id: Optional profile ID to filter instances by (use "self" for your own profile)
+        
+    Returns:
+        List[InstanceResponse] containing the deleted instances
+        
+    Note:
+        At least one of run_id or profile_id must be provided.
+    """
+    return Fleet().close_all(run_id=run_id, profile_id=profile_id)
+
+
+def list_runs(profile_id: Optional[str] = None, status: Optional[str] = "active") -> List[Run]:
+    """List all runs (groups of instances by run_id) with aggregated statistics.
+    
+    Args:
+        profile_id: Optional profile ID to filter runs by (use "self" for your own profile)
+        status: Filter by run status - "active" (default), "inactive", or "all"
+        
+    Returns:
+        List[Run] containing run information with instance counts and timestamps
+    """
+    return Fleet().list_runs(profile_id=profile_id, status=status)
+
+
+def heartbeat(instance_id: str) -> HeartbeatResponse:
+    """Send heartbeat to keep instance alive (if heartbeat monitoring is enabled).
+    
+    Args:
+        instance_id: The instance ID to send heartbeat for
+        
+    Returns:
+        HeartbeatResponse containing heartbeat status and deadline information
+    """
+    return Fleet().heartbeat(instance_id)
+
+
 def account() -> AccountResponse:
     return Fleet().account()

fleet/eval/__init__.py

@@ -0,0 +1,15 @@
+"""Eval telemetry - uploads raw proxy traffic to backend.
+
+Simple design:
+- Proxy captures all HTTP traffic to JSONL file
+- Uploader tails file, batches entries, ships raw to backend
+- Backend does all parsing/structuring of transcripts
+- Optional whitelist to filter URLs
+
+No local parsing - just spool and ship.
+"""
+
+from .uploader import TrafficUploader
+
+__all__ = ["TrafficUploader"]
+

fleet/eval/uploader.py

@@ -0,0 +1,231 @@
+"""Raw traffic uploader - spools proxy logs and uploads to backend.
+
+No parsing, no structuring - just batch and ship raw entries.
+Backend handles all parsing/extraction of transcripts.
+
+Usage:
+    uploader = TrafficUploader(job_id="eval_123", log_file=proxy.log_path)
+    await uploader.start()  # Starts tailing and uploading
+    # ... run tasks ...
+    await uploader.stop()   # Flushes remaining
+"""
+
+import asyncio
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import List, Optional, Set
+
+logger = logging.getLogger(__name__)
+
+
+class TrafficUploader:
+    """Tails proxy log file and uploads raw entries in batches.
+    
+    Design:
+    - Tails JSONL file (like tail -f)
+    - Batches by count (100) or time (500ms)
+    - Uploads raw JSON entries (no parsing)
+    - Optional URL whitelist for filtering
+    """
+    
+    BATCH_SIZE = 100
+    FLUSH_INTERVAL_MS = 500
+    UPLOAD_TIMEOUT = 10.0
+    MAX_RETRIES = 3
+    
+    def __init__(
+        self,
+        job_id: str,
+        log_file: Path,
+        whitelist: Optional[Set[str]] = None,
+    ):
+        self.job_id = job_id
+        self.log_file = log_file
+        self.whitelist = whitelist  # URL patterns to include (None = all)
+        
+        self._running = False
+        self._task: Optional[asyncio.Task] = None
+        self._file = None
+        self._position = 0
+        
+        # Stats
+        self._read = 0
+        self._uploaded = 0
+        self._filtered = 0
+        
+        # HTTP client
+        self._client = None
+        self._base_url = os.environ.get("FLEET_API_URL", "https://orchestrator.fleetai.com")
+        self._api_key = os.environ.get("FLEET_API_KEY", "")
+    
+    async def start(self):
+        """Start tailing and uploading."""
+        if self._running:
+            return
+        
+        self._running = True
+        self._position = 0
+        self._read = 0
+        self._uploaded = 0
+        self._filtered = 0
+        
+        # Start tail loop
+        self._task = asyncio.create_task(self._tail_loop())
+        logger.info(f"Uploader started: job={self.job_id}, file={self.log_file}")
+    
+    async def stop(self):
+        """Stop and flush remaining entries."""
+        if not self._running:
+            return
+        
+        self._running = False
+        
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        
+        # Final read and upload
+        entries = self._read_new_entries()
+        if entries:
+            await self._upload_batch(entries)
+        
+        # Close client
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+        
+        logger.info(f"Uploader stopped: read={self._read}, uploaded={self._uploaded}, filtered={self._filtered}")
+    
+    async def _tail_loop(self):
+        """Main loop - tail file and upload batches."""
+        batch: List[dict] = []
+        last_flush = time.time()
+        
+        while self._running:
+            try:
+                # Read new entries from file
+                new_entries = self._read_new_entries()
+                
+                for entry in new_entries:
+                    # Apply whitelist filter
+                    if self._should_include(entry):
+                        batch.append(entry)
+                    else:
+                        self._filtered += 1
+                
+                # Check if we should flush
+                now = time.time()
+                should_flush = (
+                    len(batch) >= self.BATCH_SIZE or
+                    (batch and (now - last_flush) * 1000 >= self.FLUSH_INTERVAL_MS)
+                )
+                
+                if should_flush:
+                    await self._upload_batch(batch)
+                    batch = []
+                    last_flush = now
+                
+                # Small sleep to avoid busy loop
+                await asyncio.sleep(0.05)  # 50ms
+                
+            except asyncio.CancelledError:
+                # Upload remaining on cancel
+                if batch:
+                    await self._upload_batch(batch)
+                raise
+            except Exception as e:
+                logger.error(f"Tail loop error: {e}")
+                await asyncio.sleep(1)
+    
+    def _read_new_entries(self) -> List[dict]:
+        """Read new lines from log file."""
+        entries = []
+        
+        try:
+            if not self.log_file.exists():
+                return entries
+            
+            with open(self.log_file, "r") as f:
+                f.seek(self._position)
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        try:
+                            entry = json.loads(line)
+                            entries.append(entry)
+                            self._read += 1
+                        except json.JSONDecodeError:
+                            pass
+                self._position = f.tell()
+        except Exception as e:
+            logger.error(f"Read error: {e}")
+        
+        return entries
+    
+    def _should_include(self, entry: dict) -> bool:
+        """Check if entry passes whitelist filter."""
+        if self.whitelist is None:
+            return True  # No filter, include all
+        
+        # Check URL against whitelist patterns
+        url = entry.get("request", {}).get("url", "")
+        for pattern in self.whitelist:
+            if pattern in url:
+                return True
+        
+        return False
+    
+    async def _upload_batch(self, batch: List[dict]):
+        """Upload batch of raw entries to backend."""
+        if not batch:
+            return
+        
+        if not self._api_key:
+            # No API key, just count as uploaded (data is in local file)
+            self._uploaded += len(batch)
+            return
+        
+        for attempt in range(self.MAX_RETRIES):
+            try:
+                await self._do_upload(batch)
+                self._uploaded += len(batch)
+                return
+            except Exception as e:
+                if attempt == self.MAX_RETRIES - 1:
+                    logger.warning(f"Upload failed after {self.MAX_RETRIES} attempts: {e}")
+                else:
+                    await asyncio.sleep(0.2 * (attempt + 1))
+    
+    async def _do_upload(self, batch: List[dict]):
+        """POST raw entries to backend."""
+        import httpx
+        
+        if not self._client:
+            self._client = httpx.AsyncClient(
+                base_url=self._base_url,
+                headers={"Authorization": f"Bearer {self._api_key}"},
+                timeout=self.UPLOAD_TIMEOUT,
+            )
+        
+        payload = {
+            "job_id": self.job_id,
+            "entries": batch,  # Raw entries, no parsing
+        }
+        
+        resp = await self._client.post(f"/v1/eval_jobs/{self.job_id}/logs", json=payload)
+        resp.raise_for_status()
+    
+    @property
+    def stats(self) -> dict:
+        return {
+            "read": self._read,
+            "uploaded": self._uploaded,
+            "filtered": self._filtered,
+        }
+

fleet/exceptions.py

@@ -137,6 +137,14 @@ class FleetTeamNotFoundError(FleetPermissionError):
         self.team_id = team_id
 
 
+class FleetConflictError(FleetAPIError):
+    """Exception raised when there's a conflict (e.g., resource already exists)."""
+
+    def __init__(self, message: str, resource_name: Optional[str] = None):
+        super().__init__(message, status_code=409)
+        self.resource_name = resource_name
+
+
 class FleetEnvironmentError(FleetError):
     """Exception raised when environment operations fail."""
 

fleet/instance/client.py

@@ -9,6 +9,7 @@ from urllib.parse import urlparse
 
 from ..resources.sqlite import SQLiteResource
 from ..resources.browser import BrowserResource
+from ..resources.api import APIResource
 from ..resources.base import Resource
 
 from fleet.verifiers import DatabaseSnapshot
@@ -23,6 +24,7 @@ from .models import (
     ResetResponse,
     Resource as ResourceModel,
     ResourceType,
+    ResourceMode,
     HealthResponse,
     ExecuteFunctionRequest,
     ExecuteFunctionResponse,
@@ -35,6 +37,7 @@ logger = logging.getLogger(__name__)
 RESOURCE_TYPES = {
     ResourceType.db: SQLiteResource,
     ResourceType.cdp: BrowserResource,
+    ResourceType.api: APIResource,
 }
 
 ValidatorType = Callable[
@@ -83,15 +86,46 @@ class InstanceClient:
         Returns:
             An SQLite database resource for the given database name
         """
-        return SQLiteResource(
-            self._resources_state[ResourceType.db.value][name], self.client
-        )
+        resource_info = self._resources_state[ResourceType.db.value][name]
+        # Local mode - resource_info is a dict with creation parameters
+        if isinstance(resource_info, dict) and resource_info.get('type') == 'local':
+            # Create new instance each time (matching HTTP mode behavior)
+            return SQLiteResource(
+                resource_info['resource_model'],
+                client=None,
+                db_path=resource_info['db_path']
+            )
+        # HTTP mode - resource_info is a ResourceModel, create new wrapper
+        return SQLiteResource(resource_info, self.client)
 
     def browser(self, name: str) -> BrowserResource:
         return BrowserResource(
             self._resources_state[ResourceType.cdp.value][name], self.client
         )
 
+    def api(self, name: str, base_url: str) -> APIResource:
+        """
+        Returns an API resource for making HTTP requests.
+
+        Args:
+            name: The name of the API resource
+            base_url: The base URL for API requests
+
+        Returns:
+            An APIResource for making HTTP requests
+        """
+        # Create a minimal resource model for API
+        resource_model = ResourceModel(
+            name=name,
+            type=ResourceType.api,
+            mode=ResourceMode.rw,
+        )
+        return APIResource(
+            resource_model,
+            base_url=base_url,
+            client=self.client.httpx_client if self.client else None,
+        )
+
     def resources(self) -> List[Resource]:
         self._load_resources()
         return [
@@ -128,10 +162,14 @@ class InstanceClient:
 
     def _load_resources(self) -> None:
         if self._resources is None:
-            response = self.client.request("GET", "/resources", timeout=1.0)
+            response = self.client.request("GET", "/resources")
             if response.status_code != 200:
-                self._resources = []
-                return
+                response_body = response.text[:500] if response.text else "empty"
+                self._resources = []  # Mark as loaded (empty) to prevent retries
+                raise FleetEnvironmentError(
+                    f"Failed to load instance resources: status_code={response.status_code} "
+                    f"(url={self.base_url}, response={response_body})"
+                )
 
             # Handle both old and new response formats
             response_data = response.json()
@@ -175,10 +213,17 @@ class InstanceClient:
         response = self.client.request("GET", "/health")
         return HealthResponse(**response.json())
 
+    def close(self):
+        """Close anchor connections for in-memory databases."""
+        if hasattr(self, '_memory_anchors'):
+            for conn in self._memory_anchors.values():
+                conn.close()
+            self._memory_anchors.clear()
+
     def __enter__(self):
-        """Async context manager entry."""
+        """Context manager entry."""
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
+        """Context manager exit."""
         self.close()

fleet/instance/models.py

@@ -91,6 +91,7 @@ class ResourceMode(Enum):
 class ResourceType(Enum):
     db = "sqlite"
     cdp = "cdp"
+    api = "api"
 
 
 class TableSchema(BaseModel):