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

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

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

fleet_python-0.2.0/examples/browser_control_example.py → fleet_python-0.2.1/examples/example.py

@@ -11,22 +11,21 @@ async def main():
     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)
+    # Create a new instance
+    instance = await fleet.make(
+        flt.InstanceRequest(env_key="hubspot", version="v1.2.7")
+    )
+    print("New Instance:", instance.instance_id)
 
     environment = await fleet.environment(instance.env_key)
     print("Environment Default Version:", environment.default_version)
 
-    response = await instance.env.reset()
+    response = await instance.env.reset(flt.ResetRequest(seed=42))
     print("Reset response:", response)
 
     print(await instance.env.resources())
 
-    sqlite = instance.env.sqlite("current")
+    sqlite = instance.env.db("current")
     print("SQLite:", await sqlite.describe())
 
     print("Query:", await sqlite.query("SELECT * FROM users"))
@@ -34,13 +33,14 @@ async def main():
     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)
+    await instance.env.browser("cdp").start(
+        flt.ChromeStartRequest(resolution="1920,1080")
+    )
 
-    # Create a new instance
-    instance = await fleet.make(flt.InstanceRequest(env_key=instance.env_key))
-    print("New Instance:", instance.instance_id)
+    browser = await instance.env.browser("cdp").describe()
+    print("CDP Page URL:", browser.cdp_page_url)
+    print("CDP Browser URL:", browser.cdp_browser_url)
+    print("CDP Devtools URL:", browser.cdp_devtools_url)
 
     # Delete the instance
     instance = await fleet.delete(instance.instance_id)

fleet_python-0.2.1/examples/nova_act_example.py

