fleet-python 0.2.11__tar.gz → 0.2.12__tar.gz

{fleet_python-0.2.11 → fleet_python-0.2.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.11
+Version: 0.2.12
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -23,6 +23,7 @@ License-File: LICENSE
 Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: httpx-retries>=0.4.0
 Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"

fleet_python-0.2.12/fleet/_async/base.py

@@ -0,0 +1,223 @@
+import httpx
+from typing import Dict, Any, Optional
+import json
+
+from .models import InstanceResponse
+from .exceptions import (
+    FleetAPIError,
+    FleetAuthenticationError,
+    FleetRateLimitError,
+    FleetInstanceLimitError,
+    FleetTimeoutError,
+    FleetTeamNotFoundError,
+    FleetEnvironmentAccessError,
+    FleetRegionError,
+    FleetEnvironmentNotFoundError,
+    FleetVersionNotFoundError,
+    FleetBadRequestError,
+    FleetPermissionError,
+)
+
+
+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://orchestrator.fleetai.com"
+        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,
+        base_url: Optional[str] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        base_url = base_url or self.base_url
+        try:
+            response = await self.httpx_client.request(
+                method,
+                f"{base_url}{url}",
+                headers=self.get_headers(),
+                params=params,
+                json=json,
+                **kwargs,
+            )
+
+            # Check for HTTP errors
+            if response.status_code >= 400:
+                self._handle_error_response(response)
+
+            return response
+        except httpx.TimeoutException as e:
+            raise FleetTimeoutError(f"Request timed out: {str(e)}")
+        except httpx.RequestError as e:
+            raise FleetAPIError(f"Request failed: {str(e)}")
+
+    def _handle_error_response(self, response: httpx.Response) -> None:
+        """Handle HTTP error responses and convert to appropriate Fleet exceptions."""
+        status_code = response.status_code
+
+        # Try to parse error response as JSON
+        try:
+            error_data = response.json()
+            detail = error_data.get("detail", response.text)
+
+            # Handle structured error responses
+            if isinstance(detail, dict):
+                error_type = detail.get("error_type", "")
+                error_message = detail.get("message", str(detail))
+
+                if error_type == "instance_limit_exceeded":
+                    raise FleetInstanceLimitError(
+                        error_message,
+                        running_instances=detail.get("running_instances"),
+                        instance_limit=detail.get("instance_limit"),
+                    )
+                else:
+                    error_message = detail.get("message", str(detail))
+            else:
+                error_message = detail
+
+        except (json.JSONDecodeError, ValueError):
+            error_message = response.text
+            error_data = None
+
+        # Handle specific error types
+        if status_code == 401:
+            raise FleetAuthenticationError(error_message)
+        elif status_code == 403:
+            # Handle 403 errors - instance limit, permissions, team not found
+            if "instance limit" in error_message.lower():
+                # Try to extract instance counts from the error message
+                running_instances = None
+                instance_limit = None
+                if (
+                    "You have" in error_message
+                    and "running instances out of a maximum of" in error_message
+                ):
+                    try:
+                        # Extract numbers from message like "You have 5 running instances out of a maximum of 10"
+                        parts = error_message.split("You have ")[1].split(
+                            " running instances out of a maximum of "
+                        )
+                        if len(parts) == 2:
+                            running_instances = int(parts[0])
+                            instance_limit = int(parts[1].split(".")[0])
+                    except (IndexError, ValueError):
+                        pass
+
+                raise FleetInstanceLimitError(
+                    error_message,
+                    running_instances=running_instances,
+                    instance_limit=instance_limit,
+                )
+            elif "team not found" in error_message.lower():
+                raise FleetTeamNotFoundError(error_message)
+            elif (
+                "does not have permission" in error_message.lower()
+                and "environment" in error_message.lower()
+            ):
+                # Extract environment key from error message if possible
+                env_key = None
+                if "'" in error_message:
+                    # Look for quoted environment key
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        env_key = parts[1]
+                raise FleetEnvironmentAccessError(error_message, env_key=env_key)
+            else:
+                raise FleetPermissionError(error_message)
+        elif status_code == 400:
+            # Handle 400 errors - bad requests, region errors, environment/version not found
+            if "region" in error_message.lower() and (
+                "not supported" in error_message.lower()
+                or "unsupported" in error_message.lower()
+            ):
+                # Extract region and supported regions if possible
+                region = None
+                supported_regions = []
+                if "Region" in error_message:
+                    # Try to extract region from "Region X not supported"
+                    try:
+                        parts = error_message.split("Region ")[1].split(
+                            " not supported"
+                        )
+                        if parts:
+                            region = parts[0]
+                    except (IndexError, ValueError):
+                        pass
+                    # Try to extract supported regions from "Please use [...]"
+                    if "Please use" in error_message and "[" in error_message:
+                        try:
+                            regions_str = error_message.split("[")[1].split("]")[0]
+                            supported_regions = [
+                                r.strip().strip("'\"") for r in regions_str.split(",")
+                            ]
+                        except (IndexError, ValueError):
+                            pass
+                raise FleetRegionError(
+                    error_message, region=region, supported_regions=supported_regions
+                )
+            elif (
+                "environment" in error_message.lower()
+                and "not found" in error_message.lower()
+            ):
+                # Extract env_key if possible
+                env_key = None
+                if "'" in error_message:
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        env_key = parts[1]
+                raise FleetEnvironmentNotFoundError(error_message, env_key=env_key)
+            elif (
+                "version" in error_message.lower()
+                and "not found" in error_message.lower()
+            ):
+                # Extract version and env_key if possible
+                version = None
+                env_key = None
+                if "'" in error_message:
+                    parts = error_message.split("'")
+                    if len(parts) >= 2:
+                        version = parts[1]
+                    if len(parts) >= 4:
+                        env_key = parts[3]
+                raise FleetVersionNotFoundError(
+                    error_message, version=version, env_key=env_key
+                )
+            else:
+                raise FleetBadRequestError(error_message)
+        elif status_code == 429:
+            # Rate limit errors (not instance limit which is now 403)
+            raise FleetRateLimitError(error_message)
+        else:
+            raise FleetAPIError(
+                error_message,
+                status_code=status_code,
+                response_data=error_data if "error_data" in locals() else None,
+            )

{fleet_python-0.2.11 → fleet_python-0.2.12}/fleet/_async/client.py

@@ -29,6 +29,8 @@ from .instance import (
     ValidatorType,
     ExecuteFunctionResponse,
 )
+from .config import DEFAULT_MAX_RETRIES, REGION_BASE_URL
+from .instance.base import default_httpx_client
 from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
 from .resources.browser import AsyncBrowserResource
@@ -37,15 +39,17 @@ logger = logging.getLogger(__name__)
 
 
 class AsyncEnvironment(EnvironmentBase):
-    def __init__(self, httpx_client: Optional[httpx.AsyncClient] = None, **kwargs):
+    def __init__(self, client: AsyncWrapper, **kwargs):
         super().__init__(**kwargs)
-        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=180.0)
+        self._client = client
         self._instance: Optional[AsyncInstanceClient] = None
 
     @property
     def instance(self) -> AsyncInstanceClient:
         if self._instance is None:
