fleet-python 0.2.94__tar.gz → 0.2.96__tar.gz

{fleet_python-0.2.94/fleet_python.egg-info → fleet_python-0.2.96}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.94
+Version: 0.2.96
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/__init__.py

@@ -73,7 +73,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.93"
+__version__ = "0.2.96"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/_async/__init__.py

@@ -44,7 +44,7 @@ from ..types import VerifierFunction
 from .. import env
 from . import global_client as _async_global_client
 
-__version__ = "0.2.93"
+__version__ = "0.2.96"
 
 __all__ = [
     # Core classes

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/_async/base.py

@@ -26,7 +26,7 @@ from .exceptions import (
 try:
     from .. import __version__
 except ImportError:
-    __version__ = "0.2.93"
+    __version__ = "0.2.96"
 
 logger = logging.getLogger(__name__)
 

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/_async/client.py

@@ -172,6 +172,7 @@ from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
 from .resources.browser import AsyncBrowserResource
 from .resources.mcp import AsyncMCPResource
+from .resources.api import AsyncAPIResource
 
 logger = logging.getLogger(__name__)
 
@@ -385,6 +386,24 @@ class AsyncEnv(EnvironmentBase):
     def browser(self, name: str = "cdp") -> AsyncBrowserResource:
         return self.instance.browser(name)
 
+    def api(self, name: str = "api") -> AsyncAPIResource:
+        """Get an API resource for making HTTP requests to the app's API.
+
+        Args:
+            name: Name for the API resource (default: "api")
+
+        Returns:
+            AsyncAPIResource for making HTTP requests
+        """
+        # Use urls.api if available, otherwise fall back to urls.root + "/raw"
+        if self.urls and self.urls.api:
+            base_url = self.urls.api
+        elif self.urls and self.urls.root:
+            base_url = f"{self.urls.root.rstrip('/')}/raw"
+        else:
+            raise ValueError("No API URL configured for this environment")
+        return self.instance.api(name, base_url)
+
     @property
     def mcp(self) -> AsyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"

{fleet_python-0.2.94 → fleet_python-0.2.96}/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[
@@ -102,6 +105,29 @@ class AsyncInstanceClient:
             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 [

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/_async/models.py

@@ -120,6 +120,7 @@ class ResourceMode(Enum):
 class ResourceType(Enum):
     sqlite = "sqlite"
     cdp = "cdp"
+    api = "api"
 
 
 class RestoreRequest(BaseModel):

fleet_python-0.2.96/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)

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/_async/resources/sqlite.py

@@ -1417,9 +1417,35 @@ class AsyncSnapshotDiff:
         This version supports field-level specifications for added/removed rows,
         allowing users to specify expected field values instead of just whole-row specs.
         """
-        # Special case: empty allowed_changes means no changes should have occurred
-        if not allowed_changes:
-            return await self._expect_no_changes()
+        resource = self.after.resource
+        if resource.client is not None and resource._mode == "http":
+            api_diff = None
+            try:
+                payload = {}
+                if self.ignore_config:
+                    payload["ignore_config"] = {
+                        "tables": list(self.ignore_config.tables),
+                        "fields": list(self.ignore_config.fields),
+                        "table_fields": {
+                            table: list(fields) for table, fields in self.ignore_config.table_fields.items()
+                        }
+                    }
+                response = await resource.client.request(
+                    "POST",
+                    "/diff/structured",
+                    json=payload,
+                )
+                result = response.json()
+                if result.get("success") and "diff" in result:
+                    api_diff = result["diff"]
+            except Exception as e:
+                # Fall back to local diff if API call fails
+                print(f"Warning: Failed to fetch structured diff from API: {e}")
+                print("Falling back to local diff computation...")
+            
+            # Validate outside try block so AssertionError propagates
+            if api_diff is not None:
+                return await self._validate_diff_against_allowed_changes(api_diff, allowed_changes)
 
         # Fall back to full diff for v2 (no targeted optimization yet)
         diff = await self._collect()

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/base.py

@@ -27,7 +27,7 @@ from .exceptions import (
 try:
     from . import __version__
 except ImportError:
-    __version__ = "0.2.93"
+    __version__ = "0.2.96"
 
 logger = logging.getLogger(__name__)
 

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/client.py

@@ -178,6 +178,7 @@ from .resources.base import Resource
 from .resources.sqlite import SQLiteResource
 from .resources.browser import BrowserResource
 from .resources.mcp import SyncMCPResource
+from .resources.api import APIResource
 
 logger = logging.getLogger(__name__)
 
@@ -397,6 +398,24 @@ class SyncEnv(EnvironmentBase):
     def browser(self, name: str = "cdp") -> BrowserResource:
         return self.instance.browser(name)
 
+    def api(self, name: str = "api") -> APIResource:
+        """Get an API resource for making HTTP requests to the app's API.
+
+        Args:
+            name: Name for the API resource (default: "api")
+
+        Returns:
+            APIResource for making HTTP requests
+        """
+        # Use urls.api if available, otherwise fall back to urls.root + "/raw"
+        if self.urls and self.urls.api:
+            base_url = self.urls.api
+        elif self.urls and self.urls.root:
+            base_url = f"{self.urls.root.rstrip('/')}/raw"
+        else:
+            raise ValueError("No API URL configured for this environment")
+        return self.instance.api(name, base_url)
+
     @property
     def mcp(self) -> SyncMCPResource:
         mcp_url = f"{self.urls.root}mcp"

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/instance/client.py

@@ -9,6 +9,7 @@ from urllib.parse import urlparse
 
 from ..resources.sqlite import SQLiteResource
 from ..resources.browser import BrowserResource
+from ..resources.api import APIResource
 from ..resources.base import Resource
 
 from fleet.verifiers import DatabaseSnapshot
@@ -23,6 +24,7 @@ from .models import (
     ResetResponse,
     Resource as ResourceModel,
     ResourceType,
+    ResourceMode,
     HealthResponse,
     ExecuteFunctionRequest,
     ExecuteFunctionResponse,
@@ -35,6 +37,7 @@ logger = logging.getLogger(__name__)
 RESOURCE_TYPES = {
     ResourceType.db: SQLiteResource,
     ResourceType.cdp: BrowserResource,
+    ResourceType.api: APIResource,
 }
 
 ValidatorType = Callable[
@@ -100,6 +103,29 @@ class InstanceClient:
             self._resources_state[ResourceType.cdp.value][name], self.client
         )
 
+    def api(self, name: str, base_url: str) -> APIResource:
+        """
+        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 APIResource for making HTTP requests
+        """
+        # Create a minimal resource model for API
+        resource_model = ResourceModel(
+            name=name,
+            type=ResourceType.api,
+            mode=ResourceMode.rw,
+        )
+        return APIResource(
+            resource_model,
+            base_url=base_url,
+            client=self.client.httpx_client if self.client else None,
+        )
+
     def resources(self) -> List[Resource]:
         self._load_resources()
         return [

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/instance/models.py

@@ -91,6 +91,7 @@ class ResourceMode(Enum):
 class ResourceType(Enum):
     db = "sqlite"
     cdp = "cdp"
+    api = "api"
 
 
 class TableSchema(BaseModel):

fleet_python-0.2.96/fleet/resources/api.py

@@ -0,0 +1,200 @@
+"""API Resource for making HTTP requests to the app's API endpoint."""
+
+from typing import Any, Dict, Optional, Union
+import httpx
+
+from .base import Resource
+from ..instance.models import Resource as ResourceModel
+
+
+class APIResponse:
+    """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) -> "APIResponse":
+        """Raise an HTTPStatusError if the response has an error status code."""
+        self._response.raise_for_status()
+        return self
+
+    def __repr__(self) -> str:
+        return f"<APIResponse [{self.status_code}]>"
+
+
+class APIResource(Resource):
+    """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 = api.get("/users/1")
+        print(response.status_code)  # 200
+        print(response.json())       # {"id": 1, "name": "John"}
+
+        # With headers/auth
+        response = api.post(
+            "/users",
+            json={"name": "Jane"},
+            headers={"Authorization": "Bearer xxx"}
+        )
+    """
+
+    def __init__(
+        self,
+        resource: ResourceModel,
+        base_url: str,
+        client: Optional[httpx.Client] = None,
+    ):
+        super().__init__(resource)
+        self.base_url = base_url.rstrip("/")
+        self._client = client or httpx.Client()
+
+    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}"
+
+    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,
+    ) -> APIResponse:
+        """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:
+            APIResponse with status_code, headers, text, content, json() method
+        """
+        url = self._build_url(path)
+        response = self._client.request(
+            method,
+            url,
+            params=params,
+            json=json,
+            data=data,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            **kwargs,
+        )
+        return APIResponse(response)
+
+    def get(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> APIResponse:
+        """Make a GET request."""
+        return self.request("GET", path, params=params, headers=headers, **kwargs)
+
+    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,
+    ) -> APIResponse:
+        """Make a POST request."""
+        return self.request(
+            "POST", path, json=json, data=data, params=params, headers=headers, **kwargs
+        )
+
+    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,
+    ) -> APIResponse:
+        """Make a PUT request."""
+        return self.request(
+            "PUT", path, json=json, data=data, params=params, headers=headers, **kwargs
+        )
+
+    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,
+    ) -> APIResponse:
+        """Make a PATCH request."""
+        return self.request(
+            "PATCH", path, json=json, data=data, params=params, headers=headers, **kwargs
+        )
+
+    def delete(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> APIResponse:
+        """Make a DELETE request."""
+        return self.request("DELETE", path, params=params, headers=headers, **kwargs)
+
+    def head(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> APIResponse:
+        """Make a HEAD request."""
+        return self.request("HEAD", path, params=params, headers=headers, **kwargs)
+
+    def options(
+        self,
+        path: str,
+        *,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        **kwargs: Any,
+    ) -> APIResponse:
+        """Make an OPTIONS request."""
+        return self.request("OPTIONS", path, params=params, headers=headers, **kwargs)

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet/resources/sqlite.py

@@ -1439,9 +1439,35 @@ class SyncSnapshotDiff:
         This version supports field-level specifications for added/removed rows,
         allowing users to specify expected field values instead of just whole-row specs.
         """
-        # Special case: empty allowed_changes means no changes should have occurred
-        if not allowed_changes:
-            return self._expect_no_changes()
+        resource = self.after.resource
+        if resource.client is not None and resource._mode == "http":
+            api_diff = None
+            try:
+                payload = {}
+                if self.ignore_config:
+                    payload["ignore_config"] = {
+                        "tables": list(self.ignore_config.tables),
+                        "fields": list(self.ignore_config.fields),
+                        "table_fields": {
+                            table: list(fields) for table, fields in self.ignore_config.table_fields.items()
+                        }
+                    }
+                response = resource.client.request(
+                    "POST",
+                    "/diff/structured",
+                    json=payload,
+                )
+                result = response.json()
+                if result.get("success") and "diff" in result:
+                    api_diff = result["diff"]
+            except Exception as e:
+                # Fall back to local diff if API call fails
+                print(f"Warning: Failed to fetch structured diff from API: {e}")
+                print("Falling back to local diff computation...")
+            
+            # Validate outside try block so AssertionError propagates
+            if api_diff is not None:
+                return self._validate_diff_against_allowed_changes(api_diff, allowed_changes)
 
         # Fall back to full diff for v2 (no targeted optimization yet)
         diff = self._collect()

{fleet_python-0.2.94 → fleet_python-0.2.96/fleet_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.94
+Version: 0.2.96
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.94 → fleet_python-0.2.96}/fleet_python.egg-info/SOURCES.txt

@@ -49,6 +49,7 @@ fleet/_async/instance/__init__.py
 fleet/_async/instance/base.py
 fleet/_async/instance/client.py
 fleet/_async/resources/__init__.py
+fleet/_async/resources/api.py
 fleet/_async/resources/base.py
 fleet/_async/resources/browser.py
 fleet/_async/resources/mcp.py
@@ -81,6 +82,7 @@ fleet/proxy/__init__.py
 fleet/proxy/proxy.py
 fleet/proxy/whitelist.py
 fleet/resources/__init__.py
+fleet/resources/api.py
 fleet/resources/base.py
 fleet/resources/browser.py
 fleet/resources/mcp.py

{fleet_python-0.2.94 → fleet_python-0.2.96}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "fleet-python"
 
-version = "0.2.94"
+version = "0.2.96"
 description = "Python SDK for Fleet environments"
 authors = [
     {name = "Fleet AI", email = "nic@fleet.so"},