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

fleet/instance/__init__.py

@@ -1,6 +1,7 @@
 """Fleet SDK Environment Module."""
 
-from .client import InstanceClient, AsyncInstanceClient, ValidatorType
+from .client import InstanceClient, ValidatorType
+from .._async.instance.client import AsyncInstanceClient
 from .models import (
     ResetRequest,
     ResetResponse,
@@ -22,4 +23,4 @@ __all__ = [
     "ChromeStartResponse",
     "ChromeStatusResponse",
     "ExecuteFunctionResponse"
-]
+]

fleet/instance/base.py

@@ -34,27 +34,4 @@ class SyncWrapper(BaseWrapper):
             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/instance/client.py

@@ -1,4 +1,4 @@
-"""Fleet SDK Base Environment Classes."""
+"""Fleet SDK Async Instance Client."""
 
 from typing import Any, Callable, Dict, List, Optional, Tuple
 import asyncio
@@ -8,15 +8,15 @@ import time
 import logging
 from urllib.parse import urlparse
 
-from ..resources.sqlite import AsyncSQLiteResource
-from ..resources.browser import AsyncBrowserResource
+from ..resources.sqlite import SQLiteResource
+from ..resources.browser import BrowserResource
 from ..resources.base import Resource
 
 from ..verifiers import DatabaseSnapshot
 
 from ..exceptions import FleetEnvironmentError, FleetAPIError
 
-from .base import SyncWrapper, AsyncWrapper
+from .base import SyncWrapper
 from .models import (
     ResetRequest,
     ResetResponse,
@@ -32,8 +32,8 @@ logger = logging.getLogger(__name__)
 
 
 RESOURCE_TYPES = {
-    ResourceType.db: AsyncSQLiteResource,
-    ResourceType.cdp: AsyncBrowserResource,
+    ResourceType.db: SQLiteResource,
+    ResourceType.cdp: BrowserResource,
 }
 
 ValidatorType = Callable[
@@ -50,38 +50,21 @@ class InstanceClient:
     ):
         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 AsyncInstanceClient:
-    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(timeout=60.0),
+            httpx_client=httpx_client or httpx.Client(timeout=60.0),
         )
         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()
+    def load(self) -> None:
+        self._load_resources()
 
