fleet-python 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

examples/example.py

@@ -16,7 +16,7 @@ async def main():
     print("Environments:", len(environments))
 
     # Create a new instance
-    env = await flt.env.make_async("hubspot:v1.2.7")
+    env = await flt.env.make_async("hubspot")
     print(f"New Instance: {env.instance_id} ({env.region})")
 
     response = await env.reset(seed=42)

examples/example_sync.py

@@ -15,7 +15,7 @@ def main():
     print("Instances:", len(instances))
 
     # Create a new instance
-    env = flt.env.make("hubspot:v1.2.7")
+    env = flt.env.make("hubspot")
     print("New Instance:", env.instance_id)
 
     response = env.reset(seed=42)

fleet/_async/base.py

@@ -2,13 +2,20 @@ import httpx
 from typing import Dict, Any, Optional
 import json
 
-from .models import InstanceResponse
+from ..models import InstanceResponse
 from .exceptions import (
     FleetAPIError,
     FleetAuthenticationError,
     FleetRateLimitError,
     FleetInstanceLimitError,
     FleetTimeoutError,
+    FleetTeamNotFoundError,
+    FleetEnvironmentAccessError,
+    FleetRegionError,
+    FleetEnvironmentNotFoundError,
+    FleetVersionNotFoundError,
+    FleetBadRequestError,
+    FleetPermissionError,
 )
 
 
@@ -47,86 +54,170 @@ class AsyncWrapper(BaseWrapper):
         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"{self.base_url}{url}",
+                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")
+                        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 == 429:
-            # Check if it's an instance limit error vs rate limit error (fallback for unstructured errors)
+        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:
+                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 ")
+                        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
+                    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 FleetRateLimitError(error_message)
+                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
-            )
+                response_data=error_data if "error_data" in locals() else None,
+            )

fleet/_async/client.py

@@ -20,7 +20,7 @@ import logging
 from typing import Optional, List
 
 from .base import EnvironmentBase, AsyncWrapper
-from .models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
+from ..models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
 
 from .instance import (
     AsyncInstanceClient,
@@ -29,6 +29,8 @@ from .instance import (
     ValidatorType,
     ExecuteFunctionResponse,
 )
+from ..config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT, 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
@@ -36,16 +38,23 @@ from .resources.browser import AsyncBrowserResource
 logger = logging.getLogger(__name__)
 
 
+async def _delete_instance(client: AsyncWrapper, instance_id: str) -> InstanceRecord:
+    response = await client.request("DELETE", f"/v1/env/instances/{instance_id}")
+    return InstanceRecord(**response.json())
+
+
 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 +75,7 @@ class AsyncEnvironment(EnvironmentBase):
         return await self.instance.resources()
 
     async def close(self) -> InstanceRecord:
-        return await AsyncFleet().delete(self.instance_id)
+        return await _delete_instance(self._client, self.instance_id)
 
     async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return await self.instance.verify(validator)
@@ -83,8 +92,10 @@ 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,
+        timeout: float = DEFAULT_TIMEOUT,
     ):
-        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=180.0)
+        self._httpx_client = httpx_client or default_httpx_client(max_retries, timeout)
         self.client = AsyncWrapper(
             api_key=api_key,
             base_url=base_url,
@@ -115,10 +126,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,16 +147,16 @@ 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
 
     async def delete(self, instance_id: str) -> InstanceRecord:
-        response = await self.client.request(
-            "DELETE", f"/v1/env/instances/{instance_id}"
-        )
-        return InstanceRecord(**response.json())
+        return await _delete_instance(self.client, instance_id)

fleet/_async/env/client.py

@@ -1,5 +1,5 @@
 from ..client import AsyncFleet, AsyncEnvironment
-from ..models import Environment as EnvironmentModel
+from ...models import Environment as EnvironmentModel
 from typing import List, Optional
 
 

fleet/_async/exceptions.py

@@ -5,7 +5,7 @@ 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
@@ -14,7 +14,7 @@ class FleetError(Exception):
 
 class FleetAPIError(FleetError):
     """Exception raised when Fleet API returns an error."""
-    
+
     def __init__(
         self,
         message: str,
@@ -29,7 +29,7 @@ class FleetAPIError(FleetError):
 
 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
@@ -37,30 +37,109 @@ class FleetTimeoutError(FleetError):
 
 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=429)
+
+    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
@@ -68,7 +147,7 @@ class FleetEnvironmentError(FleetError):
 
 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
@@ -76,7 +155,7 @@ class FleetFacetError(FleetError):
 
 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 
+        self.config_key = config_key

fleet/_async/instance/__init__.py

@@ -1,7 +1,7 @@
 """Fleet SDK Environment Module."""
 
 from .client import AsyncInstanceClient, ValidatorType
-from .models import (
+from ...instance.models import (
     ResetRequest,
     ResetResponse,
     CDPDescribeResponse,

fleet/_async/instance/base.py

@@ -1,7 +1,34 @@
 import httpx
+import httpx_retries
 from typing import Dict, Any, Optional
 
 
+def default_httpx_client(max_retries: int, timeout: float) -> httpx.AsyncClient:
+    if max_retries <= 0:
+        return httpx.AsyncClient(timeout=timeout)
+
+    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=timeout,
+        transport=retry,
+    )
+
+
 class BaseWrapper:
     def __init__(self, *, url: str):
         self.url = url
@@ -34,4 +61,4 @@ class AsyncWrapper(BaseWrapper):
             params=params,
             json=json,
             **kwargs,
-        )
+        )

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,10 +13,11 @@ 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, DEFAULT_TIMEOUT
 
-from .base import AsyncWrapper
-from .models import (
+from .base import AsyncWrapper, default_httpx_client
+from ...instance.models import (
     ResetRequest,
     ResetResponse,
     Resource as ResourceModel,
@@ -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, DEFAULT_TIMEOUT),
         )
         self._resources: Optional[List[ResourceModel]] = None
         self._resources_state: Dict[str, Dict[str, Resource]] = {

fleet/_async/resources/base.py

@@ -1,5 +1,5 @@
 from abc import ABC
-from ..instance.models import Resource as ResourceModel, ResourceType, ResourceMode
+from ...instance.models import Resource as ResourceModel, ResourceType, ResourceMode
 
 
 class Resource(ABC):

fleet/_async/resources/browser.py

@@ -1,5 +1,5 @@
 from typing import Optional
-from ..instance.models import (
+from ...instance.models import (
     Resource as ResourceModel,
     CDPDescribeResponse,
     ChromeStartRequest,

fleet/_async/resources/sqlite.py

@@ -1,6 +1,6 @@
 from typing import Any, List, Optional
-from ..instance.models import Resource as ResourceModel
-from ..instance.models import DescribeResponse, QueryRequest, QueryResponse
+from ...instance.models import Resource as ResourceModel
+from ...instance.models import DescribeResponse, QueryRequest, QueryResponse
 from .base import Resource
 
 from typing import TYPE_CHECKING