fleet-python 0.2.69b3__tar.gz → 0.2.70__tar.gz

{fleet_python-0.2.69b3/fleet_python.egg-info → fleet_python-0.2.70}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.69b3
+Version: 0.2.70
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.69b3 → fleet_python-0.2.70}/fleet/__init__.py

@@ -26,7 +26,7 @@ from .exceptions import (
 )
 from .client import Fleet, SyncEnv
 from ._async.client import AsyncFleet, AsyncEnv
-from .models import InstanceResponse, Environment
+from .models import InstanceResponse, Environment, Run
 from .instance.models import Resource, ResetResponse
 
 # Import sync verifiers with explicit naming
@@ -73,7 +73,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.1.0"
+__version__ = "0.2.70"
 
 __all__ = [
     # Core classes
@@ -86,6 +86,7 @@ __all__ = [
     "SyncEnv",
     "Resource",
     "ResetResponse",
+    "Run",
     # Task models
     "Task",
     "VerifierFunction",

{fleet_python-0.2.69b3 → fleet_python-0.2.70}/fleet/_async/__init__.py

@@ -25,7 +25,7 @@ from ..exceptions import (
     FleetConfigurationError,
 )
 from .client import AsyncFleet, AsyncEnv
-from ..models import InstanceResponse, Environment, AccountResponse
+from ..models import InstanceResponse, Environment, AccountResponse, Run
 from ..instance.models import Resource, ResetResponse
 
 # Import async verifiers
@@ -44,7 +44,7 @@ from ..types import VerifierFunction
 from .. import env
 from . import global_client as _async_global_client
 
-__version__ = "0.1.0"
+__version__ = "0.2.70"
 
 __all__ = [
     # Core classes
@@ -54,6 +54,7 @@ __all__ = [
     "InstanceResponse",
     "Resource",
     "ResetResponse",
+    "Run",
     # Task models
     "Task",
     "VerifierFunction",
@@ -90,6 +91,7 @@ __all__ = [
     "import_tasks",
     "account",
     "get_task",
+    "list_runs",
     # Version
     "__version__",
 ]
@@ -255,6 +257,28 @@ async def get_task(task_key: str, version_id: Optional[str] = None):
     )
 
 
+async 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
+
+    Example:
+        runs = await fleet.list_runs()
+        my_runs = await fleet.list_runs(profile_id="self")
+        all_runs = await fleet.list_runs(status="all")
+    """
+    return await _async_global_client.get_client().list_runs(
+        profile_id=profile_id, status=status
+    )
+
+
 def configure(
     api_key: Optional[str] = None,
     base_url: Optional[str] = None,

{fleet_python-0.2.69b3 → fleet_python-0.2.70}/fleet/_async/base.py

@@ -2,6 +2,7 @@ import httpx
 from typing import Dict, Any, Optional
 import json
 import logging
+import uuid
 
 from ..models import InstanceResponse
 from ..config import GLOBAL_BASE_URL
@@ -20,6 +21,12 @@ from .exceptions import (
     FleetPermissionError,
 )
 
+# Import version
+try:
+    from .. import __version__
+except ImportError:
+    __version__ = "0.2.70"
+
 logger = logging.getLogger(__name__)
 
 
@@ -38,17 +45,17 @@ class BaseWrapper:
             base_url = GLOBAL_BASE_URL
         self.base_url = base_url
 
-    def get_headers(self) -> Dict[str, str]:
+    def get_headers(self, request_id: Optional[str] = None) -> Dict[str, str]:
         headers: Dict[str, str] = {
             "X-Fleet-SDK-Language": "Python",
-            "X-Fleet-SDK-Version": "1.0.0",
+            "X-Fleet-SDK-Version": __version__,
         }
         headers["Authorization"] = f"Bearer {self.api_key}"
-        # Debug log
-        import logging
-
-        logger = logging.getLogger(__name__)
-        logger.debug(f"Headers being sent: {headers}")
+        
+        # Add request ID for idempotency (persists across retries)
+        if request_id:
+            headers["X-Request-ID"] = request_id
+        
         return headers
 
 
@@ -67,11 +74,14 @@ class AsyncWrapper(BaseWrapper):
         **kwargs,
     ) -> httpx.Response:
         base_url = base_url or self.base_url
+        # Generate unique request ID that persists across retries
+        request_id = str(uuid.uuid4())
+        
         try:
             response = await self.httpx_client.request(
                 method,
                 f"{base_url}{url}",
-                headers=self.get_headers(),
+                headers=self.get_headers(request_id=request_id),
                 params=params,
                 json=json,
                 **kwargs,
@@ -93,8 +103,9 @@ class AsyncWrapper(BaseWrapper):
 
         # Debug log 500 errors
         if status_code == 500:
-            logger.error(f"Got 500 error from {response.url}")
-            logger.error(f"Response text: {response.text}")
+            # logger.error(f"Got 500 error from {response.url}")
+            # logger.error(f"Response text: {response.text}")
+            pass
 
         # Try to parse error response as JSON
         try:

{fleet_python-0.2.69b3 → fleet_python-0.2.70}/fleet/_async/client.py

@@ -21,7 +21,7 @@ import httpx
 import json
 import logging
 import os
-from typing import List, Optional, Dict, Any, TYPE_CHECKING, Union
+from typing import List, Optional, Dict, Any, TYPE_CHECKING
 
 from .base import EnvironmentBase, AsyncWrapper
 from ..models import (
@@ -35,6 +35,8 @@ from ..models import (
     TaskRequest,
     TaskResponse,
     TaskUpdateRequest,
+    Run,
+    HeartbeatResponse,
 )
 from .tasks import Task
 
@@ -47,11 +49,6 @@ from .instance import (
     ResetResponse,
     ExecuteFunctionResponse,
 )
-from ..instance.models import (
-    Resource as ResourceModel,
-    ResourceType,
-    ResourceMode,
-)
 from ..config import (
     DEFAULT_MAX_RETRIES,
     DEFAULT_TIMEOUT,
@@ -131,6 +128,23 @@ class AsyncEnv(EnvironmentBase):
     async def close(self) -> InstanceResponse:
         return await _delete_instance(self._load_client, self.instance_id)
 
+    async def heartbeat(self) -> HeartbeatResponse:
+        """Send heartbeat to keep instance alive (if heartbeat monitoring is enabled).
+        
+        Returns:
+            HeartbeatResponse containing heartbeat status and deadline information
+        """
+        body = {}
+        if self.heartbeat_region:
+            body["region"] = self.heartbeat_region
+        
+        response = await self._load_client.request(
+            "POST", 
+            f"/v1/env/instances/{self.instance_id}/heartbeat",
+            json=body
+        )
+        return HeartbeatResponse(**response.json())
+
     async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return await self.instance.verify(validator)
 
@@ -218,6 +232,7 @@ class AsyncFleet:
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
         run_id: Optional[str] = None,
+        heartbeat_interval: Optional[int] = None,
     ) -> AsyncEnv:
         if ":" in env_key:
             env_key_part, env_version = env_key.split(":", 1)
@@ -254,6 +269,7 @@ class AsyncFleet:
             created_from="sdk",
             ttl_seconds=ttl_seconds,
             run_id=run_id,
+            heartbeat_interval=heartbeat_interval,
         )
 
         # Only use region-specific base URL if no custom base URL is set
@@ -276,7 +292,7 @@ class AsyncFleet:
         return await self.make(env_key=f"{task.env_id}:{task.version}")
 
     async def instances(
-        self, status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
+        self, status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None, profile_id: Optional[str] = None
     ) -> List[AsyncEnv]:
         params = {}
         if status:
@@ -285,6 +301,8 @@ class AsyncFleet:
             params["region"] = region
         if run_id:
             params["run_id"] = run_id
+        if profile_id:
+            params["profile_id"] = profile_id
 
         response = await self.client.request("GET", "/v1/env/instances", params=params)
         return [
@@ -292,163 +310,11 @@ class AsyncFleet:
             for instance_data in response.json()
         ]
 
-    async def instance(self, instance_id: Union[str, Dict[str, str]]) -> AsyncEnv:
-        """Create or connect to an environment instance.
-
-        Supports three modes based on input type:
-        1. dict: Local filesystem mode - {"current": "./data.db", "seed": "./seed.db"}
-        2. str starting with http:// or https://: Localhost/URL mode
-        3. str (other): Remote cloud instance mode
-
-        Args:
-            instance_id: Instance identifier (str), URL (str starting with http://),
-                        or local db mapping (dict)
-
-        Returns:
-            AsyncEnv: Environment instance
-        """
-        # Local filesystem mode - dict of resource names to file paths
-        if isinstance(instance_id, dict):
-            return self._create_local_instance(instance_id)
-
-        # Localhost/direct URL mode - string starting with http:// or https://
-        elif isinstance(instance_id, str) and instance_id.startswith(("http://", "https://")):
-            return self._create_url_instance(instance_id)
-
-        # Remote mode - existing behavior
-        else:
-            response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
-            instance = AsyncEnv(client=self.client, **response.json())
-            await instance.instance.load()
-            return instance
-
-    def _create_url_instance(self, base_url: str) -> AsyncEnv:
-        """Create instance connected to a direct URL (localhost or custom).
-
-        Args:
-            base_url: URL of the instance manager API
-
-        Returns:
-            AsyncEnv: Environment instance configured for URL mode
-        """
-        instance_client = AsyncInstanceClient(url=base_url, httpx_client=self._httpx_client)
-
-        # Create a minimal environment for URL mode
-        env = AsyncEnv(
-            client=self.client,
-            instance_id=base_url,
-            env_key="localhost",
-            version="",
-            status="running",
-            subdomain="localhost",
-            created_at="",
-            updated_at="",
-            terminated_at=None,
-            team_id="",
-            region="localhost",
-            env_variables=None,
-            data_key=None,
-            data_version=None,
-            urls=None,
-            health=None,
-        )
-        env._instance = instance_client
-        return env
-
-    @staticmethod
-    def _normalize_db_path(path: str) -> tuple[str, bool]:
-        """Normalize database path and detect if it's in-memory.
-
-        Args:
-            path: Database path - can be:
-                  - File path: "./data.db"
-                  - Plain memory: ":memory:"
-                  - Named memory: ":memory:namespace"
-                  - URI: "file:name?mode=memory&cache=shared"
-
-        Returns:
-            Tuple of (normalized_path, is_memory)
-        """
-        import uuid
-        import sqlite3
-
-        if path == ":memory:":
-            # Plain :memory: - create unique namespace
-            name = f"mem_{uuid.uuid4().hex[:8]}"
-            return f"file:{name}?mode=memory&cache=shared", True
-        elif path.startswith(":memory:"):
-            # Named memory: :memory:current -> file:current?mode=memory&cache=shared
-            namespace = path[8:]  # Remove ":memory:" prefix
-            return f"file:{namespace}?mode=memory&cache=shared", True
-        elif "mode=memory" in path:
-            # Already a proper memory URI
-            return path, True
-        else:
-            # Regular file path
-            return path, False
-
-    def _create_local_instance(self, dbs: Dict[str, str]) -> AsyncEnv:
-        """Create instance with local file-based or in-memory SQLite resources.
-
-        Args:
-            dbs: Map of resource names to paths (e.g., {"current": "./data.db"} or
-                 {"current": ":memory:current"})
-
-        Returns:
-            AsyncEnv: Environment instance configured for local mode
-        """
-        import sqlite3
-
-        instance_client = AsyncInstanceClient(url="local://", httpx_client=None)
-        instance_client._resources = []  # Mark as loaded
-        instance_client._memory_anchors = {}  # Store anchor connections for in-memory DBs
-
-        # Store creation parameters for local AsyncSQLiteResources
-        # This allows db() to create new instances each time (matching HTTP mode behavior)
-        for name, path in dbs.items():
-            # Normalize path and detect if it's in-memory
-            normalized_path, is_memory = self._normalize_db_path(path)
-
-            # Create anchor connection for in-memory databases
-            # This keeps the database alive as long as the env exists
-            if is_memory:
-                anchor_conn = sqlite3.connect(normalized_path, uri=True)
-                instance_client._memory_anchors[name] = anchor_conn
-
-            resource_model = ResourceModel(
-                name=name,
-                type=ResourceType.db,
-                mode=ResourceMode.rw,
-                label=f"Local: {path}",
-            )
-            instance_client._resources_state[ResourceType.db.value][name] = {
-                'type': 'local',
-                'resource_model': resource_model,
-                'db_path': normalized_path,
-                'is_memory': is_memory
-            }
-
-        # Create a minimal environment for local mode
-        env = AsyncEnv(
-            client=self.client,
-            instance_id="local",
-            env_key="local",
-            version="",
-            status="running",
-            subdomain="local",
-            created_at="",
-            updated_at="",
-            terminated_at=None,
-            team_id="",
-            region="local",
-            env_variables=None,
-            data_key=None,
-            data_version=None,
-            urls=None,
-            health=None,
-        )
-        env._instance = instance_client
-        return env
+    async def instance(self, instance_id: str) -> AsyncEnv:
+        response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
+        instance = AsyncEnv(client=self.client, **response.json())
+        await instance.instance.load()
+        return instance
 
     async def check_bundle_exists(self, bundle_hash: str) -> VerifiersCheckResponse:
         return await _check_bundle_exists(self.client, bundle_hash)
@@ -474,16 +340,53 @@ class AsyncFleet:
         """
         return await _delete_instance(self.client, instance_id)
 
-    async def close_all(self, run_id: str) -> List[InstanceResponse]:
-        """Close (delete) all instances associated with a run_id.
+    async def heartbeat(self, instance_id: str, region: Optional[str] = None) -> HeartbeatResponse:
+        """Send heartbeat to keep instance alive (if heartbeat monitoring is enabled).
+        
+        Args:
+            instance_id: The instance ID to send heartbeat for
+            region: Optional region override for cross-region heartbeats
+            
+        Returns:
+            HeartbeatResponse containing heartbeat status and deadline information
+        """
+        return await _send_heartbeat(self.client, instance_id, region)
+
+    async def close_all(self, run_id: Optional[str] = None, profile_id: Optional[str] = None) -> List[InstanceResponse]:
+        """Close (delete) instances using the batch delete endpoint.
         
         Args:
-            run_id: The run ID whose instances should be closed
+            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 await _delete_instances_by_run_id(self.client, run_id)
+        return await _delete_instances_batch(self.client, run_id=run_id, profile_id=profile_id)
+    
+    async def list_runs(
+        self, 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
+        """
+        params = {}
+        if profile_id:
+            params["profile_id"] = profile_id
+        if status:
+            params["active"] = status
+            
+        response = await self.client.request("GET", "/v1/env/runs", params=params)
+        return [Run(**run_data) for run_data in response.json()]
 
     async def load_tasks_from_file(self, filename: str) -> List[Task]:
         with open(filename, "r", encoding="utf-8") as f:
@@ -563,8 +466,8 @@ class AsyncFleet:
             error_msg = f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
             if raise_on_verifier_error:
                 raise ValueError(error_msg) from e
-            else:
-                logger.warning(error_msg)
+            # else:
+            #     logger.warning(error_msg)
 
         task = Task(
             key=task_json.get("key", task_json.get("id")),
@@ -656,25 +559,25 @@ class AsyncFleet:
                                     verifier_sha=tr.verifier.sha256,
                                 )
                             except Exception as e:
-                                logger.warning(
-                                    f"Failed to create verifier {tr.verifier.key}: {e}"
-                                )
+                                # logger.warning(
+                                #     f"Failed to create verifier {tr.verifier.key}: {e}"
+                                # )
                                 return None
                         else:
                             # Fallback: try fetching by ID
                             try:
-                                logger.warning(
-                                    f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
-                                    f"Attempting to refetch by id {tr.verifier.verifier_id}"
-                                )
+                                # logger.warning(
+                                #     f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
+                                #     f"Attempting to refetch by id {tr.verifier.verifier_id}"
+                                # )
                                 return await self._load_verifier(
                                     tr.verifier.verifier_id
                                 )
                             except Exception as e:
-                                logger.warning(
-                                    f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
-                                    "Leaving verifier unset."
-                                )
+                                # logger.warning(
+                                #     f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
+                                #     "Leaving verifier unset."
+                                # )
                                 return None
 
                 # Add the coroutine for parallel execution
@@ -713,9 +616,10 @@ class AsyncFleet:
             if task_response.verifier:
                 # Process verifier result
                 if isinstance(verifier_result, Exception):
-                    logger.warning(
-                        f"Verifier loading failed for {task_response.key}: {verifier_result}"
-                    )
+                    # logger.warning(
+                    #     f"Verifier loading failed for {task_response.key}: {verifier_result}"
+                    # )
+                    pass
                 elif verifier_result is not None:
                     verifier = verifier_result
                     embedded_code = task_response.verifier.code or ""
@@ -789,10 +693,10 @@ class AsyncFleet:
             with open(filename, "w", encoding="utf-8") as f:
                 json.dump(tasks_data, f, indent=2, default=str)
 
-            logger.info(f"Exported {len(tasks)} tasks to {filename}")
+            # logger.info(f"Exported {len(tasks)} tasks to {filename}")
             return filename
         else:
-            logger.info("No tasks found to export")
+            # logger.info("No tasks found to export")
             return None
 
     async def import_single_task(self, task: Task, project_key: Optional[str] = None):
@@ -821,7 +725,7 @@ class AsyncFleet:
             )
             return response
         except Exception as e:
-            logger.error(f"Failed to import task {task.key}: {e}")
+            # logger.error(f"Failed to import task {task.key}: {e}")
             return None
 
     async def import_tasks(self, filename: str, project_key: Optional[str] = None):
@@ -994,8 +898,34 @@ async def _delete_instance(client: AsyncWrapper, instance_id: str) -> InstanceRe
     return InstanceResponse(**response.json())
 
 
-async def _delete_instances_by_run_id(client: AsyncWrapper, run_id: str) -> List[InstanceResponse]:
-    response = await client.request("DELETE", f"/v1/env/instances/run/{run_id}")
+async def _send_heartbeat(client: AsyncWrapper, instance_id: str, region: Optional[str] = None) -> HeartbeatResponse:
+    """Send heartbeat to keep instance alive."""
+    body = {}
+    if region:
+        body["region"] = region
+    
+    response = await client.request(
+        "POST",
+        f"/v1/env/instances/{instance_id}/heartbeat",
+        json=body
+    )
+    return HeartbeatResponse(**response.json())
+
+
+async def _delete_instances_batch(
+    client: AsyncWrapper, run_id: Optional[str] = None, profile_id: Optional[str] = None
+) -> List[InstanceResponse]:
+    """Delete instances using the batch endpoint with flexible filtering."""
+    params = {}
+    if run_id:
+        params["run_id"] = run_id
+    if profile_id:
+        params["profile_id"] = profile_id
+    
+    if not params:
+        raise ValueError("At least one of run_id or profile_id must be provided")
+    
+    response = await client.request("DELETE", "/v1/env/instances/batch", params=params)
     return [InstanceResponse(**instance_data) for instance_data in response.json()]
 
 
@@ -1041,17 +971,17 @@ async def _execute_verifier_remote(
         request_data["bundle"] = bundle_b64
 
     # Debug logging
-    logger.debug(
-        f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
-    )
-    logger.debug(f"Request has bundle: {needs_upload}")
-    logger.debug(f"Using client with base_url: {client.base_url}")
-    logger.debug(f"Request data keys: {list(request_data.keys())}")
-    logger.debug(
-        f"Bundle size: {len(request_data.get('bundle', ''))} chars"
-        if "bundle" in request_data
-        else "No bundle"
-    )
+    # logger.debug(
+    #     f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
+    # )
+    # logger.debug(f"Request has bundle: {needs_upload}")
+    # logger.debug(f"Using client with base_url: {client.base_url}")
+    # logger.debug(f"Request data keys: {list(request_data.keys())}")
+    # logger.debug(
+    #     f"Bundle size: {len(request_data.get('bundle', ''))} chars"
+    #     if "bundle" in request_data
+    #     else "No bundle"
+    # )
 
     # Note: This should be called on the instance URL, not the orchestrator
     # The instance has manager URLs for verifier execution
@@ -1059,6 +989,6 @@ async def _execute_verifier_remote(
 
     # Debug the response
     response_json = response.json()
-    logger.debug(f"Verifier execute response: {response_json}")
+    # logger.debug(f"Verifier execute response: {response_json}")
 
     return VerifiersExecuteResponse(**response_json)