-            self._instance = AsyncInstanceClient(self.manager_url, self._httpx_client)
+            self._instance = AsyncInstanceClient(
+                self.manager_url, self._client.httpx_client
+            )
         return self._instance
 
     async def reset(
@@ -66,7 +70,10 @@ class AsyncEnvironment(EnvironmentBase):
         return await self.instance.resources()
 
     async def close(self) -> InstanceRecord:
-        return await AsyncFleet().delete(self.instance_id)
+        response = await self._client.request(
+            "DELETE", f"/v1/env/instances/{self.instance_id}"
+        )
+        return InstanceRecord(**response.json())
 
     async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return await self.instance.verify(validator)
@@ -83,8 +90,9 @@ class AsyncFleet:
         api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
         base_url: Optional[str] = None,
         httpx_client: Optional[httpx.AsyncClient] = None,
+        max_retries: int = DEFAULT_MAX_RETRIES,
     ):
-        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=180.0)
+        self._httpx_client = httpx_client or default_httpx_client(max_retries)
         self.client = AsyncWrapper(
             api_key=api_key,
             base_url=base_url,
@@ -115,10 +123,14 @@ class AsyncFleet:
             version = None
 
         request = InstanceRequest(env_key=env_key_part, version=version, region=region)
+        region_base_url = REGION_BASE_URL.get(region)
         response = await self.client.request(
-            "POST", "/v1/env/instances", json=request.model_dump()
+            "POST",
+            "/v1/env/instances",
+            json=request.model_dump(),
+            base_url=region_base_url,
         )
-        instance = AsyncEnvironment(**response.json())
+        instance = AsyncEnvironment(client=self.client, **response.json())
         await instance.instance.load()
         return instance
 
@@ -132,11 +144,14 @@ class AsyncFleet:
             params["region"] = region
 
         response = await self.client.request("GET", "/v1/env/instances", params=params)
-        return [AsyncEnvironment(**instance_data) for instance_data in response.json()]
+        return [
+            AsyncEnvironment(client=self.client, **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}")
-        instance = AsyncEnvironment(**response.json())
+        instance = AsyncEnvironment(client=self.client, **response.json())
         await instance.instance.load()
         return instance
 

fleet_python-0.2.12/fleet/_async/config.py

@@ -0,0 +1,8 @@
+DEFAULT_MAX_RETRIES = 5
+
+GLOBAL_BASE_URL = "https://orchestrator.fleetai.com"
+REGION_BASE_URL = {
+    "us-west-1": "https://us-west-1.fleetai.com",
+    "us-east-1": "https://us-east-1.fleetai.com",
+    "eu-west-2": "https://eu-west-2.fleetai.com",
+}

fleet_python-0.2.12/fleet/_async/exceptions.py

@@ -0,0 +1,161 @@
+"""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 FleetInstanceLimitError(FleetAPIError):
+    """Exception raised when team instance limit is exceeded."""
+
+    def __init__(
+        self,
+        message: str = "Instance limit exceeded",
+        running_instances: Optional[int] = None,
+        instance_limit: Optional[int] = None,
+    ):
+        super().__init__(message, status_code=403)
+        self.running_instances = running_instances
+        self.instance_limit = instance_limit
+
+
+class FleetBadRequestError(FleetAPIError):
+    """Exception raised for bad request errors (400)."""
+
+    def __init__(self, message: str, error_type: Optional[str] = None):
+        super().__init__(message, status_code=400)
+        self.error_type = error_type
+
+
+class FleetPermissionError(FleetAPIError):
+    """Exception raised when permission is denied (403)."""
+
+    def __init__(
+        self,
+        message: str,
+        resource_type: Optional[str] = None,
+        resource_id: Optional[str] = None,
+    ):
+        super().__init__(message, status_code=403)
+        self.resource_type = resource_type
+        self.resource_id = resource_id
+
+
+class FleetRegionError(FleetBadRequestError):
+    """Exception raised when an unsupported region is specified."""
+
+    def __init__(
+        self,
+        message: str,
+        region: Optional[str] = None,
+        supported_regions: Optional[list] = None,
+    ):
+        super().__init__(message, error_type="unsupported_region")
+        self.region = region
+        self.supported_regions = supported_regions or []
+
+
+class FleetEnvironmentNotFoundError(FleetBadRequestError):
+    """Exception raised when environment is not found."""
+
+    def __init__(self, message: str, env_key: Optional[str] = None):
+        super().__init__(message, error_type="environment_not_found")
+        self.env_key = env_key
+
+
+class FleetVersionNotFoundError(FleetBadRequestError):
+    """Exception raised when version is not found."""
+
+    def __init__(
+        self, message: str, env_key: Optional[str] = None, version: Optional[str] = None
+    ):
+        super().__init__(message, error_type="version_not_found")
+        self.env_key = env_key
+        self.version = version
+
+
+class FleetEnvironmentAccessError(FleetPermissionError):
+    """Exception raised when team doesn't have access to an environment."""
+
+    def __init__(
+        self, message: str, env_key: Optional[str] = None, version: Optional[str] = None
+    ):
+        super().__init__(message, resource_type="environment", resource_id=env_key)
+        self.env_key = env_key
+        self.version = version
+
+
+class FleetTeamNotFoundError(FleetPermissionError):
+    """Exception raised when team is not found."""
+
+    def __init__(self, message: str, team_id: Optional[str] = None):
+        super().__init__(message, resource_type="team", resource_id=team_id)
+        self.team_id = team_id
+
+
+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_python-0.2.11 → fleet_python-0.2.12}/fleet/_async/instance/base.py

@@ -1,7 +1,31 @@
 import httpx
+import httpx_retries
 from typing import Dict, Any, Optional
 
 
+def default_httpx_client(max_retries: int) -> httpx.AsyncClient:
+    policy = httpx_retries.Retry(
+        total=max_retries,
+        status_forcelist=[
+            404,
+            429,
+            500,
+            502,
+            503,
+            504,
+        ],
+        allowed_methods=["GET", "POST", "PATCH", "DELETE"],
+        backoff_factor=0.5,
+    )
+    retry = httpx_retries.RetryTransport(
+        transport=httpx.AsyncHTTPTransport(retries=2), retry=policy
+    )
+    return httpx.AsyncClient(
+        timeout=300.0,
+        transport=retry,
+    )
+
+
 class BaseWrapper:
     def __init__(self, *, url: str):
         self.url = url
@@ -34,4 +58,4 @@ class AsyncWrapper(BaseWrapper):
             params=params,
             json=json,
             **kwargs,
-        )
+        )

{fleet_python-0.2.11 → fleet_python-0.2.12}/fleet/_async/instance/client.py

@@ -1,7 +1,6 @@
 """Fleet SDK Instance Client."""
 
 from typing import Any, Callable, Dict, List, Optional, Tuple
-import asyncio
 import httpx
 import inspect
 import time
@@ -14,9 +13,10 @@ from ..resources.base import Resource
 
 from fleet.verifiers import DatabaseSnapshot
 
-from ..exceptions import FleetEnvironmentError, FleetAPIError
+from ..exceptions import FleetEnvironmentError
+from ..config import DEFAULT_MAX_RETRIES
 
-from .base import AsyncWrapper
+from .base import AsyncWrapper, default_httpx_client
 from .models import (
     ResetRequest,
     ResetResponse,
@@ -51,7 +51,7 @@ class AsyncInstanceClient:
         self.base_url = url
         self.client = AsyncWrapper(
             url=self.base_url,
-            httpx_client=httpx_client or httpx.AsyncClient(timeout=180.0),
+            httpx_client=httpx_client or default_httpx_client(DEFAULT_MAX_RETRIES),
         )
         self._resources: Optional[List[ResourceModel]] = None
         self._resources_state: Dict[str, Dict[str, Resource]] = {