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

fleet/_async/base.py

@@ -0,0 +1,51 @@
+import httpx
+from typing import Dict, Any, Optional
+
+from .models import InstanceResponse
+
+
+class EnvironmentBase(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 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/_async/client.py

@@ -0,0 +1,133 @@
+# Copyright 2025 Fleet AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Fleet API Client for making HTTP requests to Fleet services."""
+
+import os
+import httpx
+import logging
+from typing import Optional, List
+
+from .base import EnvironmentBase, AsyncWrapper
+from .models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
+
+from .instance import (
+    AsyncInstanceClient,
+    ResetRequest,
+    ResetResponse,
+    ValidatorType,
+    ExecuteFunctionResponse,
+)
+from .resources.base import Resource
+from .resources.sqlite import AsyncSQLiteResource
+from .resources.browser import AsyncBrowserResource
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncEnvironment(EnvironmentBase):
+    def __init__(self, httpx_client: Optional[httpx.AsyncClient] = None, **kwargs):
+        super().__init__(**kwargs)
+        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=60.0)
+        self._instance: Optional[AsyncInstanceClient] = None
+
+    @property
+    def instance(self) -> AsyncInstanceClient:
+        if self._instance is None:
+            self._instance = AsyncInstanceClient(self.manager_url, self._httpx_client)
+        return self._instance
+
+    async def reset(
+        self, seed: Optional[int] = None, timestamp: Optional[int] = None
+    ) -> ResetResponse:
+        return await self.instance.reset(ResetRequest(seed=seed, timestamp=timestamp))
+
+    def db(self, name: str = "current") -> AsyncSQLiteResource:
+        return self.instance.db(name)
+
+    def browser(self, name: str = "cdp") -> AsyncBrowserResource:
+        return self.instance.browser(name)
+
+    def state(self, uri: str) -> Resource:
+        return self.instance.state(uri)
+
+    async def resources(self) -> List[Resource]:
+        return await self.instance.resources()
+
+    async def close(self) -> InstanceRecord:
+        return await AsyncFleet().delete(self.instance_id)
+
+    async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
+        return await self.instance.verify(validator)
+
+    async def verify_raw(
+        self, function_code: str, function_name: str
+    ) -> ExecuteFunctionResponse:
+        return await self.instance.verify_raw(function_code, function_name)
+
+
+class AsyncFleet:
+    def __init__(
+        self,
+        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, env_key: str) -> AsyncEnvironment:
+        if ":" in env_key:
+            env_key_part, version = env_key.split(":", 1)
+            if not version.startswith("v"):
+                version = f"v{version}"
+        else:
+            env_key_part = env_key
+            version = None
+
+        request = InstanceRequest(env_key=env_key_part, version=version)
+        response = await self.client.request(
+            "POST", "/v1/env/instances", json=request.model_dump()
+        )
+        instance = AsyncEnvironment(**response.json())
+        await instance.instance.load()
+        return instance
+
+    async def instances(self, status: Optional[str] = None) -> List[AsyncEnvironment]:
+        params = {}
+        if status:
+            params["status"] = status
+
+        response = await self.client.request("GET", "/v1/env/instances", params=params)
+        return [AsyncEnvironment(**instance_data) for instance_data in response.json()]
+
+    async def instance(self, instance_id: str) -> AsyncEnvironment:
+        response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
+        return AsyncEnvironment(**response.json())
+
+    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/_async/env/client.py

@@ -0,0 +1,15 @@
+from ..client import AsyncFleet, AsyncEnvironment
+from ..models import Environment as EnvironmentModel
+from typing import List
+
+
+async def make_async(env_key: str) -> AsyncEnvironment:
+    return await AsyncFleet().make(env_key)
+
+
+async def list_envs_async() -> List[EnvironmentModel]:
+    return await AsyncFleet().list_envs()
+
+
+async def get_async(instance_id: str) -> AsyncEnvironment:
+    return await AsyncFleet().instance(instance_id)

fleet/_async/exceptions.py