@@ -0,0 +1,180 @@
+"""
+Nova Act + Fleet SDK Integration Example
+
+This example demonstrates how to use Amazon Nova Act (an AI-powered browser automation SDK)
+with Fleet's browser instances. Nova Act can navigate websites, fill forms, and extract data
+using natural language commands.
+
+Requirements:
+1. Fleet SDK: pip install fleet-python
+2. Nova Act SDK: pip install nova-act
+3. Playwright Chrome: playwright install chrome
+4. Environment variables:
+   - FLEET_API_KEY: Your Fleet API key
+   - NOVA_ACT_API_KEY: Your Nova Act API key (get from https://nova.amazon.com/act)
+
+Note: Nova Act is currently only available in the US as a research preview.
+
+Usage:
+    export FLEET_API_KEY=your_fleet_key
+    export NOVA_ACT_API_KEY=your_nova_act_key
+    python examples/nova_act_example.py
+
+Important: Nova Act typically creates its own browser instance. Integration with
+Fleet's CDP endpoint may not be fully supported in the current version.
+"""
+
+import asyncio
+import fleet as flt
+import nova_act
+import os
+from concurrent.futures import ThreadPoolExecutor
+
+
+def test_nova_act_sync():
+    """Test Nova Act in a synchronous context (outside asyncio loop)."""
+    print("\n🧪 Testing Nova Act independently...")
+    try:
+        with nova_act.NovaAct(
+            headless=False,
+            starting_page="https://example.com"
+        ) as nova:
+            print("✅ Nova Act initialized successfully!")
+            result = nova.act("What is the main heading on this page?")
+            print(f"Test result: {result}")
+            return True
+    except Exception as e:
+        print(f"❌ Nova Act test failed: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def run_nova_act_with_fleet_data(fleet_app_url):
+    """Run Nova Act examples using Fleet's app URL."""
+    print("\n🤖 Starting Nova Act with Fleet app URL...")
+    
+    try:
+        with nova_act.NovaAct(
+            headless=False,
+            starting_page=fleet_app_url,
+            cdp_endpoint_url="wss://05bd8217.fleetai.com/cdp/devtools/browser/288477c8-2a6d-4e66-b8de-29bc3033c7a2"
+        ) as nova:
+            print("✅ Nova Act started successfully!")
+            run_nova_examples(nova)
+            
+    except Exception as e:
+        print(f"❌ Error during Nova Act operations: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+
+def run_nova_examples(nova):
+    """Run Nova Act examples in a separate function."""
+    # Example 1: Navigate and interact with a website
+    print("\n📝 Example 1: Basic navigation and interaction")
+    nova.act("Navigate to https://example.com")
+
+    # Extract page title
+    result = nova.act(
+        "What is the title of this page?",
+        schema={"type": "object", "properties": {"title": {"type": "string"}}},
+    )
+    if result.matches_schema:
+        print(f"Page title: {result.parsed_response.get('title')}")
+
+    # Example 2: More complex interaction
+    print("\n📝 Example 2: Search on a website")
+    nova.act("Navigate to https://www.python.org")
+    nova.act("Search for 'asyncio' in the search box")
+
+    # Example 3: Extract structured data
+    print("\n📝 Example 3: Extract structured information")
+    result = nova.act(
+        "Find the first 3 search results and return their titles",
+        schema={
+            "type": "object",
+            "properties": {
+                "results": {"type": "array", "items": {"type": "string"}}
+            },
+        },
+    )
+    if result.matches_schema:
+        results = result.parsed_response.get("results", [])
+        print("Search results:")
+        for i, title in enumerate(results, 1):
+            print(f"  {i}. {title}")
+
+    # Example 4: Fill out a form
+    print("\n📝 Example 4: Form interaction")
+    nova.act("Navigate to https://httpbin.org/forms/post")
+    nova.act("Fill the customer name field with 'John Doe'")
+    nova.act("Select 'Medium' for the size")
+    nova.act("Check the 'Bacon' topping")
+
+    # You can also use nova_act's ability to take screenshots
+    print("\n📸 Taking screenshot...")
+    nova.act("Take a screenshot of the current page")
+
+
+async def main():
+    """Main async function for Fleet operations."""
+    
+    # Check for Nova Act API key
+    nova_api_key = os.getenv("NOVA_ACT_API_KEY")
+    if not nova_api_key:
+        print("❌ NOVA_ACT_API_KEY environment variable not set!")
+        print("Please set it with: export NOVA_ACT_API_KEY=your_api_key")
+        return
+    else:
+        print(f"✅ Nova Act API key found: {nova_api_key[:8]}...{nova_api_key[-4:]}")
+
+    # Test Nova Act outside of asyncio loop
+    # with ThreadPoolExecutor() as executor:
+    #     nova_test_future = executor.submit(test_nova_act_sync)
+    #     nova_works = nova_test_future.result()
+        
+    # if not nova_works:
+    #     print("\nNova Act is not working properly. Please check:")
+    #     print("1. You have a valid NOVA_ACT_API_KEY")
+    #     print("2. You have installed nova-act: pip install nova-act")
+    #     print("3. You have playwright installed: playwright install chrome")
+    #     return
+
+    # Initialize Fleet client
+    fleet = flt.AsyncFleet()
+    print("\n🚀 Initializing Fleet client...")
+
+    instance = await fleet.instance("05bd8217")
+
+    try:
+        # Reset the environment to ensure clean state
+        # print("🔄 Resetting environment...")
+        # await instance.env.reset()
+
+        # Get browser resource from Fleet
+        browser = await instance.env.browser("cdp").describe()
+        print(f"🌐 CDP URL: {browser.url}")
+        print(f"🔧 DevTools URL: {browser.devtools_url}")
+
+        # Run Nova Act in a separate thread to avoid asyncio conflicts
+        with ThreadPoolExecutor() as executor:
+            nova_future = executor.submit(run_nova_act_with_fleet_data, instance.urls.app)
+            nova_future.result()  # Wait for Nova Act to complete
+
+    except Exception as e:
+        print(f"❌ Error in main flow: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\n\n⚠️  Script interrupted by user")
+        print("Nova Act browser may still be running in the background.")
+    except Exception as e:
+        print(f"\n❌ Unexpected error: {type(e).__name__}: {str(e)}")
+        import traceback
+        traceback.print_exc()

fleet_python-0.2.1/examples/openai_example.py

@@ -0,0 +1,329 @@
+import time
+import base64
+from typing import List, Dict, Callable
+from playwright.sync_api import sync_playwright, Browser, Page
+
+# Optional: key mapping if your model uses "CUA" style keys
+CUA_KEY_TO_PLAYWRIGHT_KEY = {
+    "/": "Divide",
+    "\\": "Backslash",
+    "alt": "Alt",
+    "arrowdown": "ArrowDown",
+    "arrowleft": "ArrowLeft",
+    "arrowright": "ArrowRight",
+    "arrowup": "ArrowUp",
+    "backspace": "Backspace",
+    "capslock": "CapsLock",
+    "cmd": "Meta",
+    "ctrl": "Control",
+    "delete": "Delete",
+    "end": "End",
+    "enter": "Enter",
+    "esc": "Escape",
+    "home": "Home",
+    "insert": "Insert",
+    "option": "Alt",
+    "pagedown": "PageDown",
+    "pageup": "PageUp",
+    "shift": "Shift",
+    "space": " ",
+    "super": "Meta",
+    "tab": "Tab",
+    "win": "Meta",
+}
+
+
+class BasePlaywrightComputer:
+    """
+    Abstract base for Playwright-based computers:
+
+      - Subclasses override `_get_browser_and_page()` to do local or remote connection,
+        returning (Browser, Page).
+      - This base class handles context creation (`__enter__`/`__exit__`),
+        plus standard "Computer" actions like click, scroll, etc.
+      - We also have extra browser actions: `goto(url)` and `back()`.
+    """
+
+    def get_environment(self):
+        return "browser"
+
+    def get_dimensions(self):
+        return (1024, 768)
+
+    def __init__(self):
+        self._playwright = None
+        self._browser: Browser | None = None
+        self._page: Page | None = None
+
+    def __enter__(self):
+        # Start Playwright and call the subclass hook for getting browser/page
+        self._playwright = sync_playwright().start()
+        self._browser, self._page = self._get_browser_and_page()
+
+        # Set up network interception to flag URLs matching domains in BLOCKED_DOMAINS
+        def handle_route(route, request):
+            route.continue_()
+
+        self._page.route("**/*", handle_route)
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self._browser:
+            self._browser.close()
+        if self._playwright:
+            self._playwright.stop()
+
+    def get_current_url(self) -> str:
+        return self._page.url
+
+    # --- Common "Computer" actions ---
+    def screenshot(self) -> str:
+        """Capture only the viewport (not full_page)."""
+        png_bytes = self._page.screenshot(full_page=False)
+        return base64.b64encode(png_bytes).decode("utf-8")
+
+    def click(self, x: int, y: int, button: str = "left") -> None:
+        if button == "back":
+            self.back()
+        elif button == "forward":
+            self.forward()
+        elif button == "wheel":
+            self._page.mouse.wheel(x, y)
+        else:
+            button_mapping = {"left": "left", "right": "right"}
+            button_type = button_mapping.get(button, "left")
+            self._page.mouse.click(x, y, button=button_type)
+
+    def double_click(self, x: int, y: int) -> None:
+        self._page.mouse.dblclick(x, y)
+
+    def scroll(self, x: int, y: int, scroll_x: int, scroll_y: int) -> None:
+        self._page.mouse.move(x, y)
+        self._page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
+
+    def type(self, text: str) -> None:
+        self._page.keyboard.type(text)
+
+    def wait(self, ms: int = 1000) -> None:
+        time.sleep(ms / 1000)
+
+    def move(self, x: int, y: int) -> None:
+        self._page.mouse.move(x, y)
+
+    def keypress(self, keys: List[str]) -> None:
+        mapped_keys = [CUA_KEY_TO_PLAYWRIGHT_KEY.get(key.lower(), key) for key in keys]
+        for key in mapped_keys:
+            self._page.keyboard.down(key)
+        for key in reversed(mapped_keys):
+            self._page.keyboard.up(key)
+
+    def drag(self, path: List[Dict[str, int]]) -> None:
+        if not path:
+            return
+        self._page.mouse.move(path[0]["x"], path[0]["y"])
+        self._page.mouse.down()
+        for point in path[1:]:
+            self._page.mouse.move(point["x"], point["y"])
+        self._page.mouse.up()
+
+    # --- Extra browser-oriented actions ---
+    def goto(self, url: str) -> None:
+        try:
+            return self._page.goto(url)
+        except Exception as e:
+            print(f"Error navigating to {url}: {e}")
+
+    def back(self) -> None:
+        return self._page.go_back()
+
+    def forward(self) -> None:
+        return self._page.go_forward()
+
+    # --- Subclass hook ---
+    def _get_browser_and_page(self) -> tuple[Browser, Page]:
+        """Subclasses must implement, returning (Browser, Page)."""
+        raise NotImplementedError
+
+
+class LocalPlaywrightBrowser(BasePlaywrightComputer):
+    """Launches a local Chromium instance using Playwright."""
+
+    def __init__(self, headless: bool = False):
+        super().__init__()
+        self.headless = headless
+
+    def _get_browser_and_page(self) -> tuple[Browser, Page]:
+        width, height = self.get_dimensions()
+        launch_args = [
+            f"--window-size={width},{height}",
+            "--disable-extensions",
+            "--disable-file-system",
+        ]
+        browser = self._playwright.chromium.launch(
+            chromium_sandbox=True,
+            headless=self.headless,
+            args=launch_args,
+            env={"DISPLAY": ":0"},
+        )
+
+        context = browser.new_context()
+
+        # Add event listeners for page creation and closure
+        context.on("page", self._handle_new_page)
+
+        page = context.new_page()
+        page.set_viewport_size({"width": width, "height": height})
+        page.on("close", self._handle_page_close)
+
+        page.goto("https://bing.com")
+
+        return browser, page
+
+    def _handle_new_page(self, page: Page):
+        """Handle the creation of a new page."""
+        print("New page created")
+        self._page = page
+        page.on("close", self._handle_page_close)
+
+    def _handle_page_close(self, page: Page):
+        """Handle the closure of a page."""
+        print("Page closed")
+        if self._page == page:
+            if self._browser.contexts[0].pages:
+                self._page = self._browser.contexts[0].pages[-1]
+            else:
+                print("Warning: All pages have been closed.")
+                self._page = None
+
+
+class Agent:
+    """
+    A sample agent class that can be used to interact with a computer.
+
+    (See simple_cua_loop.py for a simple example without an agent.)
+    """
+
+    def __init__(
+        self,
+        model="computer-use-preview",
+        computer: Computer = None,
+        tools: list[dict] = [],
+        acknowledge_safety_check_callback: Callable = lambda: False,
+    ):
+        self.model = model
+        self.computer = computer
+        self.tools = tools
+        self.print_steps = True
+        self.debug = False
+        self.show_images = False
+        self.acknowledge_safety_check_callback = acknowledge_safety_check_callback
+
+        if computer:
+            dimensions = computer.get_dimensions()
+            self.tools += [
+                {
+                    "type": "computer-preview",
+                    "display_width": dimensions[0],
+                    "display_height": dimensions[1],
+                    "environment": computer.get_environment(),
+                },
+            ]
+
+    def debug_print(self, *args):
+        if self.debug:
+            pp(*args)
+
+    def handle_item(self, item):
+        """Handle each item; may cause a computer action + screenshot."""
+        if item["type"] == "message":
+            if self.print_steps:
+                print(item["content"][0]["text"])
+
+        if item["type"] == "function_call":
+            name, args = item["name"], json.loads(item["arguments"])
+            if self.print_steps:
+                print(f"{name}({args})")
+
+            if hasattr(self.computer, name):  # if function exists on computer, call it
+                method = getattr(self.computer, name)
+                method(**args)
+            return [
+                {
+                    "type": "function_call_output",
+                    "call_id": item["call_id"],
+                    "output": "success",  # hard-coded output for demo
+                }
+            ]
+
+        if item["type"] == "computer_call":
+            action = item["action"]
+            action_type = action["type"]
+            action_args = {k: v for k, v in action.items() if k != "type"}
+            if self.print_steps:
+                print(f"{action_type}({action_args})")
+
+            method = getattr(self.computer, action_type)
+            method(**action_args)
+
+            screenshot_base64 = self.computer.screenshot()
+            if self.show_images:
+                show_image(screenshot_base64)
+
+            # if user doesn't ack all safety checks exit with error
+            pending_checks = item.get("pending_safety_checks", [])
+            for check in pending_checks:
+                message = check["message"]
+                if not self.acknowledge_safety_check_callback(message):
+                    raise ValueError(
+                        f"Safety check failed: {message}. Cannot continue with unacknowledged safety checks."
+                    )
+
+            call_output = {
+                "type": "computer_call_output",
+                "call_id": item["call_id"],
+                "acknowledged_safety_checks": pending_checks,
+                "output": {
+                    "type": "input_image",
+                    "image_url": f"data:image/png;base64,{screenshot_base64}",
+                },
+            }
+
+            # additional URL safety checks for browser environments
+            if self.computer.get_environment() == "browser":
+                current_url = self.computer.get_current_url()
+                check_blocklisted_url(current_url)
+                call_output["output"]["current_url"] = current_url
+
+            return [call_output]
+        return []
+
+    def run_full_turn(
+        self, input_items, print_steps=True, debug=False, show_images=False
+    ):
+        self.print_steps = print_steps
+        self.debug = debug
+        self.show_images = show_images
+        new_items = []
+
+        # keep looping until we get a final response
+        while new_items[-1].get("role") != "assistant" if new_items else True:
+            self.debug_print([sanitize_message(msg) for msg in input_items + new_items])
+
+            response = create_response(
+                model=self.model,
+                input=input_items + new_items,
+                tools=self.tools,
+                truncation="auto",
+            )
+            self.debug_print(response)
+
+            if "output" not in response and self.debug:
+                print(response)
+                raise ValueError("No output from model")
+            else:
+                new_items += response["output"]
+                for item in response["output"]:
+                    new_items += self.handle_item(item)
+
+        return new_items

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

@@ -14,17 +14,36 @@
 
 """Fleet Python SDK - Environment-based AI agent interactions."""
 
-from .exceptions import FleetError, FleetAPIError, FleetTimeoutError, FleetConfigurationError
+from .exceptions import (
+    FleetError,
+    FleetAPIError,
+    FleetTimeoutError,
+    FleetConfigurationError,
+)
 from .client import Fleet, AsyncFleet, InstanceRequest
+from .env import (
+    ResetRequest,
+    ResetResponse,
+    CDPDescribeResponse,
+    ChromeStartRequest,
+    ChromeStartResponse,
+    ChromeStatusResponse,
+)
 
 __version__ = "0.1.1"
 __all__ = [
     "env",
     "FleetError",
-    "FleetAPIError", 
+    "FleetAPIError",
     "FleetTimeoutError",
     "FleetConfigurationError",
     "Fleet",
     "AsyncFleet",
     "InstanceRequest",
-] 
+    "ResetRequest",
+    "ResetResponse",
+    "CDPDescribeResponse",
+    "ChromeStartRequest",
+    "ChromeStartResponse",
+    "ChromeStatusResponse",
+]

fleet_python-0.2.1/fleet/env/__init__.py

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

{fleet_python-0.2.0 → fleet_python-0.2.1}/fleet/env/client.py

@@ -15,6 +15,7 @@ from ..exceptions import FleetEnvironmentError, FleetAPIError
 
 from .base import SyncWrapper, AsyncWrapper
 from .models import (
+    ResetRequest,
     ResetResponse,
     Resource as ResourceModel,
     ResourceType,
@@ -26,7 +27,7 @@ logger = logging.getLogger(__name__)
 
 
 RESOURCE_TYPES = {
-    ResourceType.sqlite: AsyncSQLiteResource,
+    ResourceType.db: AsyncSQLiteResource,
     ResourceType.cdp: AsyncBrowserResource,
 }
 
@@ -66,17 +67,30 @@ class AsyncEnvironment:
     async def load(self) -> None:
         await self._load_resources()
 
-    async def reset(self) -> ResetResponse:
-        response = await self.client.request("POST", "/reset")
+    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 sqlite(self, name: str) -> AsyncSQLiteResource:
+    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.sqlite.value][name], self.client
+            self._resources_state[ResourceType.db.value][name], self.client
         )
 
     def browser(self, name: str) -> AsyncBrowserResource:
