fleet-python 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

fleet/client.py

@@ -20,38 +20,76 @@ import httpx
 import logging
 from typing import Optional, List
 
-from .base import InstanceBase, AsyncWrapper, SyncWrapper
+from .base import EnvironmentBase, AsyncWrapper, SyncWrapper
 from .models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
 
-from .env import Environment, AsyncEnvironment
+from .instance import (
+    InstanceClient,
+    AsyncInstanceClient,
+    ResetRequest,
+    ResetResponse,
+    ValidatorType,
+    ExecuteFunctionResponse,
+)
+from .resources.base import Resource
+from .resources.sqlite import AsyncSQLiteResource
+from .resources.browser import AsyncBrowserResource
 
 logger = logging.getLogger(__name__)
 
 
-class Instance(InstanceBase):
+class Environment(EnvironmentBase):
     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
+        self._instance: Optional[InstanceClient] = None
 
     @property
-    def env(self) -> Environment:
-        if self._env is None:
-            self._env = Environment(self.manager_url, self._httpx_client)
-        return self._env
+    def instance(self) -> InstanceClient:
+        if self._instance is None:
+            self._instance = InstanceClient(self.manager_url, self._httpx_client)
+        return self._instance
 
 
-class AsyncInstance(InstanceBase):
+class AsyncEnvironment(EnvironmentBase):
     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
+        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=60.0)
+        self._instance: Optional[AsyncInstanceClient] = None
 
     @property
-    def env(self) -> AsyncEnvironment:
-        if self._env is None:
-            self._env = AsyncEnvironment(self.manager_url, self._httpx_client)
-        return self._env
+    def instance(self) -> AsyncInstanceClient:
+        if self._instance is None:
+            self._instance = AsyncInstanceClient(self.manager_url, self._httpx_client)
+        return self._instance
+
+    async def reset(
+        self, seed: Optional[int] = None, timestamp: Optional[int] = None
+    ) -> ResetResponse:
+        return await self.instance.reset(ResetRequest(seed=seed, timestamp=timestamp))
+
+    def db(self, name: str = "current") -> AsyncSQLiteResource:
+        return self.instance.db(name)
+
+    def browser(self, name: str = "cdp") -> AsyncBrowserResource:
+        return self.instance.browser(name)
+
+    def state(self, uri: str) -> Resource:
+        return self.instance.state(uri)
+
+    async def resources(self) -> List[Resource]:
+        return await self.instance.resources()
+
+    async def close(self) -> InstanceRecord:
+        return await AsyncFleet().delete(self.instance_id)
+
+    async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
+        return await self.instance.verify(validator)
+
+    async def verify_raw(
+        self, function_code: str, function_name: str
+    ) -> ExecuteFunctionResponse:
+        return await self.instance.verify_raw(function_code, function_name)
 
 
 class Fleet:
@@ -76,23 +114,23 @@ class Fleet:
         response = self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    def make(self, request: InstanceRequest) -> Instance:
+    def make(self, request: InstanceRequest) -> Environment:
         response = self.client.request(
             "POST", "/v1/env/instances", json=request.model_dump()
         )
-        return Instance(**response.json())
+        return Environment(**response.json())
 
-    def instances(self, status: Optional[str] = None) -> List[Instance]:
+    def instances(self, status: Optional[str] = None) -> List[Environment]:
         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()]
+        return [Environment(**instance_data) for instance_data in response.json()]
 
-    def instance(self, instance_id: str) -> Instance:
+    def instance(self, instance_id: str) -> Environment:
         response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        return Instance(**response.json())
+        return Environment(**response.json())
 
     def delete(self, instance_id: str) -> InstanceRecord:
         response = self.client.request("DELETE", f"/v1/env/instances/{instance_id}")
@@ -121,30 +159,39 @@ class AsyncFleet:
         response = await self.client.request("GET", f"/v1/env/{env_key}")
         return EnvironmentModel(**response.json())
 
-    async def make(self, request: InstanceRequest) -> AsyncInstance:
+    async def make(self, env_key: str) -> AsyncEnvironment:
+        if ":" in env_key:
+            env_key_part, version = env_key.split(":", 1)
+            if not version.startswith("v"):
+                version = f"v{version}"
+        else:
+            env_key_part = env_key
+            version = None
+
+        request = InstanceRequest(env_key=env_key_part, version=version)
         response = await self.client.request(
             "POST", "/v1/env/instances", json=request.model_dump()
         )
-        instance = AsyncInstance(**response.json())
-        await instance.env.load()
+        instance = AsyncEnvironment(**response.json())
+        await instance.instance.load()
         return instance
 