-    async def reset(
+    def reset(
         self, reset_request: Optional[ResetRequest] = None
     ) -> ResetResponse:
-        response = await self.client.request(
+        response = self.client.request(
             "POST", "/reset", json=reset_request.model_dump() if reset_request else None
         )
         return ResetResponse(**response.json())
@@ -90,7 +73,7 @@ class AsyncInstanceClient:
         url = urlparse(uri)
         return self._resources_state[url.scheme][url.netloc]
 
-    def db(self, name: str) -> AsyncSQLiteResource:
+    def db(self, name: str) -> SQLiteResource:
         """
         Returns an AsyncSQLiteResource object for the given SQLite database name.
 
@@ -100,32 +83,32 @@ class AsyncInstanceClient:
         Returns:
             An AsyncSQLiteResource object for the given SQLite database name
         """
-        return AsyncSQLiteResource(
+        return SQLiteResource(
             self._resources_state[ResourceType.db.value][name], self.client
         )
 
-    def browser(self, name: str) -> AsyncBrowserResource:
-        return AsyncBrowserResource(
+    def browser(self, name: str) -> BrowserResource:
+        return BrowserResource(
             self._resources_state[ResourceType.cdp.value][name], self.client
         )
 
-    async def resources(self) -> List[Resource]:
-        await self._load_resources()
+    def resources(self) -> List[Resource]:
+        self._load_resources()
         return [
             resource
             for resources_by_name in self._resources_state.values()
             for resource in resources_by_name.values()
         ]
 
-    async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
+    def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         function_code = inspect.getsource(validator)
         function_name = validator.__name__
-        return await self.verify_raw(function_code, function_name)
+        return self.verify_raw(function_code, function_name)
 
-    async def verify_raw(
+    def verify_raw(
         self, function_code: str, function_name: str
     ) -> ExecuteFunctionResponse:
-        response = await self.client.request(
+        response = self.client.request(
             "POST",
             "/execute_verifier_function",
             json=ExecuteFunctionRequest(
@@ -135,9 +118,9 @@ class AsyncInstanceClient:
         )
         return ExecuteFunctionResponse(**response.json())
 
-    async def _load_resources(self) -> None:
+    def _load_resources(self) -> None:
         if self._resources is None:
-            response = await self.client.request("GET", "/resources")
+            response = self.client.request("GET", "/resources")
             if response.status_code != 200:
                 self._resources = []
                 return
@@ -159,7 +142,7 @@ class AsyncInstanceClient:
                     RESOURCE_TYPES[resource.type](resource, self.client)
                 )
 
-    async def step(self, action: Dict[str, Any]) -> Tuple[Dict[str, Any], float, bool]:
+    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(
@@ -172,20 +155,20 @@ class AsyncInstanceClient:
 
             # 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)
+            state, reward, done = 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:
+    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)
+                    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}")
@@ -195,20 +178,20 @@ class AsyncInstanceClient:
 
             # Close manager client
             if self._manager_client:
-                await self._manager_client.close()
+                self._manager_client.close()
                 self._manager_client = None
 
             # Close API client
-            await self._client.close()
+            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")
+    def manager_health_check(self) -> Optional[HealthResponse]:
+        response = self.client.request("GET", "/health")
         return HealthResponse(**response.json())
 
-    async def _wait_for_instance_ready(self, timeout: float = 300.0) -> None:
+    def _wait_for_instance_ready(self, timeout: float = 300.0) -> None:
         """Wait for instance to be ready.
 
         Args:
@@ -218,7 +201,7 @@ class AsyncInstanceClient:
 
         while time.time() - start_time < timeout:
             try:
-                instance = await self._client.get_instance(self._instance_id)
+                instance = self._client.get_instance(self._instance_id)
                 self._instance_response = instance
 
                 if instance.status == "running":
@@ -231,20 +214,20 @@ class AsyncInstanceClient:
                     )
 
                 # Wait before checking again
-                await asyncio.sleep(5)
+                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)
+                asyncio.sleep(5)
 
         raise FleetEnvironmentError(
             f"Timeout waiting for instance {self._instance_id} to be ready"
         )
 
-    async def _execute_action(
+    def _execute_action(
         self, action: Dict[str, Any]
     ) -> Tuple[Dict[str, Any], float, bool]:
         """Execute an action through the instance manager API.
@@ -259,7 +242,7 @@ class AsyncInstanceClient:
             Tuple of (state, reward, done)
         """
         # Ensure manager client is available
-        await self._ensure_manager_client()
+        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)
@@ -286,10 +269,10 @@ class AsyncInstanceClient:
             "status": "running",
         }
 
-    async def __aenter__(self):
+    def __enter__(self):
         """Async context manager entry."""
         return self
 
-    async def __aexit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
-        await self.close()
+        self.close()

fleet/playwright.py

@@ -1,7 +1,7 @@
 import base64
 from typing import List, Dict, Any
-from playwright.async_api import async_playwright, Browser, Page
-from .client import AsyncEnvironment
+from playwright.sync_api import sync_playwright, Browser, Page
+from .client import Environment
 
 
 # Key mapping for computer use actions
@@ -65,7 +65,7 @@ class FleetPlaywrightWrapper:
 
     def __init__(
         self,
-        env: AsyncEnvironment,
+        env: Environment,
         display_width: int = 1920,
         display_height: int = 1080,
     ):
@@ -86,35 +86,33 @@ class FleetPlaywrightWrapper:
         self._page: Page | None = None
         self._started = False
 
-    async def start(self):
+    def start(self):
         """Start the browser and establish connection."""
         if self._started:
             return
 
         # Start Playwright
-        self._playwright = await async_playwright().start()
+        self._playwright = sync_playwright().start()
 
         # Start browser on the Fleet instance
         print("Starting browser...")
-        await self.env.browser().start()
-        cdp = await self.env.browser().describe()
+        self.env.browser().start()
+        cdp = self.env.browser().describe()
 
         # Connect to browser
-        self._browser = await self._playwright.chromium.connect_over_cdp(
-            cdp.cdp_browser_url
-        )
+        self._browser = self._playwright.chromium.connect_over_cdp(cdp.cdp_browser_url)
         self._page = self._browser.contexts[0].pages[0]
-        await self._page.set_viewport_size(
+        self._page.set_viewport_size(
             {"width": self.display_width, "height": self.display_height}
         )
 
         self._started = True
         print(f"Track agent: {cdp.cdp_devtools_url}")
 
-    async def close(self):
+    def close(self):
         """Close the browser connection."""
         if self._playwright:
-            await self._playwright.stop()
+            self._playwright.stop()
             self._playwright = None
             self._browser = None
             self._page = None
@@ -140,7 +138,7 @@ class FleetPlaywrightWrapper:
             "environment": "browser",
         }
 
-    async def screenshot(self) -> str:
+    def screenshot(self) -> str:
         """
         Take a screenshot and return base64 encoded string.
 
@@ -149,7 +147,7 @@ class FleetPlaywrightWrapper:
         """
         self._ensure_started()
 
-        png_bytes = await self._page.screenshot(full_page=False)
+        png_bytes = self._page.screenshot(full_page=False)
         return base64.b64encode(png_bytes).decode("utf-8")
 
     def get_current_url(self) -> str:
@@ -157,7 +155,7 @@ class FleetPlaywrightWrapper:
         self._ensure_started()
         return self._page.url
 
-    async def execute_computer_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
+    def execute_computer_action(self, action: Dict[str, Any]) -> Dict[str, Any]:
         """
         Execute a computer action and return the result for OpenAI API.
 
@@ -177,12 +175,12 @@ class FleetPlaywrightWrapper:
         # Execute the action
         if hasattr(self, f"_{action_type}"):
             method = getattr(self, f"_{action_type}")
-            await method(**action_args)
+            method(**action_args)
         else:
             raise ValueError(f"Unsupported action type: {action_type}")
 
         # Take screenshot after action
-        screenshot_base64 = await self.screenshot()
+        screenshot_base64 = self.screenshot()
 
         return {
             "type": "input_image",
@@ -191,81 +189,81 @@ class FleetPlaywrightWrapper:
         }
 
     # Computer action implementations
-    async def _click(self, x: int, y: int, button: str = "left") -> None:
+    def _click(self, x: int, y: int, button: str = "left") -> None:
         """Click at coordinates."""
         self._ensure_started()
-        await self._page.mouse.click(x, y, button=button)
+        self._page.mouse.click(x, y, button=button)
 
-    async def _double_click(self, x: int, y: int) -> None:
+    def _double_click(self, x: int, y: int) -> None:
         """Double-click at coordinates."""
         self._ensure_started()
-        await self._page.mouse.dblclick(x, y)
+        self._page.mouse.dblclick(x, y)
 
-    async def _scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
+    def _scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
         """Scroll from coordinates."""
         self._ensure_started()
-        await self._page.mouse.move(x, y)
-        await self._page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
+        self._page.mouse.move(x, y)
+        self._page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
 
-    async def _type(self, text: str) -> None:
+    def _type(self, text: str) -> None:
         """Type text."""
         self._ensure_started()
-        await self._page.keyboard.type(text)
+        self._page.keyboard.type(text)
 
-    async def _keypress(self, keys: List[str]) -> None:
+    def _keypress(self, keys: List[str]) -> None:
         """Press key combination."""
         self._ensure_started()
         mapped_keys = [CUA_KEY_TO_PLAYWRIGHT_KEY.get(key.lower(), key) for key in keys]
         for key in mapped_keys:
-            await self._page.keyboard.down(key)
+            self._page.keyboard.down(key)
         for key in reversed(mapped_keys):
-            await self._page.keyboard.up(key)
+            self._page.keyboard.up(key)
 
-    async def _move(self, x: int, y: int) -> None:
+    def _move(self, x: int, y: int) -> None:
         """Move mouse to coordinates."""
         self._ensure_started()
-        await self._page.mouse.move(x, y)
+        self._page.mouse.move(x, y)
 
-    async def _drag(self, path: List[Dict[str, int]]) -> None:
+    def _drag(self, path: List[Dict[str, int]]) -> None:
         """Drag mouse along path."""
         self._ensure_started()
         if not path:
             return
-        await self._page.mouse.move(path[0]["x"], path[0]["y"])
-        await self._page.mouse.down()
+        self._page.mouse.move(path[0]["x"], path[0]["y"])
+        self._page.mouse.down()
         for point in path[1:]:
-            await self._page.mouse.move(point["x"], point["y"])
-        await self._page.mouse.up()
+            self._page.mouse.move(point["x"], point["y"])
+        self._page.mouse.up()
 
-    async def _wait(self, ms: int = 1000) -> None:
+    def _wait(self, ms: int = 1000) -> None:
         """Wait for specified milliseconds."""
         import asyncio
 
-        await asyncio.sleep(ms / 1000)
+        asyncio.sleep(ms / 1000)
 
     # Browser-specific actions
-    async def _goto(self, url: str) -> None:
+    def _goto(self, url: str) -> None:
         """Navigate to URL."""
         self._ensure_started()
         try:
-            await self._page.goto(url)
+            self._page.goto(url)
         except Exception as e:
             print(f"Error navigating to {url}: {e}")
 
-    async def _back(self) -> None:
+    def _back(self) -> None:
         """Go back in browser history."""
         self._ensure_started()
-        await self._page.go_back()
+        self._page.go_back()
 
-    async def _forward(self) -> None:
+    def _forward(self) -> None:
         """Go forward in browser history."""
         self._ensure_started()
-        await self._page.go_forward()
+        self._page.go_forward()
 
-    async def _refresh(self) -> None:
+    def _refresh(self) -> None:
         """Refresh the page."""
         self._ensure_started()
-        await self._page.reload()
+        self._page.reload()
 
     # ------------------------------------------------------------------
     # Public aliases (no leading underscore) expected by the Agent &

fleet/resources/browser.py

@@ -10,32 +10,32 @@ from .base import Resource
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ..instance.base import AsyncWrapper
+    from ..instance.base import SyncWrapper
 
 
-class AsyncBrowserResource(Resource):
-    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+class BrowserResource(Resource):
+    def __init__(self, resource: ResourceModel, client: "SyncWrapper"):
         super().__init__(resource)
         self.client = client
 
-    async def start(self, width: int = 1920, height: int = 1080) -> CDPDescribeResponse:
-        response = await self.client.request(
+    def start(self, width: int = 1920, height: int = 1080) -> CDPDescribeResponse:
+        response = self.client.request(
             "POST",
             "/resources/cdp/start",
             json=ChromeStartRequest(resolution=f"{width},{height}").model_dump(),
         )
         ChromeStartResponse(**response.json())
-        return await self.describe()
+        return self.describe()
 
-    async def describe(self) -> CDPDescribeResponse:
-        response = await self.client.request("GET", "/resources/cdp/describe")
+    def describe(self) -> CDPDescribeResponse:
+        response = self.client.request("GET", "/resources/cdp/describe")
         if response.status_code != 200:
-            await self.start()
-            response = await self.client.request("GET", "/resources/cdp/describe")
+            self.start()
+            response = self.client.request("GET", "/resources/cdp/describe")
         return CDPDescribeResponse(**response.json())
 
-    async def cdp_url(self) -> str:
-        return (await self.describe()).cdp_browser_url
+    def cdp_url(self) -> str:
+        return (self.describe()).cdp_browser_url
 
-    async def devtools_url(self) -> str:
-        return (await self.describe()).cdp_devtools_url
+    def devtools_url(self) -> str:
+        return (self.describe()).cdp_devtools_url

fleet/resources/sqlite.py

@@ -6,34 +6,34 @@ from .base import Resource
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from ..instance.base import AsyncWrapper
+    from ..instance.base import SyncWrapper
 
 
-class AsyncSQLiteResource(Resource):
-    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+class SQLiteResource(Resource):
+    def __init__(self, resource: ResourceModel, client: "SyncWrapper"):
         super().__init__(resource)
         self.client = client
 
-    async def describe(self) -> DescribeResponse:
+    def describe(self) -> DescribeResponse:
         """Describe the SQLite database schema."""
-        response = await self.client.request(
+        response = self.client.request(
             "GET", f"/resources/sqlite/{self.resource.name}/describe"
         )
         return DescribeResponse(**response.json())
 
-    async def query(
+    def query(
         self, query: str, args: Optional[List[Any]] = None
     ) -> QueryResponse:
-        return await self._query(query, args, read_only=True)
+        return self._query(query, args, read_only=True)
 
-    async def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
-        return await self._query(query, args, read_only=False)
+    def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
+        return self._query(query, args, read_only=False)
 
-    async def _query(
+    def _query(
         self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
     ) -> QueryResponse:
         request = QueryRequest(query=query, args=args, read_only=read_only)
-        response = await self.client.request(
+        response = self.client.request(
             "POST",
             f"/resources/sqlite/{self.resource.name}/query",
             json=request.model_dump(),

fleet/verifiers/__init__.py

@@ -1,16 +1,11 @@
-from .db import QueryBuilder, DatabaseSnapshot, SnapshotDiff, IgnoreConfig
-from .code import (
-    TASK_SUCCESSFUL_SCORE,
-    extract_last_assistant_message,
-    execute_validation_function,
-)
+"""Fleet verifiers module - database snapshot validation utilities."""
+
+from .db import DatabaseSnapshot, IgnoreConfig, SnapshotDiff
+from .code import TASK_SUCCESSFUL_SCORE
 
 __all__ = [
     "DatabaseSnapshot",
-    "QueryBuilder",
-    "SnapshotDiff",
     "IgnoreConfig",
+    "SnapshotDiff",
     "TASK_SUCCESSFUL_SCORE",
-    "extract_last_assistant_message",
-    "execute_validation_function",
 ]