fleet-python 0.1.1__tar.gz → 0.2.0__tar.gz

{fleet_python-0.1.1/fleet_python.egg-info → fleet_python-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.1.1
+Version: 0.2.0
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -22,6 +22,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.8.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.27.0
 Requires-Dist: typing-extensions>=4.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"

fleet_python-0.2.0/examples/browser_control_example.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Example demonstrating browser control with Fleet Manager Client."""
+
+import asyncio
+import fleet as flt
+
+
+async def main():
+    fleet = flt.AsyncFleet()
+
+    environments = await fleet.list_envs()
+    print("Environments:", len(environments))
+
+    instances = await fleet.instances(status="running")
+    print("Instances:", len(instances))
+
+    instance = await fleet.instance("16fdbc96")
+    print("Instance:", instance.instance_id)
+    print("Instance Environment:", instance.env_key)
+
+    environment = await fleet.environment(instance.env_key)
+    print("Environment Default Version:", environment.default_version)
+
+    response = await instance.env.reset()
+    print("Reset response:", response)
+
+    print(await instance.env.resources())
+
+    sqlite = instance.env.sqlite("current")
+    print("SQLite:", await sqlite.describe())
+
+    print("Query:", await sqlite.query("SELECT * FROM users"))
+
+    sqlite = await instance.env.state("sqlite://current").describe()
+    print("SQLite:", sqlite)
+
+    browser = await instance.env.browser("cdp").describe()
+    print("CDP URL:", browser.url)
+    print("CDP Devtools URL:", browser.devtools_url)
+
+    # Create a new instance
+    instance = await fleet.make(flt.InstanceRequest(env_key=instance.env_key))
+    print("New Instance:", instance.instance_id)
+
+    # Delete the instance
+    instance = await fleet.delete(instance.instance_id)
+    print("Instance deleted:", instance.terminated_at)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fleet_python-0.1.1 → fleet_python-0.2.0}/fleet/__init__.py

@@ -14,11 +14,8 @@
 
 """Fleet Python SDK - Environment-based AI agent interactions."""
 
-from . import env
 from .exceptions import FleetError, FleetAPIError, FleetTimeoutError, FleetConfigurationError
-from .config import get_config, FleetConfig
-from .client import FleetAPIClient, InstanceRequest, InstanceResponse, EnvDetails as APIEnvironment, HealthResponse, ManagerURLs, InstanceURLs
-from .manager_client import FleetManagerClient, ManagerHealthResponse, TimestampResponse
+from .client import Fleet, AsyncFleet, InstanceRequest
 
 __version__ = "0.1.1"
 __all__ = [
@@ -27,16 +24,7 @@ __all__ = [
     "FleetAPIError", 
     "FleetTimeoutError",
     "FleetConfigurationError",
-    "get_config",
-    "FleetConfig",
-    "FleetAPIClient",
+    "Fleet",
+    "AsyncFleet",
     "InstanceRequest",
-    "InstanceResponse",
-    "APIEnvironment",
-    "HealthResponse",
-    "ManagerURLs",
-    "InstanceURLs",
-    "FleetManagerClient",
-    "ManagerHealthResponse",
-    "TimestampResponse",
 ] 

fleet_python-0.2.0/fleet/base.py

@@ -0,0 +1,74 @@
+import httpx
+from typing import Dict, Any, Optional
+
+from .models import InstanceResponse
+
+
+class InstanceBase(InstanceResponse):
+    @property
+    def manager_url(self) -> str:
+        return f"{self.urls.manager.api}"
+
+
+class BaseWrapper:
+    def __init__(self, *, api_key: Optional[str], base_url: Optional[str]):
+        if api_key is None:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        if base_url is None:
+            base_url = "https://fleet.new"
+        self.base_url = base_url
+
+    def get_headers(self) -> Dict[str, str]:
+        headers: Dict[str, str] = {
+            "X-Fleet-SDK-Language": "Python",
+            "X-Fleet-SDK-Version": "1.0.0",
+        }
+        headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+
+class SyncWrapper(BaseWrapper):
+    def __init__(self, *, httpx_client: httpx.Client, **kwargs):
+        super().__init__(**kwargs)
+        self.httpx_client = httpx_client
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        return self.httpx_client.request(
+            method,
+            f"{self.base_url}{url}",
+            headers=self.get_headers(),
+            params=params,
+            json=json,
+            **kwargs,
+        )
+
+
+class AsyncWrapper(BaseWrapper):
+    def __init__(self, *, httpx_client: httpx.AsyncClient, **kwargs):
+        super().__init__(**kwargs)
+        self.httpx_client = httpx_client
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        return await self.httpx_client.request(
+            method,
+            f"{self.base_url}{url}",
+            headers=self.get_headers(),
+            params=params,
+            json=json,
+            **kwargs,
+        )

fleet_python-0.2.0/fleet/client.py

@@ -0,0 +1,154 @@
+# Copyright 2025 Fleet AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Fleet API Client for making HTTP requests to Fleet services."""
+
+import asyncio
+import os
+import httpx
+import logging
+from typing import Optional, List
+
+from .base import InstanceBase, AsyncWrapper, SyncWrapper
+from .models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
+
+from .env import Environment, AsyncEnvironment
+
+logger = logging.getLogger(__name__)
+
+
+class Instance(InstanceBase):
+    def __init__(self, httpx_client: Optional[httpx.Client] = None, **kwargs):
+        super().__init__(**kwargs)
+        self._httpx_client = httpx_client or httpx.Client()
+        self._env: Optional[Environment] = None
+
+    @property
+    def env(self) -> Environment:
+        if self._env is None:
+            self._env = Environment(self.manager_url, self._httpx_client)
+        return self._env
+
+
+class AsyncInstance(InstanceBase):
+    def __init__(self, httpx_client: Optional[httpx.AsyncClient] = None, **kwargs):
+        super().__init__(**kwargs)
+        self._httpx_client = httpx_client or httpx.AsyncClient()
+        self._env: Optional[AsyncEnvironment] = None
+
+    @property
+    def env(self) -> AsyncEnvironment:
+        if self._env is None:
+            self._env = AsyncEnvironment(self.manager_url, self._httpx_client)
+        return self._env
+
+
+class Fleet:
+    def __init__(
+        self,
+        api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
+        base_url: Optional[str] = None,
+        httpx_client: Optional[httpx.Client] = None,
+    ):
+        self._httpx_client = httpx_client or httpx.Client(timeout=60.0)
+        self.client = SyncWrapper(
+            api_key=api_key,
+            base_url=base_url,
+            httpx_client=self._httpx_client,
+        )
+
+    def environments(self) -> List[EnvironmentModel]:
+        response = self.client.request("GET", "/v1/env/")
+        return [EnvironmentModel(**env_data) for env_data in response.json()]
+
+    def environment(self, env_key: str) -> EnvironmentModel:
+        response = self.client.request("GET", f"/v1/env/{env_key}")
+        return EnvironmentModel(**response.json())
+
+    def make(self, request: InstanceRequest) -> Instance:
+        response = self.client.request(
+            "POST", "/v1/env/instances", json=request.model_dump()
+        )
+        return Instance(**response.json())
+
+    def instances(self, status: Optional[str] = None) -> List[Instance]:
+        params = {}
+        if status:
+            params["status"] = status
+
+        response = self.client.request("GET", "/v1/env/instances", params=params)
+        return [Instance(**instance_data) for instance_data in response.json()]
+
+    def instance(self, instance_id: str) -> Instance:
+        response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
+        return Instance(**response.json())
+
+    def delete(self, instance_id: str) -> InstanceRecord:
+        response = self.client.request("DELETE", f"/v1/env/instances/{instance_id}")
+        return InstanceRecord(**response.json())
+
+
+class AsyncFleet:
+    def __init__(
+        self,
+        api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
+        base_url: Optional[str] = None,
+        httpx_client: Optional[httpx.AsyncClient] = None,
+    ):
+        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=60.0)
+        self.client = AsyncWrapper(
+            api_key=api_key,
+            base_url=base_url,
+            httpx_client=self._httpx_client,
+        )
+
+    async def list_envs(self) -> List[EnvironmentModel]:
+        response = await self.client.request("GET", "/v1/env/")
+        return [EnvironmentModel(**env_data) for env_data in response.json()]
+
+    async def environment(self, env_key: str) -> EnvironmentModel:
+        response = await self.client.request("GET", f"/v1/env/{env_key}")
+        return EnvironmentModel(**response.json())
+
+    async def make(self, request: InstanceRequest) -> AsyncInstance:
+        response = await self.client.request(
+            "POST", "/v1/env/instances", json=request.model_dump()
+        )
+        instance = AsyncInstance(**response.json())
+        await instance.env.load()
+        return instance
+
+    async def instances(self, status: Optional[str] = None) -> List[AsyncInstance]:
+        params = {}
+        if status:
+            params["status"] = status
+
+        response = await self.client.request("GET", "/v1/env/instances", params=params)
+        instances = [
+            AsyncInstance(**instance_data) for instance_data in response.json()
+        ]
+        await asyncio.gather(*[instance.env.load() for instance in instances])
+        return instances
+
+    async def instance(self, instance_id: str) -> AsyncInstance:
+        response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
+        instance = AsyncInstance(**response.json())
+        await instance.env.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())