-    async def instances(self, status: Optional[str] = None) -> List[AsyncInstance]:
+    async def instances(self, status: Optional[str] = None) -> List[AsyncEnvironment]:
         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()
+            AsyncEnvironment(**instance_data) for instance_data in response.json()
         ]
-        await asyncio.gather(*[instance.env.load() for instance in instances])
+        await asyncio.gather(*[instance.instance.load() for instance in instances])
         return instances
 
-    async def instance(self, instance_id: str) -> AsyncInstance:
+    async def instance(self, instance_id: str) -> AsyncEnvironment:
         response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = AsyncInstance(**response.json())
-        await instance.env.load()
+        instance = AsyncEnvironment(**response.json())
+        await instance.instance.load()
         return instance
 
     async def delete(self, instance_id: str) -> InstanceRecord:

fleet/env/__init__.py

@@ -1,22 +1,3 @@
-"""Fleet SDK Environment Module."""
+from .client import make, list_envs, get
 
-from .client import Environment, AsyncEnvironment
-from .models import (
-    ResetRequest,
-    ResetResponse,
-    CDPDescribeResponse,
-    ChromeStartRequest,
-    ChromeStartResponse,
-    ChromeStatusResponse,
-)
-
-__all__ = [
-    "Environment",
-    "AsyncEnvironment",
-    "ResetRequest",
-    "ResetResponse",
-    "CDPDescribeResponse",
-    "ChromeStartRequest",
-    "ChromeStartResponse",
-    "ChromeStatusResponse",
-]
+__all__ = ["make", "list_envs", "get"]

fleet/env/client.py

@@ -1,259 +1,15 @@
-"""Fleet SDK Base Environment Classes."""
+from ..client import AsyncFleet, AsyncEnvironment
+from ..models import Environment as EnvironmentModel
+from typing import List
 
-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
+async def make(env_key: str) -> AsyncEnvironment:
+    return await AsyncFleet().make(env_key)
 
-from ..exceptions import FleetEnvironmentError, FleetAPIError
 
-from .base import SyncWrapper, AsyncWrapper
-from .models import (
-    ResetRequest,
-    ResetResponse,
-    Resource as ResourceModel,
-    ResourceType,
-    HealthResponse,
-)
+async def list_envs() -> List[EnvironmentModel]:
+    return await AsyncFleet().list_envs()
 
 
-logger = logging.getLogger(__name__)
-
-
-RESOURCE_TYPES = {
-    ResourceType.db: 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, reset_request: Optional[ResetRequest] = None
-    ) -> ResetResponse:
-        response = await self.client.request(
-            "POST", "/reset", json=reset_request.model_dump() if reset_request else None
-        )
-        return ResetResponse(**response.json())
-
-    def state(self, uri: str) -> Resource:
-        url = urlparse(uri)
-        return self._resources_state[url.scheme][url.netloc]
-
-    def db(self, name: str) -> AsyncSQLiteResource:
-        """
-        Returns an AsyncSQLiteResource object for the given SQLite database name.
-
-        Args:
-            name: The name of the SQLite database to return
-
-        Returns:
-            An AsyncSQLiteResource object for the given SQLite database name
-        """
-        return AsyncSQLiteResource(
-            self._resources_state[ResourceType.db.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[Resource]:
-        await self._load_resources()
-        return [
-            resource
-            for resources_by_name in self._resources_state.values()
-            for resource in resources_by_name.values()
-        ]
-
-    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
-            print(response.json())
-            self._resources = [
-                ResourceModel(**resource) for resource in response.json()
-            ]
-            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()
+async def get(instance_id: str) -> AsyncEnvironment:
+    return await AsyncFleet().instance(instance_id)

fleet/instance/__init__.py

@@ -0,0 +1,25 @@
+"""Fleet SDK Environment Module."""
+
+from .client import InstanceClient, AsyncInstanceClient, ValidatorType
+from .models import (
+    ResetRequest,
+    ResetResponse,
+    CDPDescribeResponse,
+    ChromeStartRequest,
+    ChromeStartResponse,
+    ChromeStatusResponse,
+    ExecuteFunctionResponse,
+)
+
+__all__ = [
+    "ValidatorType",
+    "InstanceClient",
+    "AsyncInstanceClient",
+    "ResetRequest",
+    "ResetResponse",
+    "CDPDescribeResponse",
+    "ChromeStartRequest",
+    "ChromeStartResponse",
+    "ChromeStatusResponse",
+    "ExecuteFunctionResponse"
+]