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

fleet/base.py

@@ -9,6 +9,13 @@ from .exceptions import (
     FleetRateLimitError,
     FleetInstanceLimitError,
     FleetTimeoutError,
+    FleetTeamNotFoundError,
+    FleetEnvironmentAccessError,
+    FleetRegionError,
+    FleetEnvironmentNotFoundError,
+    FleetVersionNotFoundError,
+    FleetBadRequestError,
+    FleetPermissionError,
 )
 
 
@@ -47,86 +54,170 @@ class SyncWrapper(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 = 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/client.py

@@ -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 SQLiteResource
 from .resources.browser import BrowserResource
@@ -36,16 +38,23 @@ from .resources.browser import BrowserResource
 logger = logging.getLogger(__name__)
 
 
+def _delete_instance(client: SyncWrapper, instance_id: str) -> InstanceRecord:
+    response = client.request("DELETE", f"/v1/env/instances/{instance_id}")
+    return InstanceRecord(**response.json())
+
+
 class Environment(EnvironmentBase):
-    def __init__(self, httpx_client: Optional[httpx.Client] = None, **kwargs):
+    def __init__(self, client: SyncWrapper, **kwargs):
         super().__init__(**kwargs)
-        self._httpx_client = httpx_client or httpx.Client(timeout=180.0)
+        self._client = client
         self._instance: Optional[InstanceClient] = None
 
     @property
     def instance(self) -> InstanceClient:
         if self._instance is None:
-            self._instance = InstanceClient(self.manager_url, self._httpx_client)
+            self._instance = InstanceClient(
+                self.manager_url, self._client.httpx_client
+            )
         return self._instance
 
     def reset(
@@ -66,7 +75,7 @@ class Environment(EnvironmentBase):
         return self.instance.resources()
 
     def close(self) -> InstanceRecord:
-        return Fleet().delete(self.instance_id)
+        return _delete_instance(self._client, self.instance_id)
 
     def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return self.instance.verify(validator)
@@ -83,8 +92,10 @@ class Fleet:
         api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
         base_url: Optional[str] = None,
         httpx_client: Optional[httpx.Client] = None,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        timeout: float = DEFAULT_TIMEOUT,
     ):
-        self._httpx_client = httpx_client or httpx.Client(timeout=180.0)
+        self._httpx_client = httpx_client or default_httpx_client(max_retries, timeout)
         self.client = SyncWrapper(
             api_key=api_key,
             base_url=base_url,
@@ -95,6 +106,10 @@ class Fleet:
         response = self.client.request("GET", "/v1/env/")
         return [EnvironmentModel(**env_data) for env_data in response.json()]
 
+    def list_regions(self) -> List[str]:
+        response = self.client.request("GET", "/v1/regions")
+        return response.json()
+
     def environment(self, env_key: str) -> EnvironmentModel:
         response = self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
@@ -111,10 +126,14 @@ class Fleet:
             version = None
 
         request = InstanceRequest(env_key=env_key_part, version=version, region=region)
+        region_base_url = REGION_BASE_URL.get(region)
         response = 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 = Environment(**response.json())
+        instance = Environment(client=self.client, **response.json())
         instance.instance.load()
         return instance
 
@@ -128,16 +147,16 @@ class Fleet:
             params["region"] = region
 
         response = self.client.request("GET", "/v1/env/instances", params=params)
-        return [Environment(**instance_data) for instance_data in response.json()]
+        return [
+            Environment(client=self.client, **instance_data)
+            for instance_data in response.json()
+        ]
 
     def instance(self, instance_id: str) -> Environment:
         response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = Environment(**response.json())
+        instance = Environment(client=self.client, **response.json())
         instance.instance.load()
         return instance
 
     def delete(self, instance_id: str) -> InstanceRecord:
-        response = self.client.request(
-            "DELETE", f"/v1/env/instances/{instance_id}"
-        )
-        return InstanceRecord(**response.json())
+        return _delete_instance(self.client, instance_id)

fleet/config.py

@@ -0,0 +1,9 @@
+DEFAULT_MAX_RETRIES = 5
+DEFAULT_TIMEOUT = 300.0
+
+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/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/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.Client:
+    if max_retries <= 0:
+        return httpx.Client(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.HTTPTransport(retries=2), retry=policy
+    )
+    return httpx.Client(
+        timeout=timeout,
+        transport=retry,
+    )
+
+
 class BaseWrapper:
     def __init__(self, *, url: str):
         self.url = url
@@ -34,4 +61,4 @@ class SyncWrapper(BaseWrapper):
             params=params,
             json=json,
             **kwargs,
-        )
+        )