@@ -84,9 +98,13 @@ class AsyncEnvironment:
             self._resources_state[ResourceType.cdp.value][name], self.client
         )
 
-    async def resources(self) -> List[ResourceModel]:
+    async def resources(self) -> List[Resource]:
         await self._load_resources()
-        return self._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:
@@ -94,9 +112,9 @@ class AsyncEnvironment:
             if response.status_code != 200:
                 self._resources = []
                 return
-            data = response.json()
+            print(response.json())
             self._resources = [
-                ResourceModel(**resource) for resource in data["resources"]
+                ResourceModel(**resource) for resource in response.json()
             ]
             for resource in self._resources:
                 if resource.type not in self._resources_state:

{fleet_python-0.2.0 → fleet_python-0.2.1}/fleet/env/models.py

@@ -1,6 +1,6 @@
 # generated by datamodel-codegen:
-#   filename:  openapi_2.json
-#   timestamp: 2025-07-08T20:02:11+00:00
+#   filename:  openapi (2).json
+#   timestamp: 2025-07-09T20:11:31+00:00
 
 from __future__ import annotations
 
@@ -10,22 +10,27 @@ from typing import Any, Dict, List, Optional, Union
 from pydantic import BaseModel, Field
 
 
-class BrowserDescribeResponse(BaseModel):
+class CDPDescribeResponse(BaseModel):
     success: bool = Field(..., title="Success")
