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

examples/dsl_example.py

@@ -1,6 +1,9 @@
 import asyncio
 import fleet as flt
 from fleet.verifiers import DatabaseSnapshot, IgnoreConfig, TASK_SUCCESSFUL_SCORE
+from dotenv import load_dotenv
+
+load_dotenv()
 
 
 def validate_new_deal_creation(

examples/example.py

@@ -3,6 +3,9 @@
 
 import asyncio
 import fleet as flt
+from dotenv import load_dotenv
+
+load_dotenv()
 
 
 async def main():
@@ -11,7 +14,7 @@ async def main():
 
     # Create a new instance
     env = await flt.env.make_async("hubspot:v1.2.7")
-    print("New Instance:", env.instance_id)
+    print(f"New Instance: {env.instance_id} ({env.region})")
 
     response = await env.reset(seed=42)
     print("Reset response:", response)

examples/example_client.py

@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+"""Example demonstrating browser control with Fleet Manager Client."""
+
+import asyncio
+import fleet as flt
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def main():
+    fleet = flt.AsyncFleet()
+
+    environments = await fleet.list_envs()
+    print("Environments:", len(environments))
+
+    # Create a new instance
+    env = await fleet.make("fira")
+    print(f"New Instance: {env.instance_id} ({env.region})")
+
+    response = await env.reset(seed=42)
+    print("Reset response:", response)
+
+    print(await env.resources())
+
+    sqlite = env.db()
+    print("SQLite:", await sqlite.describe())
+
+    print("Query:", await sqlite.query("SELECT * FROM users"))
+
+    sqlite = await env.state("sqlite://current").describe()
+    print("SQLite:", sqlite)
+
+    browser = env.browser()
+    print("CDP URL:", await browser.cdp_url())
+    print("Devtools URL:", await browser.devtools_url())
+
+    # Delete the instance
+    await fleet.delete(env.instance_id)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/example_sync.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""Example demonstrating browser control with Fleet Manager Client."""
+
+import fleet as flt
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def main():
+    environments = flt.env.list_envs()
+    print("Environments:", len(environments))
+
+    # Create a new instance
+    env = flt.env.make("hubspot:v1.2.7")
+    print("New Instance:", env.instance_id)
+
+    response = env.reset(seed=42)
+    print("Reset response:", response)
+
+    print(env.resources())
+
+    sqlite = env.db()
+    print("SQLite:", sqlite.describe())
+
+    print("Query:", sqlite.query("SELECT * FROM users"))
+
+    sqlite = env.state("sqlite://current").describe()
+    print("SQLite:", sqlite)
+
+    browser = env.browser()
+    print("CDP URL:", browser.cdp_url())
+    print("Devtools URL:", browser.devtools_url())
+
+    # Delete the instance
+    env.close()
+
+
+if __name__ == "__main__":
+    main()

examples/json_tasks_example.py

@@ -6,6 +6,9 @@ from typing import TypedDict, List
 from pathlib import Path
 import fleet as flt
 from nova_act import NovaAct, ActResult
+from dotenv import load_dotenv
+
+load_dotenv()
 
 
 MAX_STEPS = 30

examples/nova_act_example.py

@@ -1,6 +1,9 @@
 import asyncio
 import fleet as flt
 from nova_act import NovaAct, ActResult
+from dotenv import load_dotenv
+
+load_dotenv()
 
 
 async def main():

examples/openai_example.py

@@ -2,6 +2,9 @@ from openai import OpenAI
 import fleet as flt
 import json
 from typing import Callable
+from dotenv import load_dotenv
+
+load_dotenv()
 
 
 client = OpenAI()

examples/openai_simple_example.py

@@ -1,5 +1,8 @@
 from openai import OpenAI
 import fleet as flt
+from dotenv import load_dotenv
+
+load_dotenv()
 
 client = OpenAI()
 

examples/quickstart.py

@@ -7,9 +7,11 @@ This example demonstrates basic usage of the Fleet SDK for environment managemen
 
 import asyncio
 import logging
-from typing import Dict, Any
+from dotenv import load_dotenv
 
-import fleet
+load_dotenv()
+
+from fleet import AsyncFleet
 
 
 # Configure logging
@@ -19,23 +21,14 @@ logger = logging.getLogger(__name__)
 
 async def main():
     """Main example function."""
-    
-    # Check API health
-    print("🔍 Checking Fleet API health...")
-    try:
-        config = fleet.get_config()
-        client = fleet.FleetAPIClient(config)
-        health = await client.health_check()
-        print(f"✅ API Status: {health.status}")
-        await client.close()
-    except Exception as e:
-        print(f"❌ API Health Check failed: {e}")
-        return
-    
+
+    # Initialize the Fleet client
+    fleet_client = AsyncFleet()
+
     # 1. List available environments
     print("\n📋 Available environments:")
     try:
-        environments = await fleet.instance.list_envs()
+        environments = await fleet_client.list_envs()
         for env in environments:
             print(f"  - {env.env_key}: {env.name}")
             print(f"    Description: {env.description}")
@@ -44,77 +37,66 @@ async def main():
     except Exception as e:
         print(f"❌ Failed to list environments: {e}")
         return
-    
+
     # 2. Create a new environment instance
     print("\n🚀 Creating new environment...")
     try:
-        env = await fleet.instance.make("fira:v1.2.5", region="us-west-1")
+        env = await fleet_client.make("fira:v1.3.1")
         print(f"✅ Environment created with instance ID: {env.instance_id}")
-        
-        # Execute a simple action
+
+        # TODO: Execute a simple action
         print("\n⚡ Executing a simple action...")
         action = {"type": "test", "data": {"message": "Hello Fleet!"}}
-        state, reward, done = await env.step(action)
+        state, reward, done = await env.instance.step(action)
         print(f"✅ Action executed successfully!")
         print(f"   Reward: {reward}")
         print(f"   Done: {done}")
         print(f"   State keys: {list(state.keys())}")
-        
-        # Check manager API health
-        print("\n🏥 Checking manager API health...")
-        try:
-            manager_health = await env.manager_health_check()
-            if manager_health:
-                print(f"✅ Manager API Status: {manager_health.status}")
-                print(f"   Service: {manager_health.service}")
-                print(f"   Timestamp: {manager_health.timestamp}")
-            else:
-                print("❌ Manager API not available")
-        except Exception as e:
-            print(f"❌ Manager health check failed: {e}")
-        
+
         # Clean up
         print("\n🧹 Cleaning up...")
         await env.close()
         print("✅ Environment closed")
-        
+
     except Exception as e:
         print(f"❌ Environment creation failed: {e}")
         return
-    
+
     # 3. List running instances
     print("\n🏃 Listing running instances...")
     try:
-        instances = await fleet.instance.list_instances(status="running")
+        instances = await fleet_client.instances(status="running")
         if instances:
             print(f"Found {len(instances)} running instances:")
             for instance in instances:
-                print(f"  - {instance.instance_id}: {instance.env_key} ({instance.status})")
+                print(
+                    f"  - {instance.instance_id}: {instance.env_key} ({instance.status})"
+                )
         else:
             print("No running instances found")
     except Exception as e:
         print(f"❌ Failed to list instances: {e}")
-    
+
     # 4. Connect to an existing instance (if any)
     print("\n🔗 Connecting to existing instance...")
     try:
         # Only get running instances
-        running_instances = await fleet.instance.list_instances(status="running")
+        running_instances = await fleet_client.instances(status="running")
         if running_instances:
             # Find a running instance that's not the one we just created/deleted
             target_instance = running_instances[0]
             print(f"Connecting to running instance: {target_instance.instance_id}")
-            
-            env = await fleet.instance.get(target_instance.instance_id)
+
+            env = await fleet_client.instance(target_instance.instance_id)
             print(f"✅ Connected to instance: {env.instance_id}")
-            
+
             # Execute an action on the existing instance
             action = {"type": "ping", "data": {"timestamp": "2024-01-01T00:00:00Z"}}
-            state, reward, done = await env.step(action)
+            state, reward, done = await env.instance.step(action)
             print(f"✅ Action executed on existing instance!")
             print(f"   Reward: {reward}")
             print(f"   Done: {done}")
-            
+
             # Clean up (this will delete the instance)
             await env.close()
             print("✅ Connection closed (instance deleted)")
@@ -122,9 +104,9 @@ async def main():
             print("No running instances to connect to")
     except Exception as e:
         print(f"❌ Failed to connect to existing instance: {e}")
-    
+
     print("\n🎉 Quickstart complete!")
 
 
 if __name__ == "__main__":
-    asyncio.run(main()) 
+    asyncio.run(main())

fleet/__init__.py

@@ -25,7 +25,6 @@ from ._async.client import AsyncFleet, AsyncEnvironment
 from .models import InstanceRequest
 from .instance import (
     InstanceClient,
-    AsyncInstanceClient,
     ResetRequest,
     ResetResponse,
     CDPDescribeResponse,
@@ -33,6 +32,7 @@ from .instance import (
     ChromeStartResponse,
     ChromeStatusResponse,
 )
+from ._async.instance import AsyncInstanceClient
 from .verifiers import (
     DatabaseSnapshot,
     IgnoreConfig,

fleet/_async/__init__.py

@@ -0,0 +1 @@
+# This file makes the _async directory a proper Python package

fleet/_async/client.py

@@ -126,8 +126,12 @@ class AsyncFleet:
 
     async def instance(self, instance_id: str) -> AsyncEnvironment:
         response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        return AsyncEnvironment(**response.json())
+        instance = AsyncEnvironment(**response.json())
+        await instance.instance.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())
+        response = await self.client.request(
+            "DELETE", f"/v1/env/instances/{instance_id}"
+        )
+        return InstanceRecord(**response.json())

fleet/_async/env/client.py

@@ -1,6 +1,6 @@
 from ..client import AsyncFleet, AsyncEnvironment
 from ..models import Environment as EnvironmentModel
-from typing import List
+from typing import List, Optional
 
 
 async def make_async(env_key: str) -> AsyncEnvironment:
@@ -11,5 +11,9 @@ async def list_envs_async() -> List[EnvironmentModel]:
     return await AsyncFleet().list_envs()
 
 
+async def list_instances_async(status: Optional[str] = None) -> List[AsyncEnvironment]:
+    return await AsyncFleet().instances(status=status)
+
+
 async def get_async(instance_id: str) -> AsyncEnvironment:
-    return await AsyncFleet().instance(instance_id)
+    return await AsyncFleet().instance(instance_id)

fleet/_async/instance/client.py

@@ -1,4 +1,4 @@
-"""Fleet SDK Async Instance Client."""
+"""Fleet SDK Instance Client."""
 
 from typing import Any, Callable, Dict, List, Optional, Tuple
 import asyncio
@@ -12,7 +12,7 @@ from ..resources.sqlite import AsyncSQLiteResource
 from ..resources.browser import AsyncBrowserResource
 from ..resources.base import Resource
 
-from ...verifiers import DatabaseSnapshot
+from fleet.verifiers import DatabaseSnapshot
 
 from ..exceptions import FleetEnvironmentError, FleetAPIError
 
@@ -75,13 +75,13 @@ class AsyncInstanceClient:
 
     def db(self, name: str) -> AsyncSQLiteResource:
         """
-        Returns an AsyncSQLiteResource object for the given SQLite database name.
+        Returns an SQLite database resource for the given database name.
 
         Args:
             name: The name of the SQLite database to return
 
         Returns:
-            An AsyncSQLiteResource object for the given SQLite database name
+            An SQLite database resource for the given database name
         """
         return AsyncSQLiteResource(
             self._resources_state[ResourceType.db.value][name], self.client
@@ -144,135 +144,33 @@ class AsyncInstanceClient:
 
     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()
+            # Create a placeholder state
+            state = {
+                "action": action,
+                "timestamp": time.time(),
+                "status": "completed",
+            }
+
+            # Create a placeholder reward
+            reward = 0.0
 
-            # 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)
+            # Determine if episode is done (placeholder logic)
+            done = False
 
             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()
+        await self.close()

fleet/_async/playwright.py

@@ -34,7 +34,7 @@ CUA_KEY_TO_PLAYWRIGHT_KEY = {
 }
 
 
-class FleetPlaywrightWrapper:
+class AsyncFleetPlaywrightWrapper:
     """
     A wrapper that adds Playwright browser automation to Fleet environment instances.
 
@@ -46,7 +46,7 @@ class FleetPlaywrightWrapper:
 
     Usage:
         instance = await fleet.env.make(env_key="hubspot", version="v1.2.7")
-        browser = FleetPlaywrightWrapper(instance)
+        browser = AsyncFleetPlaywrightWrapper(instance)
         await browser.start()
 
         # Use browser methods

fleet/client.py

@@ -126,8 +126,12 @@ class Fleet:
 
     def instance(self, instance_id: str) -> Environment:
         response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        return Environment(**response.json())
+        instance = Environment(**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())
+        response = self.client.request(
+            "DELETE", f"/v1/env/instances/{instance_id}"
+        )
+        return InstanceRecord(**response.json())

fleet/env/client.py

@@ -1,6 +1,6 @@
 from ..client import Fleet, Environment
 from ..models import Environment as EnvironmentModel
-from typing import List
+from typing import List, Optional
 
 
 def make(env_key: str) -> Environment:
@@ -11,5 +11,9 @@ def list_envs() -> List[EnvironmentModel]:
     return Fleet().list_envs()
 
 
+def list_instances(status: Optional[str] = None) -> List[Environment]:
+    return Fleet().instances(status=status)
+
+
 def get(instance_id: str) -> Environment:
-    return Fleet().instance(instance_id)
+    return Fleet().instance(instance_id)

fleet/instance/__init__.py

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

fleet/instance/client.py

@@ -1,7 +1,6 @@
-"""Fleet SDK Async Instance Client."""
+"""Fleet SDK Instance Client."""
 
 from typing import Any, Callable, Dict, List, Optional, Tuple
-import asyncio
 import httpx
 import inspect
 import time
@@ -75,13 +74,13 @@ class InstanceClient:
 
     def db(self, name: str) -> SQLiteResource:
         """
-        Returns an AsyncSQLiteResource object for the given SQLite database name.
+        Returns an SQLite database resource for the given database name.
 
         Args:
             name: The name of the SQLite database to return
 
         Returns:
-            An AsyncSQLiteResource object for the given SQLite database name
+            An SQLite database resource for the given database name
         """
         return SQLiteResource(
             self._resources_state[ResourceType.db.value][name], self.client
@@ -144,135 +143,33 @@ class InstanceClient:
 
     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()
+            # Create a placeholder state
+            state = {
+                "action": action,
+                "timestamp": time.time(),
+                "status": "completed",
+            }
+
+            # Create a placeholder reward
+            reward = 0.0
 
-            # Execute action through instance manager API
-            # This is a placeholder - actual implementation depends on the manager API spec
-            state, reward, done = self._execute_action(action)
+            # Determine if episode is done (placeholder logic)
+            done = False
 
             return state, reward, done
 
         except Exception as e:
             raise FleetEnvironmentError(f"Failed to execute step: {e}")
 
-    def close(self) -> None:
-        """Close the environment and clean up resources."""
-        try:
-            # Delete instance if it exists
-            if self._instance_id:
-                try:
-                    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:
-                self._manager_client.close()
-                self._manager_client = None
-
-            # Close API client
-            self._client.close()
-
-        except Exception as e:
-            logger.error(f"Error closing environment: {e}")
-
     def manager_health_check(self) -> Optional[HealthResponse]:
         response = self.client.request("GET", "/health")
         return HealthResponse(**response.json())
 
-    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 = 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
-                asyncio.sleep(5)
-
-            except FleetAPIError as e:
-                if time.time() - start_time >= timeout:
-                    raise FleetEnvironmentError(
-                        f"Timeout waiting for instance to be ready: {e}"
-                    )
-                asyncio.sleep(5)
-
-        raise FleetEnvironmentError(
-            f"Timeout waiting for instance {self._instance_id} to be ready"
-        )
-
-    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
-        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",
-        }
-
     def __enter__(self):
         """Async context manager entry."""
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
-        self.close()
+        self.close()

fleet/playwright.py

@@ -45,16 +45,16 @@ class FleetPlaywrightWrapper:
     - Integration with OpenAI computer use API
 
     Usage:
-        instance = await fleet.env.make(env_key="hubspot", version="v1.2.7")
+        instance = fleet.env.make(env_key="hubspot", version="v1.2.7")
         browser = FleetPlaywrightWrapper(instance)
-        await browser.start()
+        browser.start()
 
         # Use browser methods
-        screenshot = await browser.screenshot()
+        screenshot = browser.screenshot()
         tools = [browser.openai_cua_tool]
 
         # Clean up when done
-        await browser.close()
+        browser.close()
     """
 
     def get_environment(self):
@@ -100,7 +100,9 @@ class FleetPlaywrightWrapper:
         cdp = self.env.browser().describe()
 
         # Connect to browser
-        self._browser = 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]
         self._page.set_viewport_size(
             {"width": self.display_width, "height": self.display_height}
@@ -121,7 +123,7 @@ class FleetPlaywrightWrapper:
     def _ensure_started(self):
         """Ensure browser is started before operations."""
         if not self._started:
-            raise RuntimeError("Browser not started. Call await browser.start() first.")
+            raise RuntimeError("Browser not started. Call browser.start() first.")
 
     @property
     def openai_cua_tool(self) -> Dict[str, Any]:
@@ -237,9 +239,8 @@ class FleetPlaywrightWrapper:
 
     def _wait(self, ms: int = 1000) -> None:
         """Wait for specified milliseconds."""
-        import asyncio
 
-        asyncio.sleep(ms / 1000)
+        time.sleep(ms / 1000)
 
     # Browser-specific actions
     def _goto(self, url: str) -> None:

{fleet_python-0.2.5.dist-info → fleet_python-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.5
+Version: 0.2.7
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -32,6 +32,7 @@ Requires-Dist: isort>=5.0.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
 Requires-Dist: unasync>=0.6.0; extra == "dev"
+Requires-Dist: python-dotenv>=1.1.1; extra == "dev"
 Provides-Extra: playwright
 Requires-Dist: playwright>=1.40.0; extra == "playwright"
 Dynamic: license-file
@@ -112,3 +113,44 @@ running_instances = flt.env.list_instances(status_filter="running")
 # List available environment types
 available_envs = flt.env.list_envs()
 ```
+
+## Development
+
+### Code Structure
+
+This SDK uses `unasync` to maintain both async and sync versions of the code from a single source:
+
+- **`fleet/_async/`** - The source code (async version) - **EDIT THIS**
+- **`fleet/`** - The generated sync version - **DO NOT EDIT** (auto-generated)
+
+### Making Changes
+
+⚠️ **Important**: All code modifications should be made in the `fleet/_async/` directory. The synchronous versions in `fleet/` are automatically generated.
+
+1. Make your changes in `fleet/_async/`
+2. Run `make unasync` to generate the sync versions
+3. Test both async and sync versions
+4. Commit all changes (both async source and generated sync files)
+
+Example workflow:
+```bash
+# Edit the async source files
+vim fleet/_async/client.py
+
+# Generate sync versions
+make unasync
+
+# Run tests
+python examples/examle.py
+
+# Commit both source and generated files
+git add fleet/_async/ fleet/
+git commit -m "Add new feature"
+```
+
+### Why This Structure?
+
+- Single source of truth for business logic
+- Automatic sync/async API generation
+- Consistent behavior between sync and async versions
+- Easier maintenance and testing

{fleet_python-0.2.5.dist-info → fleet_python-0.2.7.dist-info}/RECORD

@@ -1,36 +1,39 @@
-examples/dsl_example.py,sha256=nBfKdv4u6XuM97TG-ugfVStPdtoYq86ildFzLcQqGIk,5315
-examples/example.py,sha256=B1ERVudPsPx1D1od3gCQU8MnG4FxuSBm0p7otkvIaLw,945
-examples/json_tasks_example.py,sha256=_y4w94FfAaMBGgIqhVlrDU0PXbinNDWrT28DsUMvd9Y,2354
-examples/nova_act_example.py,sha256=YMfx_7O1_6pqsy0Rf6Yabyqyg4_kI3cgMBlMJjAQXW4,790
-examples/openai_example.py,sha256=5ZvBC0dcw8gPHoC6Gn-1KZx3CmUQBlBmPJgOrcgMSVM,8188
-examples/openai_simple_example.py,sha256=pS2z7Q3s7tml5hbahc1NGgMXoF0mWwhi7VeLDTA4sE4,1702
-examples/quickstart.py,sha256=lVRzbnWIweU9ioe7uk6R2Rm7oSpt4mt8Jq_VUUp1zKg,4696
-fleet/__init__.py,sha256=CxDokocjQsv_JUNwhSqnijpQVXhQx73CXLu2Cp-rtgk,2087
+examples/dsl_example.py,sha256=3Eu5924a8x61nuSGXqGz8XjPLNKKH8Ye7lSYHSvixtk,5361
+examples/example.py,sha256=FFPfM5Oso7IP9Q8aELpof1J41zslELdHHJhAAck9vLk,1008
+examples/example_client.py,sha256=70HKEhz_Gb79YcvKQauCPdS08AAwjo9unt2dh1jN_Oo,1030
+examples/example_sync.py,sha256=sW8pMU1WsEecGlc_NeQ8BAS1YxOud4iG6MafWGnFeTg,885
+examples/json_tasks_example.py,sha256=EhsJKVWoJFcrqhIIKF5lVrnIqpZDtizQqYblJaOZtmk,2400
+examples/nova_act_example.py,sha256=hZLpObVsiXKQzqGwMZVMf4A2j_z4TYE-YO9pgNmaKPk,836
+examples/openai_example.py,sha256=I2vk_SJN9BkSRQCYRJfbtGJ-HJ2xzQj-lOjwqmLos5M,8234
+examples/openai_simple_example.py,sha256=I42ytIwv0INgDO39pp1MOQSqsJz2YYH8GeNNBaUtq3A,1748
+examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
+fleet/__init__.py,sha256=p-0zZMxKoD6dlQ9IGQ753QQWuwcw-RPl4E6HezhKfV4,2111
 fleet/base.py,sha256=t4xkgazl8kEP05JFjNByyf39RvvASRP0GsvxuoqKPY0,1395
-fleet/client.py,sha256=SQEUoj4DMuXa4m5wfPPCkBEhQc7f6941K9V8Qk6ZF0U,4675
+fleet/client.py,sha256=xPLlHS14Q2F8jn8e5lSLMUFE6o6ro7oM0XclOjVrxE4,4759
 fleet/exceptions.py,sha256=yG3QWprCw1OnF-vdFBFJWE4m3ftBLBng31Dr__VbjI4,2249
 fleet/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
-fleet/playwright.py,sha256=LWx_1UlNZPo117Lf7qnBlWT4RJA0OcwqRVRdFE98bSQ,8627
+fleet/playwright.py,sha256=BmRvez5DUa0ttAQB084hPAyt9_8WxdzCGBGF-GZbTuQ,8593
+fleet/_async/__init__.py,sha256=AJWCnuo7XKja4yBb8fK2wX7ntciLXQrpzdRHwjTRP6M,62
 fleet/_async/base.py,sha256=hUch1I5oUPgaCXR3IpJ8f_PjigifAZg2-LR7BJdZSo8,1413
-fleet/_async/client.py,sha256=pL0csdrAJKltA9km6DHDRogPpTEzi8AH32mS1efxNgg,4920
+fleet/_async/client.py,sha256=T15EwovKCCshr4sF_HeHNdnbIUFoyZqjrN6_tU5o4aY,5010
 fleet/_async/exceptions.py,sha256=yG3QWprCw1OnF-vdFBFJWE4m3ftBLBng31Dr__VbjI4,2249
 fleet/_async/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
-fleet/_async/playwright.py,sha256=5MLFPE5P_-MpzAQ3EJ6GsLthuJiWwYkNuvhPE_rwe_E,8914
+fleet/_async/playwright.py,sha256=2r4ywuv2ZqT0Qu3-k8A7V4YijeAOHnN8HiqJreLEYGI,8924
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=Gft6pNkUK4PYMV8VE3KyS5R_-HuqGO5HEjAUuCPObiw,440
+fleet/_async/env/client.py,sha256=CO2KuD6FFkP1SdOJ2ehwBKrCdLEFsz5tj3jPR5tVu4U,596
 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=Llc-yefnbL3fkBsayU4ANEqy_fFB2Uy6jNhTkfGj1mU,9362
+fleet/_async/instance/client.py,sha256=qmX5g6lPrq0b3BQ6LvTApeyquTtCse98Cu_Kwc72y6A,5653
 fleet/_async/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 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/env/__init__.py,sha256=_lvYBqieXWmvU_dyPi2seSpLO3AZh5kdprdqFeefkzk,338
-fleet/env/client.py,sha256=UGPrRlu89NM2RFdY7m6cGwUjOHJdtiPe4vkz-f2ByRg,351
-fleet/instance/__init__.py,sha256=cdVC50HLLp2y7yf1Ga5wpLiy-hmamxmyibH0NDG7xI4,597
+fleet/env/client.py,sha256=LVHXnC19bl0zEW20qykC63wJ0nO9gETF6z0_74dCdCo,479
+fleet/instance/__init__.py,sha256=Hr8xPPoqzKOViXZXWmaL6dQ7NOBn-GooTGzoIvGmiE4,514
 fleet/instance/base.py,sha256=U-qW1EQVBo6yvMpP1JeKiPRhCjZ3y3aTsYFhLPNOTtQ,929
-fleet/instance/client.py,sha256=RFp5R703pP3tjKd_HBozJJ2qNie7LpMUx9NYjyPnPOI,9128
+fleet/instance/client.py,sha256=2EcuBpq21kUHCFommYdS9Ya-unLn-e8mrdAZBIZea3Q,5467
 fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
@@ -40,9 +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.5.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.7.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scripts/fix_sync_imports.py,sha256=b7tRvShgOFqyildqs1qI-Io0gaHappykBI-PSWWqUwE,2941
 scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
-fleet_python-0.2.5.dist-info/METADATA,sha256=MqmuFENsTkHkP2gU9_UQB35NQH4hL5POBYGpYCASRIY,3139
-fleet_python-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.5.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.5.dist-info/RECORD,,
+fleet_python-0.2.7.dist-info/METADATA,sha256=hWvnoVCE-orcwesjDjMAm01Cjs5XWYpYXLfN9d7Hg44,4321
+fleet_python-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.7.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.7.dist-info/RECORD,,

scripts/fix_sync_imports.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Fix imports in sync files after unasync runs."""
+
+import re
+from pathlib import Path
+
+def fix_file(filepath: Path) -> bool:
+    """Fix imports and sleep calls in a single file."""
+    content = filepath.read_text()
+    original = content
+    
+    # Remove asyncio import if it exists
+    content = re.sub(r'^import asyncio.*\n', '', content, flags=re.MULTILINE)
+    content = re.sub(r'^import asyncio as async_time.*\n', '', content, flags=re.MULTILINE)
+    # Also remove indented asyncio imports (like in functions)
+    content = re.sub(r'^\s+import asyncio.*\n', '', content, flags=re.MULTILINE)
+    
+    # Fix any remaining asyncio.sleep or async_time.sleep calls
+    content = content.replace('asyncio.sleep(', 'time.sleep(')
+    content = content.replace('async_time.sleep(', 'time.sleep(')
+    
+    # Fix absolute imports to relative imports for verifiers
+    content = content.replace('from fleet.verifiers import', 'from ..verifiers import')
+    
+    # Fix any remaining AsyncFleetPlaywrightWrapper references in docstrings
+    content = content.replace('AsyncFleetPlaywrightWrapper', 'FleetPlaywrightWrapper')
+    
+    # Fix playwright imports for sync version
+    if 'playwright' in str(filepath):
+        # Fix the import statement
+        content = content.replace('from playwright.async_api import sync_playwright, Browser, Page', 
+                                  'from playwright.sync_api import sync_playwright, Browser, Page')
+        content = content.replace('from playwright.async_api import async_playwright, Browser, Page', 
+                                  'from playwright.sync_api import sync_playwright, Browser, Page')
+        # Replace any remaining async_playwright references
+        content = content.replace('async_playwright', 'sync_playwright')
+        # Fix await statements in docstrings
+        content = content.replace('await browser.start()', 'browser.start()')
+        content = content.replace('await browser.screenshot()', 'browser.screenshot()')
+        content = content.replace('await browser.close()', 'browser.close()')
+        content = content.replace('await fleet.env.make(', 'fleet.env.make(')
+        # Fix error message
+        content = content.replace('Call await browser.start() first', 'Call browser.start() first')
+    
+    if content != original:
+        filepath.write_text(content)
+        return True
+    return False
+
+def main():
+    """Fix all sync files."""
+    sync_dir = Path(__file__).parent.parent / "fleet"
+    
+    # Files to fix
+    files_to_fix = [
+        sync_dir / "instance" / "client.py",
+        sync_dir / "playwright.py",
+        # Add other files here as needed
+    ]
+    
+    for filepath in files_to_fix:
+        if filepath.exists():
+            if fix_file(filepath):
+                print(f"Fixed {filepath}")
+            else:
+                print(f"No changes needed for {filepath}")
+
+if __name__ == "__main__":
+    main()