fleet/instance/client.py

@@ -13,9 +13,10 @@ from ..resources.base import Resource
 
 from ..verifiers import DatabaseSnapshot
 
-from ..exceptions import FleetEnvironmentError, FleetAPIError
+from ..exceptions import FleetEnvironmentError
+from ..config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
 
-from .base import SyncWrapper
+from .base import SyncWrapper, default_httpx_client
 from .models import (
     ResetRequest,
     ResetResponse,
@@ -50,7 +51,7 @@ class InstanceClient:
         self.base_url = url
         self.client = SyncWrapper(
             url=self.base_url,
-            httpx_client=httpx_client or httpx.Client(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_python-0.2.11.dist-info → fleet_python-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.11
+Version: 0.2.13
 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.11.dist-info → fleet_python-0.2.13.dist-info}/RECORD

@@ -1,7 +1,7 @@
 examples/dsl_example.py,sha256=3Eu5924a8x61nuSGXqGz8XjPLNKKH8Ye7lSYHSvixtk,5361
-examples/example.py,sha256=62rjLU3LdGEW9QJZjMP44Gtdjalv-6oRnClDFk67Oec,1089
+examples/example.py,sha256=SAz5iPxca8n9MvnHVoWHI7GCaTgJwkegX78rMutF9gE,1082
 examples/example_client.py,sha256=70HKEhz_Gb79YcvKQauCPdS08AAwjo9unt2dh1jN_Oo,1030
-examples/example_sync.py,sha256=_XaM3E0osxdt7AJQrJdtgE_I4-ChWuANQ5HIxCisbJk,983
+examples/example_sync.py,sha256=l8l-QOGTMnijiSK0mt5aofzXqbv-kKU3WCow4QS-7yg,976
 examples/gemini_example.py,sha256=8mDXGGCaodyK6uXgpWhxi-DQ5OA-GFW12Gfwh0b3EDY,16177
 examples/json_tasks_example.py,sha256=3ub2LLiC6hXpVEH1175QxCmfCD3Blfo3yoG85uV5CS8,5334
 examples/nova_act_example.py,sha256=hZLpObVsiXKQzqGwMZVMf4A2j_z4TYE-YO9pgNmaKPk,836
@@ -9,32 +9,31 @@ examples/openai_example.py,sha256=I2vk_SJN9BkSRQCYRJfbtGJ-HJ2xzQj-lOjwqmLos5M,82
 examples/openai_simple_example.py,sha256=I42ytIwv0INgDO39pp1MOQSqsJz2YYH8GeNNBaUtq3A,1748
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 fleet/__init__.py,sha256=-EFlLzHmyJIUGSZ4_XIts6OhXIXGPyu5PgI9JxgDzTg,2165
-fleet/base.py,sha256=0ZxYHuIW3e4BKA2jRK41IP2N6SiOcoQwmTqBM5Z236I,4876
-fleet/client.py,sha256=RDU7uJesgOERTnIIz4wSq6BP_uQuY_M9TSXrlr1-jbU,4921
-fleet/exceptions.py,sha256=UHKUYK5OSeyLj9bmIPXwdtBkDMpAzfD3uxnH4yuE6k8,2659
+fleet/base.py,sha256=E4gUv_eQEU4eSzTBy8gLGwl0s4t57OCTnsMYTKP3qI0,8782
+fleet/client.py,sha256=XT61Tnq9O4B8eF01X2fFQYD4twwyKUrEK1UJawvZbUo,5583
+fleet/config.py,sha256=9eWhJl81JinQJfZxD52t4Rgn5flnhhNqv2vGmddN2os,274
+fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
 fleet/playwright.py,sha256=BmRvez5DUa0ttAQB084hPAyt9_8WxdzCGBGF-GZbTuQ,8593
 fleet/_async/__init__.py,sha256=AJWCnuo7XKja4yBb8fK2wX7ntciLXQrpzdRHwjTRP6M,62
-fleet/_async/base.py,sha256=j6Pqo0disJU3Nl2dLOacL9_7pYBslm5puIzFgDU54zg,4894
-fleet/_async/client.py,sha256=Cs85F1J2j7t1dG-ldqTTQN_Sk0Ai7a5b7JiR0notmGY,5318
-fleet/_async/exceptions.py,sha256=UHKUYK5OSeyLj9bmIPXwdtBkDMpAzfD3uxnH4yuE6k8,2659
-fleet/_async/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
+fleet/_async/base.py,sha256=qXdaKthvrE4ZyELIapuFS63dHV6ulEYPDqddgK9qX1g,8801
+fleet/_async/client.py,sha256=2ETcEUmpAdRToaUPmM4YGOPRXWwxoC4E9iM1Zk5BMwY,5842
+fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/playwright.py,sha256=2r4ywuv2ZqT0Qu3-k8A7V4YijeAOHnN8HiqJreLEYGI,8924
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=lBLcuEeQ9B2JMp6xUPb7ANgBYl9XTJMoVaOzGW7s9Pk,784
-fleet/_async/instance/__init__.py,sha256=jIt-7EEJ0WM_ipheT_s0lniCbLei6yUdN0qQv1bMJ3E,524
-fleet/_async/instance/base.py,sha256=QgcCTHdcqhi5VQi6_a1uuR-uO2_2Z19-RwVPp1k266A,947
-fleet/_async/instance/client.py,sha256=XTQWCQ6QfTpmw4x8ctlWvvnkcO8fCYnYkzbPAgs2_U4,5654
-fleet/_async/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
+fleet/_async/env/client.py,sha256=niS4uL8WY9G_lKyDhCqF5IdasxZJ3OCiiiJ5AG8_2a4,785
+fleet/_async/instance/__init__.py,sha256=LC-1PGi8UyUHh4oQSyT9ZUg2K30a0gkhEytTf1vsKIU,535
+fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
+fleet/_async/instance/client.py,sha256=ZndvSeNxpdX8gIkLr7z6_IhKWDDxfcORtvq9evRIST0,5742
 fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
-fleet/_async/resources/browser.py,sha256=x11y4aKHogIEv83FByHtExerjV-cDWI3U62349Guq_Q,1368
-fleet/_async/resources/sqlite.py,sha256=sRiII_qJ8X6-FSemlBsXThz4ZPjkNy9wDT8g5UAz2XM,1501
+fleet/_async/resources/base.py,sha256=ZFx2I9L7px-Z8LvbPUZJtbtajpqUn1yS1NFbZZutP9Q,668
+fleet/_async/resources/browser.py,sha256=oldoSiymJ1lJkADhpUG81ViOBDNyppX1jSoEwe9-W94,1369
+fleet/_async/resources/sqlite.py,sha256=_haVOT97ai1N6etYT-ZnhjILYunjK6XFjs_t8Xb8o2o,1503
 fleet/env/__init__.py,sha256=yYk657kVDnMWYbuPS_2o0kpVC99AYD85o5WG1jCaWSY,531
 fleet/env/client.py,sha256=HwJ-xCg3oZMJ48nP9_EaHk4Rao-na9myPX9X5JxYMbo,644
 fleet/instance/__init__.py,sha256=Hr8xPPoqzKOViXZXWmaL6dQ7NOBn-GooTGzoIvGmiE4,514
-fleet/instance/base.py,sha256=U-qW1EQVBo6yvMpP1JeKiPRhCjZ3y3aTsYFhLPNOTtQ,929
-fleet/instance/client.py,sha256=6Qm81vjVD-7p6ZMx9gbJwLP2R1vkqRe6Drs89w4Tf7I,5468
+fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
+fleet/instance/client.py,sha256=GGBCf9Df1LxzwYXLPEbof-MJfGQs1BdZp7tvJR9Yi3I,5564
 fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
@@ -44,10 +43,10 @@ fleet/verifiers/__init__.py,sha256=mRMN8x0gDWFJ1MRLqdBtQw0gn_q8kDV3lMLyoiEf1yY,2
 fleet/verifiers/code.py,sha256=NJ4OLZnpqLkI1lXY7-5m2GuZklLxMzHUCnRMVyN2_OI,25
 fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
-fleet_python-0.2.11.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-scripts/fix_sync_imports.py,sha256=b7tRvShgOFqyildqs1qI-Io0gaHappykBI-PSWWqUwE,2941
+fleet_python-0.2.13.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scripts/fix_sync_imports.py,sha256=BIQfnaOoQ7bwR1c-pDqH9ifN47W1bwL7OafWVXZNkuA,4368
 scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
-fleet_python-0.2.11.dist-info/METADATA,sha256=YqTOlXvN7U-hE27MAL6j2sZuF9vC45kra-C6Mtgrp44,4322
-fleet_python-0.2.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.11.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.11.dist-info/RECORD,,
+fleet_python-0.2.13.dist-info/METADATA,sha256=JHCDePiOeKojRCtFXv7P4lVljs_pJyAl1alEjTabsA8,4358
+fleet_python-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.13.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.13.dist-info/RECORD,,