-    url: str = Field(..., title="Url")
-    devtools_url: str = Field(..., title="Devtools Url")
+    cdp_page_url: str = Field(..., title="Url")
+    cdp_browser_url: str = Field(..., title="Browser Url")
+    cdp_devtools_url: str = Field(..., title="Devtools Url")
 
 
-class BrowserStartRequest(BaseModel):
-    start_page: Optional[str] = Field("about:blank", title="Start Page")
+class ChromeStartRequest(BaseModel):
     resolution: Optional[str] = Field("1920x1080", title="Resolution")
 
 
-class BrowserStartResponse(BaseModel):
+class ChromeStartResponse(BaseModel):
     success: bool = Field(..., title="Success")
     message: str = Field(..., title="Message")
 
 
+class ChromeStatusResponse(BaseModel):
+    running: bool = Field(..., title="Running")
+    message: str = Field(..., title="Message")
+
+
 class CreateSnapshotsResponse(BaseModel):
     success: bool = Field(..., title="Success")
     initial_snapshot_path: Optional[str] = Field(None, title="Initial Snapshot Path")
@@ -69,8 +74,8 @@ class QueryResponse(BaseModel):
 
 
 class ResetRequest(BaseModel):
+    timestamp: Optional[int] = Field(None, title="Timestamp")
     seed: Optional[int] = Field(None, title="Seed")