@@ -0,0 +1,73 @@
+"""Fleet SDK Exception Classes."""
+
+from typing import Any, Dict, Optional
+
+
+class FleetError(Exception):
+    """Base exception for all Fleet SDK errors."""
+    
+    def __init__(self, message: str, details: Optional[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+
+
+class FleetAPIError(FleetError):
+    """Exception raised when Fleet API returns an error."""
+    
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_data: Optional[Dict[str, Any]] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message, details)
+        self.status_code = status_code
+        self.response_data = response_data or {}
+
+
+class FleetTimeoutError(FleetError):
+    """Exception raised when a Fleet operation times out."""
+    
+    def __init__(self, message: str, timeout_duration: Optional[float] = None):
+        super().__init__(message)
+        self.timeout_duration = timeout_duration
+
+
+class FleetAuthenticationError(FleetAPIError):
+    """Exception raised when authentication fails."""
+    
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message, status_code=401)
+
+
+class FleetRateLimitError(FleetAPIError):
+    """Exception raised when rate limit is exceeded."""
+    
+    def __init__(self, message: str = "Rate limit exceeded"):
+        super().__init__(message, status_code=429)
+
+
+class FleetEnvironmentError(FleetError):
+    """Exception raised when environment operations fail."""
+    
+    def __init__(self, message: str, environment_id: Optional[str] = None):
+        super().__init__(message)
+        self.environment_id = environment_id
+
+
+class FleetFacetError(FleetError):
+    """Exception raised when facet operations fail."""
+    
+    def __init__(self, message: str, facet_type: Optional[str] = None):
+        super().__init__(message)
+        self.facet_type = facet_type
+
+
+class FleetConfigurationError(FleetError):
+    """Exception raised when configuration is invalid."""
+    
+    def __init__(self, message: str, config_key: Optional[str] = None):
+        super().__init__(message)
+        self.config_key = config_key 

fleet/{manager → _async/instance}/__init__.py

@@ -1,6 +1,6 @@
 """Fleet SDK Environment Module."""
 
-from .client import InstanceClient, AsyncInstanceClient
+from .client import AsyncInstanceClient, ValidatorType
 from .models import (
     ResetRequest,
     ResetResponse,
@@ -8,10 +8,11 @@ from .models import (
     ChromeStartRequest,
     ChromeStartResponse,
     ChromeStatusResponse,
+    ExecuteFunctionResponse,
 )
 
 __all__ = [
-    "InstanceClient",
+    "ValidatorType",
     "AsyncInstanceClient",
     "ResetRequest",
     "ResetResponse",
@@ -19,4 +20,5 @@ __all__ = [
     "ChromeStartRequest",
     "ChromeStartResponse",
     "ChromeStatusResponse",
+    "ExecuteFunctionResponse"
 ]

fleet/{manager → _async/instance}/base.py

@@ -14,29 +14,6 @@ class BaseWrapper:
         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,
-        path: str,
-        params: Optional[Dict[str, Any]] = None,
-        json: Optional[Any] = None,
-        **kwargs,
-    ) -> httpx.Response:
-        return self.httpx_client.request(
-            method,
-            f"{self.url}{path}",
-            headers=self.get_headers(),
-            params=params,
-            json=json,
-            **kwargs,
-        )
-
-
 class AsyncWrapper(BaseWrapper):
     def __init__(self, *, httpx_client: httpx.AsyncClient, **kwargs):
         super().__init__(**kwargs)
@@ -57,4 +34,4 @@ class AsyncWrapper(BaseWrapper):
             params=params,
             json=json,
             **kwargs,
-        )
+        )

fleet/{manager → _async/instance}/client.py

@@ -1,8 +1,9 @@
-"""Fleet SDK Base Environment Classes."""
+"""Fleet SDK Async Instance Client."""
 
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 import asyncio
 import httpx
+import inspect
 import time
 import logging
 from urllib.parse import urlparse
@@ -11,15 +12,19 @@ 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 SyncWrapper, AsyncWrapper
+from .base import AsyncWrapper
 from .models import (
     ResetRequest,
     ResetResponse,
     Resource as ResourceModel,
     ResourceType,
     HealthResponse,
+    ExecuteFunctionRequest,
+    ExecuteFunctionResponse,
 )
 
 
@@ -31,22 +36,10 @@ RESOURCE_TYPES = {
     ResourceType.cdp: AsyncBrowserResource,
 }
 
-
-class InstanceClient:
-    def __init__(
-        self,
-        url: str,
-        httpx_client: Optional[httpx.Client] = None,
-    ):
-        self.base_url = url
-        self.client = SyncWrapper(
-            url=self.base_url, httpx_client=httpx_client or httpx.Client()
-        )
-        raise NotImplementedError("SyncManager is not implemented")
-
-    def reset(self) -> ResetResponse:
-        response = self.client.request("POST", "/reset")
-        return ResetResponse(**response.json())
+ValidatorType = Callable[
+    [DatabaseSnapshot, DatabaseSnapshot, Optional[str]],
+    int,
+]
 
 
 class AsyncInstanceClient:
@@ -57,7 +50,8 @@ class AsyncInstanceClient:
     ):
         self.base_url = url
         self.client = AsyncWrapper(
-            url=self.base_url, httpx_client=httpx_client or httpx.AsyncClient()
+            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]] = {
@@ -106,15 +100,41 @@ class AsyncInstanceClient:
             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
-            self._resources = [
-                ResourceModel(**resource) for resource in response.json()
-            ]
+
+            # 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] = {}
@@ -255,4 +275,4 @@ class AsyncInstanceClient:
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
-        await self.close()
+        await self.close()

fleet/{manager → _async/instance}/models.py

@@ -126,3 +126,16 @@ class Resource(BaseModel):
     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