fleet_python-0.2.0/fleet/env/__init__.py

@@ -0,0 +1,8 @@
+"""Fleet SDK Environment Module."""
+
+from .client import Environment, AsyncEnvironment
+
+__all__ = [
+    "Environment",
+    "AsyncEnvironment",
+]

fleet_python-0.2.0/fleet/env/base.py

@@ -0,0 +1,60 @@
+import httpx
+from typing import Dict, Any, Optional
+
+
+class BaseWrapper:
+    def __init__(self, *, url: str):
+        self.url = url
+
+    def get_headers(self) -> Dict[str, str]:
+        headers: Dict[str, str] = {
+            "X-Fleet-SDK-Language": "Python",
+            "X-Fleet-SDK-Version": "1.0.0",
+        }
+        return headers
+
+
+class SyncWrapper(BaseWrapper):
+    def __init__(self, *, httpx_client: httpx.Client, **kwargs):
+        super().__init__(**kwargs)
+        self.httpx_client = httpx_client
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        return self.httpx_client.request(
+            method,
+            f"{self.url}{path}",
+            headers=self.get_headers(),
+            params=params,
+            json=json,
+            **kwargs,
+        )
+
+
+class AsyncWrapper(BaseWrapper):
+    def __init__(self, *, httpx_client: httpx.AsyncClient, **kwargs):
+        super().__init__(**kwargs)
+        self.httpx_client = httpx_client
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        return await self.httpx_client.request(
+            method,
+            f"{self.url}{path}",
+            headers=self.get_headers(),
+            params=params,
+            json=json,
+            **kwargs,
+        )