-    timestamp: Optional[str] = Field(None, title="Timestamp")
 
 
 class ResetResponse(BaseModel):
@@ -84,7 +89,7 @@ class ResourceMode(Enum):
 
 
 class ResourceType(Enum):
-    sqlite = "sqlite"
+    db = "sqlite"
     cdp = "cdp"
 
 
@@ -121,7 +126,3 @@ class Resource(BaseModel):
     type: ResourceType
     mode: ResourceMode
     label: Optional[str] = Field(None, title="Label")
-
-
-class ResourcesResponse(BaseModel):
-    resources: List[Resource] = Field(..., title="Resources")

fleet_python-0.2.1/fleet/resources/browser.py

@@ -0,0 +1,34 @@
+from typing import Optional
+
+from ..env.models import (
+    Resource as ResourceModel,
+    CDPDescribeResponse,
+    ChromeStartRequest,
+    ChromeStartResponse,
+)
+from .base import Resource
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..env.base import AsyncWrapper
+
+
+class AsyncBrowserResource(Resource):
+    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+        super().__init__(resource)
+        self.client = client
+
+    async def start(
+        self, start_request: Optional[ChromeStartRequest] = None
+    ) -> ChromeStartResponse:
+        response = await self.client.request(
+            "POST",
+            "/resources/cdp/start",
+            json=start_request.model_dump() if start_request else None,
+        )
+        return ChromeStartResponse(**response.json())
+
+    async def describe(self) -> CDPDescribeResponse:
+        response = await self.client.request("GET", "/resources/cdp/describe")
+        return CDPDescribeResponse(**response.json())

