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

fleet/_async/env/client.py

@@ -1,5 +1,5 @@
 from ..client import AsyncFleet, AsyncEnv, 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 @@ async def make_async(
     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,
 ) -> AsyncEnv:
     return await AsyncFleet().make(
         env_key,
@@ -18,6 +20,8 @@ async def make_async(
         env_variables=env_variables,
         image_type=image_type,
         ttl_seconds=ttl_seconds,
+        run_id=run_id,
+        heartbeat_interval=heartbeat_interval,
     )
 
 
@@ -34,14 +38,67 @@ async def list_regions_async() -> List[str]:
 
 
 async def list_instances_async(
-    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[AsyncEnv]:
-    return await AsyncFleet().instances(status=status, region=region)
+    return await AsyncFleet().instances(status=status, region=region, run_id=run_id, profile_id=profile_id)
 
 
 async def get_async(instance_id: str) -> AsyncEnv:
     return await AsyncFleet().instance(instance_id)
 
 
+async def close_async(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 await AsyncFleet().close(instance_id)
+
+
+async def close_all_async(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 await AsyncFleet().close_all(run_id=run_id, profile_id=profile_id)
+
+
+async def list_runs_async(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 await AsyncFleet().list_runs(profile_id=profile_id, status=status)
+
+
+async def heartbeat_async(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 await AsyncFleet().heartbeat(instance_id)
+
+
 async def account_async() -> AccountResponse:
     return await AsyncFleet().account()

fleet/_async/instance/client.py

@@ -9,6 +9,7 @@ from urllib.parse import urlparse
 
 from ..resources.sqlite import AsyncSQLiteResource
 from ..resources.browser import AsyncBrowserResource
+from ..resources.api import AsyncAPIResource
 from ..resources.base import Resource
 
 from fleet.verifiers import DatabaseSnapshot
@@ -23,6 +24,7 @@ from ...instance.models import (
     ResetResponse,
     Resource as ResourceModel,
     ResourceType,
+    ResourceMode,
     HealthResponse,
     ExecuteFunctionRequest,
     ExecuteFunctionResponse,
@@ -35,6 +37,7 @@ logger = logging.getLogger(__name__)
 RESOURCE_TYPES = {
     ResourceType.db: AsyncSQLiteResource,
     ResourceType.cdp: AsyncBrowserResource,
+    ResourceType.api: AsyncAPIResource,
 }
 
 ValidatorType = Callable[
@@ -85,15 +88,46 @@ class AsyncInstanceClient:
         Returns:
             An SQLite database resource for the given database name
         """
-        return AsyncSQLiteResource(
-            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 AsyncSQLiteResource(
+                resource_info['resource_model'],
+                client=None,
+                db_path=resource_info['db_path']
+            )
+        # HTTP mode - resource_info is a ResourceModel, create new wrapper
+        return AsyncSQLiteResource(resource_info, self.client)
 
     def browser(self, name: str) -> AsyncBrowserResource:
         return AsyncBrowserResource(
             self._resources_state[ResourceType.cdp.value][name], self.client
         )
 
+    def api(self, name: str, base_url: str) -> AsyncAPIResource:
+        """
+        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 AsyncAPIResource for making HTTP requests
+        """
+        # Create a minimal resource model for API
+        resource_model = ResourceModel(
+            name=name,
+            type=ResourceType.api,
+            mode=ResourceMode.rw,
+        )
+        return AsyncAPIResource(
+            resource_model,
+            base_url=base_url,
+            client=self.client.httpx_client if self.client else None,
+        )
+
     async def resources(self) -> List[Resource]:
         await self._load_resources()
         return [
@@ -130,10 +164,14 @@ class AsyncInstanceClient:
 
     async def _load_resources(self) -> None:
         if self._resources is None:
-            response = await self.client.request("GET", "/resources", timeout=1.0)
+            response = await 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()
@@ -177,10 +215,17 @@ class AsyncInstanceClient:
         response = await 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()
+
     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()
+        self.close()

fleet/_async/models.py

@@ -120,6 +120,7 @@ class ResourceMode(Enum):
 class ResourceType(Enum):
     sqlite = "sqlite"
     cdp = "cdp"
+    api = "api"
 
 
 class RestoreRequest(BaseModel):
@@ -155,12 +156,23 @@ class TaskRequest(BaseModel):
     verifier_id: Optional[str] = Field(None, title="Verifier Id")
     version: Optional[str] = Field(None, title="Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
+    writer_metadata: Optional[Dict[str, Any]] = Field(
+        None, title="Writer Metadata", description="Metadata filled by task writer"
+    )
     output_json_schema: Optional[Dict[str, Any]] = Field(None, title="Output Json Schema")
 
 
 class TaskUpdateRequest(BaseModel):
     prompt: Optional[str] = Field(None, title="Prompt")
     verifier_code: Optional[str] = Field(None, title="Verifier Code")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
+    writer_metadata: Optional[Dict[str, Any]] = Field(
+        None, title="Writer Metadata", description="Metadata filled by task writer"
+    )
+    qa_metadata: Optional[Dict[str, Any]] = Field(
+        None, title="QA Metadata", description="Metadata filled by QA reviewer"
+    )
 
 
 class VerifierData(BaseModel):
@@ -186,6 +198,9 @@ class TaskResponse(BaseModel):
     data_version: Optional[str] = Field(None, title="Data Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
     verifier: Optional[VerifierData] = Field(None, title="Verifier")
+    metadata: Optional[Dict[str, Any]] = Field(None, title="Metadata")
+    writer_metadata: Optional[Dict[str, Any]] = Field(None, title="Writer Metadata")
+    qa_metadata: Optional[Dict[str, Any]] = Field(None, title="QA Metadata")
     output_json_schema: Optional[Dict[str, Any]] = Field(None, title="Output Json Schema")
 
 

fleet/_async/resources/api.py

@@ -0,0 +1,200 @@
+"""Async API Resource for making HTTP requests to the app's API endpoint."""
+
+from typing import Any, Dict, Optional
+import httpx
+
+from .base import Resource
+from ...instance.models import Resource as ResourceModel
+
+
+class AsyncAPIResponse:
+    """Simple wrapper around httpx.Response with a requests-like interface."""
+
+    def __init__(self, response: httpx.Response):
+        self._response = response
+        self.status_code: int = response.status_code
+        self.headers: httpx.Headers = response.headers
+        self.text: str = response.text
+        self.content: bytes = response.content
+        self.url: str = str(response.url)
+        self.ok: bool = response.is_success
+
+    def json(self) -> Any:
+        """Parse response body as JSON."""
+        return self._response.json()
+
+    def raise_for_status(self) -> "AsyncAPIResponse":
+        """Raise an HTTPStatusError if the response has an error status code."""
+        self._response.raise_for_status()
+        return self
+
+    def __repr__(self) -> str:
+        return f"<AsyncAPIResponse [{self.status_code}]>"
+
+
+class AsyncAPIResource(Resource):
+    """Async HTTP client for making requests to the app's API endpoint.
+
+    Provides a requests-like interface for interacting with the app's REST API.
+
+    Example:
+        api = env.api()
+        response = await api.get("/users/1")
+        print(response.status_code)  # 200
+        print(response.json())       # {"id": 1, "name": "John"}
+
+        # With headers/auth
+        response = await api.post(
+            "/users",
+            json={"name": "Jane"},
+            headers={"Authorization": "Bearer xxx"}
+        )
+    """
+
+    def __init__(
+        self,
+        resource: ResourceModel,
+        base_url: str,
+        client: Optional[httpx.AsyncClient] = None,
+    ):
+        super().__init__(resource)
+        self.base_url = base_url.rstrip("/")
+        self._client = client or httpx.AsyncClient()
+
+    def _build_url(self, path: str) -> str:
+        """Build full URL from base_url and path."""
+        if path.startswith("/"):
+            return f"{self.base_url}{path}"
+        return f"{self.base_url}/{path}"
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        cookies: Optional[Dict[str, str]] = None,
+        timeout: Optional[float] = None,
+        **kwargs: Any,
+    ) -> AsyncAPIResponse:
+        """Make an HTTP request.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, PATCH, DELETE, etc.)
+            path: URL path (relative to base_url)
+            params: Query parameters
+            json: JSON body (will be serialized)
+            data: Form data
+            headers: Request headers
+            cookies: Request cookies
+            timeout: Request timeout in seconds
+            **kwargs: Additional arguments passed to httpx
+
+        Returns:
+            AsyncAPIResponse with status_code, headers, text, content, json() method
+        """
+        url = self._build_url(path)
+        response = await self._client.request(
+            method,
+            url,
+            params=params,
+            json=json,
+            data=data,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            **kwargs,
+        )
+        return AsyncAPIResponse(response)
+
+    async def get(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> AsyncAPIResponse:
+        """Make a GET request."""
+        return await self.request("GET", path, params=params, headers=headers, **kwargs)
+
+    async def post(
+        self,
+        path: str,
+        *,
+        json: Optional[Any] = None,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> AsyncAPIResponse:
+        """Make a POST request."""
+        return await self.request(
+            "POST", path, json=json, data=data, params=params, headers=headers, **kwargs
+        )
+
+    async def put(
+        self,
+        path: str,
+        *,
+        json: Optional[Any] = None,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> AsyncAPIResponse:
+        """Make a PUT request."""
+        return await self.request(
+            "PUT", path, json=json, data=data, params=params, headers=headers, **kwargs
+        )
+
+    async def patch(
+        self,
+        path: str,
+        *,
+        json: Optional[Any] = None,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> AsyncAPIResponse:
+        """Make a PATCH request."""
+        return await self.request(
+            "PATCH", path, json=json, data=data, params=params, headers=headers, **kwargs
+        )
+
+    async def delete(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> AsyncAPIResponse:
+        """Make a DELETE request."""
+        return await self.request("DELETE", path, params=params, headers=headers, **kwargs)
+
+    async def head(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> AsyncAPIResponse:
+        """Make a HEAD request."""
+        return await self.request("HEAD", path, params=params, headers=headers, **kwargs)
+
+    async def options(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> AsyncAPIResponse:
+        """Make an OPTIONS request."""
+        return await self.request("OPTIONS", path, params=params, headers=headers, **kwargs)