fleet_python-0.2.0/fleet/env/client.py

@@ -0,0 +1,241 @@
+"""Fleet SDK Base Environment Classes."""
+
+from typing import Any, Dict, List, Optional, Tuple
+import asyncio
+import httpx
+import time
+import logging
+from urllib.parse import urlparse
+
+from ..resources.sqlite import AsyncSQLiteResource
+from ..resources.browser import AsyncBrowserResource
+from ..resources.base import Resource
+
+from ..exceptions import FleetEnvironmentError, FleetAPIError
+
+from .base import SyncWrapper, AsyncWrapper
+from .models import (
+    ResetResponse,
+    Resource as ResourceModel,
+    ResourceType,
+    HealthResponse,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+RESOURCE_TYPES = {
+    ResourceType.sqlite: AsyncSQLiteResource,
+    ResourceType.cdp: AsyncBrowserResource,
+}
+
+
+class Environment:
+    def __init__(
+        self,
+        url: str,
+        httpx_client: Optional[httpx.Client] = None,
+    ):
+        self.base_url = url
+        self.client = SyncWrapper(
+            url=self.base_url, httpx_client=httpx_client or httpx.Client()
+        )
+        raise NotImplementedError("SyncManager is not implemented")
+
+    def reset(self) -> ResetResponse:
+        response = self.client.request("POST", "/reset")
+        return ResetResponse(**response.json())
+
+
+class AsyncEnvironment:
+    def __init__(
+        self,
+        url: str,
+        httpx_client: Optional[httpx.AsyncClient] = None,
+    ):
+        self.base_url = url
+        self.client = AsyncWrapper(
+            url=self.base_url, httpx_client=httpx_client or httpx.AsyncClient()
+        )
+        self._resources: Optional[List[ResourceModel]] = None
+        self._resources_state: Dict[str, Dict[str, Resource]] = {
+            resource_type.value: {} for resource_type in ResourceType
+        }
+
+    async def load(self) -> None:
+        await self._load_resources()
+
+    async def reset(self) -> ResetResponse:
+        response = await self.client.request("POST", "/reset")
+        return ResetResponse(**response.json())
+
+    def state(self, uri: str) -> Resource:
+        url = urlparse(uri)
+        return self._resources_state[url.scheme][url.netloc]
+
+    def sqlite(self, name: str) -> AsyncSQLiteResource:
+        return AsyncSQLiteResource(
+            self._resources_state[ResourceType.sqlite.value][name], self.client
+        )
+
+    def browser(self, name: str) -> AsyncBrowserResource:
+        return AsyncBrowserResource(
+            self._resources_state[ResourceType.cdp.value][name], self.client
+        )
+
+    async def resources(self) -> List[ResourceModel]:
+        await self._load_resources()
+        return self._resources
+
+    async def _load_resources(self) -> None:
+        if self._resources is None:
+            response = await self.client.request("GET", "/resources")
+            if response.status_code != 200:
+                self._resources = []
+                return
+            data = response.json()
+            self._resources = [
+                ResourceModel(**resource) for resource in data["resources"]
+            ]
+            for resource in self._resources:
+                if resource.type not in self._resources_state:
+                    self._resources_state[resource.type.value] = {}
+                self._resources_state[resource.type.value][resource.name] = (
+                    RESOURCE_TYPES[resource.type](resource, self.client)
+                )
+
+    async def step(self, action: Dict[str, Any]) -> Tuple[Dict[str, Any], float, bool]:
+        """Execute one step in the environment."""
+        if not self._instance_id:
+            raise FleetEnvironmentError(
+                "Environment not initialized. Call reset() first."
+            )
+
+        try:
+            # Increment step count
+            self._increment_step()
+
+            # Execute action through instance manager API
+            # This is a placeholder - actual implementation depends on the manager API spec
+            state, reward, done = await self._execute_action(action)
+
+            return state, reward, done
+
+        except Exception as e:
+            raise FleetEnvironmentError(f"Failed to execute step: {e}")
+
+    async def close(self) -> None:
+        """Close the environment and clean up resources."""
+        try:
+            # Delete instance if it exists
+            if self._instance_id:
+                try:
+                    await self._client.delete_instance(self._instance_id)
+                    logger.info(f"Deleted instance: {self._instance_id}")
+                except FleetAPIError as e:
+                    logger.warning(f"Failed to delete instance: {e}")
+                finally:
+                    self._instance_id = None
+                    self._instance_response = None
+
+            # Close manager client
+            if self._manager_client:
+                await self._manager_client.close()
+                self._manager_client = None
+
+            # Close API client
+            await self._client.close()
+
+        except Exception as e:
+            logger.error(f"Error closing environment: {e}")
+
+    async def manager_health_check(self) -> Optional[HealthResponse]:
+        response = await self.client.request("GET", "/health")
+        return HealthResponse(**response.json())
+
+    async def _wait_for_instance_ready(self, timeout: float = 300.0) -> None:
+        """Wait for instance to be ready.
+
+        Args:
+            timeout: Maximum time to wait in seconds
+        """
+        start_time = time.time()
+
+        while time.time() - start_time < timeout:
+            try:
+                instance = await self._client.get_instance(self._instance_id)
+                self._instance_response = instance
+
+                if instance.status == "running":
+                    logger.info(f"Instance {self._instance_id} is ready")
+                    return
+
+                elif instance.status == "error":
+                    raise FleetEnvironmentError(
+                        f"Instance {self._instance_id} failed to start"
+                    )
+
+                # Wait before checking again
+                await asyncio.sleep(5)
+
+            except FleetAPIError as e:
+                if time.time() - start_time >= timeout:
+                    raise FleetEnvironmentError(
+                        f"Timeout waiting for instance to be ready: {e}"
+                    )
+                await asyncio.sleep(5)
+
+        raise FleetEnvironmentError(
+            f"Timeout waiting for instance {self._instance_id} to be ready"
+        )
+
+    async def _execute_action(
+        self, action: Dict[str, Any]
+    ) -> Tuple[Dict[str, Any], float, bool]:
+        """Execute an action through the instance manager API.
+
+        This is a placeholder implementation that should be extended based on
+        the actual manager API specification.
+
+        Args:
+            action: The action to execute as a dictionary
+
+        Returns:
+            Tuple of (state, reward, done)
+        """
+        # Ensure manager client is available
+        await self._ensure_manager_client()
+
+        # TODO: In the future, this would use the manager API to execute actions
+        # For example: await self._manager_client.log_action(action)
+        # For now, return placeholder values
+
+        # Create a placeholder state
+        state = self._create_state_from_action(action)
+
+        # Create a placeholder reward
+        reward = 0.0
+
+        # Determine if episode is done (placeholder logic)
+        done = self._step_count >= 100  # Example: done after 100 steps
+
+        return state, reward, done
+
+    def _create_state_from_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
+        """Create state based on executed action."""
+        return {
+            "instance_id": self._instance_id,
+            "step": self._step_count,
+            "last_action": action,
+            "timestamp": time.time(),
+            "status": "running",
+        }
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()