{fleet_python-0.2.0 → fleet_python-0.2.1}/fleet/resources/sqlite.py

@@ -17,7 +17,7 @@ class AsyncSQLiteResource(Resource):
     async def describe(self) -> DescribeResponse:
         """Describe the SQLite database schema."""
         response = await self.client.request(
-            "GET", f"/resource/sqlite/{self.resource.name}/describe"
+            "GET", f"/resources/sqlite/{self.resource.name}/describe"
         )
         return DescribeResponse(**response.json())
 
@@ -35,7 +35,7 @@ class AsyncSQLiteResource(Resource):
         request = QueryRequest(query=query, args=args, read_only=read_only)
         response = await self.client.request(
             "POST",
-            f"/resource/sqlite/{self.resource.name}/query",
+            f"/resources/sqlite/{self.resource.name}/query",
             json=request.model_dump(),
         )
         return QueryResponse(**response.json())

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

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

{fleet_python-0.2.0 → fleet_python-0.2.1}/fleet_python.egg-info/SOURCES.txt

@@ -1,7 +1,9 @@
 LICENSE
 README.md
 pyproject.toml
-examples/browser_control_example.py
+examples/example.py
+examples/nova_act_example.py
+examples/openai_example.py
 examples/quickstart.py
 fleet/__init__.py
 fleet/base.py

{fleet_python-0.2.0 → fleet_python-0.2.1}/pyproject.toml

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

fleet_python-0.2.0/fleet/env/__init__.py

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

fleet_python-0.2.0/fleet/resources/browser.py

@@ -1,18 +0,0 @@
-from ..env.models import Resource as ResourceModel
-from ..env.models import BrowserDescribeResponse
-from .base import Resource
-
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from ..env.base import AsyncWrapper
-
-
-class AsyncBrowserResource(Resource):
-    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
-        super().__init__(resource)
-        self.client = client
-
-    async def describe(self) -> BrowserDescribeResponse:
-        response = await self.client.request("GET", "/resource/cdp/describe")
-        return BrowserDescribeResponse(**response.json())