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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.1
+Version: 0.2.3
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -31,6 +31,8 @@ Requires-Dist: black>=22.0.0; extra == "dev"
 Requires-Dist: isort>=5.0.0; extra == "dev"
 Requires-Dist: mypy>=1.0.0; extra == "dev"
 Requires-Dist: ruff>=0.1.0; extra == "dev"
+Provides-Extra: playwright
+Requires-Dist: playwright>=1.40.0; extra == "playwright"
 Dynamic: license-file
 
 # Fleet SDK

fleet_python-0.2.3/examples/dsl_example.py

@@ -0,0 +1,127 @@
+import asyncio
+import fleet as flt
+from fleet.verifiers import DatabaseSnapshot, IgnoreConfig, TASK_SUCCESSFUL_SCORE
+
+
+def validate_new_deal_creation(
+    before: DatabaseSnapshot,
+    after: DatabaseSnapshot,
+    transcript: str | None = None,
+) -> int:
+    """Validate that a new deal was created"""
+
+    # Find the new deal entry
+    new_deal = after.table("entries").eq("id", 32302).first()
+    if not new_deal:
+        raise AssertionError("Expected new deal with id 32302 not found")
+
+    # Verify it's a deal type
+    if new_deal["type"] != "deal":
+        raise AssertionError(
+            f"Expected entry type to be 'deal', got '{new_deal['type']}'"
+        )
+
+    # Verify the deal has a name (should be "testing" based on the diff)
+    if not new_deal["name"]:
+        raise AssertionError("Expected deal to have a name")
+
+    # Parse the properties JSON to check basic deal properties
+    import json
+
+    properties = json.loads(new_deal["properties"])
+
+    # Verify it has basic deal properties
+    if "dealstage" not in properties:
+        raise AssertionError("Expected deal to have a dealstage property")
+
+    if "deal_type" not in properties:
+        raise AssertionError("Expected deal to have a deal_type property")
+
+    if "priority" not in properties:
+        raise AssertionError("Expected deal to have a priority property")
+
+    # Configure ignore settings
+    ignore_config = IgnoreConfig(
+        tables={"pageviews"},
+        table_fields={
+            "entries": {"createdDate", "lastModifiedDate", "createdAt", "updatedAt"},
+        },
+    )
+
+    # Build expected changes
+    expected_changes = [
+        {
+            "table": "entries",
+            "pk": 32302,
+            "field": None,
+            "after": "__added__",
+        }
+    ]
+
+    before.diff(after, ignore_config).expect_only(expected_changes)
+    return TASK_SUCCESSFUL_SCORE
+
+
+async def main():
+    # Create a new instance
+    print("Creating new Hubspot instance...")
+    env = await flt.env.make("hubspot:v1.2.7")
+    print(f"New Instance: {env.instance_id}")
+
+    try:
+        # Reset the instance
+        response = await env.reset(seed=42)
+        print(f"Reset response: {response}")
+
+        # Run verifier before insertion (should fail)
+        print("\nRunning verifier before insertion...")
+        response = await env.verify(validate_new_deal_creation)
+        print(f"Success: {response.success}")
+        print(f"Result: {response.result}")
+        print(f"Error: {response.error}")
+        print(f"Message: {response.message}")
+
+        # Insert the deal entry
+        print("\nInserting deal entry...")
+        insert_query = """
+        INSERT INTO entries (id, name, type, owner_id, createdDate, lastModifiedDate, createdAt, updatedAt, archivedAt, properties)
+        VALUES (
+            32302,
+            'testing',
+            'deal',
+            1,
+            '2025-07-10T01:32:01.089Z',
+            '2025-07-10T01:32:01.089Z',
+            '2025-07-10 01:32:01',
+            '2025-07-10 01:32:01',
+            NULL,
+            '{"amount":null,"closedate":"2025-08-09","close_date":"2025-08-09","dealstage":"appointmentscheduled","pipeline":"default","description":null,"priority":"medium","deal_stage_probability":null,"deal_type":"newbusiness","hs_createdate":"2025-07-10T01:32:01.089Z","hs_object_source":"INTEGRATION","hs_object_source_id":"14696758","hs_object_source_label":"INTEGRATION","hs_is_closed":"false","hs_is_closed_count":"0","hs_is_closed_lost":"false","hs_is_closed_won":"false","hs_is_deal_split":"false","hs_is_open_count":"1","hs_num_associated_active_deal_registrations":"0","hs_num_associated_deal_registrations":"0","hs_num_associated_deal_splits":"0","hs_num_of_associated_line_items":"0","hs_num_target_accounts":"0","hs_number_of_call_engagements":"0","hs_number_of_inbound_calls":"0","hs_number_of_outbound_calls":"0","hs_number_of_overdue_tasks":"0","num_associated_contacts":"0","num_notes":"0","hs_closed_amount":"0","hs_closed_amount_in_home_currency":"0","hs_closed_deal_close_date":"0","hs_closed_deal_create_date":"0","hs_closed_won_count":"0","hs_v2_date_entered_current_stage":"2025-07-10T01:32:01.089Z","hs_v2_time_in_current_stage":"2025-07-10T01:32:01.089Z","hs_duration":"1752111121089","hs_open_deal_create_date":"1752111121089","days_to_close":"29","hs_days_to_close_raw":"29.936098506944443"}'
+        )
+        """
+
+        db = env.db()
+        insert_result = await db.exec(insert_query)
+        print(f"Insert result: {insert_result}")
+
+        # Verify the insertion
+        print("\nVerifying insertion...")
+        query_result = await db.query("SELECT * FROM entries WHERE id = 32302")
+        print(f"Query result: {query_result}")
+
+        # Run verifier after insertion (should succeed)
+        print("\nRunning verifier after insertion...")
+        response = await env.verify(validate_new_deal_creation)
+        print(f"Success: {response.success}")
+        print(f"Result: {response.result}")
+        print(f"Error: {response.error}")
+        print(f"Message: {response.message}")
+
+    finally:
+        # Delete the instance
+        print("\nDeleting instance...")
+        await env.close()
+        print("Instance deleted.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fleet_python-0.2.3/examples/example.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Example demonstrating browser control with Fleet Manager Client."""
+
+import asyncio
+import fleet as flt
+
+
+async def main():
+    environments = await flt.env.list_envs()
+    print("Environments:", len(environments))
+
+    # Create a new instance
+    env = await flt.env.make("hubspot:v1.2.7")
+    print("New Instance:", env.instance_id)
+
+    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 env.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fleet_python-0.2.3/examples/json_tasks_example.py

@@ -0,0 +1,82 @@
+import re
+import asyncio
+import argparse
+import json
+from typing import TypedDict, List
+from pathlib import Path
+import fleet as flt
+from nova_act import NovaAct, ActResult
+
+
+MAX_STEPS = 30
+
+
+class Problem(TypedDict):
+    id: str
+    problem: str
+    category: str
+    difficulty: str
+    verifier_func: str
+
+
+def extract_function_name(function_str: str) -> str | None:
+    match = re.search(r"(?:async\s+)?def\s+(\w+)\s*\(", function_str)
+    if match:
+        return match.group(1)
+    raise ValueError(f"No function name found in {function_str}")
+
+
+async def main():
+    parser = argparse.ArgumentParser(
+        description="Load and display Jira problems from JSON file"
+    )
+    parser.add_argument(
+        "json_file", type=str, help="Path to the JSON file containing problems"
+    )
+    args = parser.parse_args()
+
+    file_path = Path(args.json_file)
+    if not file_path.exists():
+        raise FileNotFoundError(f"Error: File '{args.json_file}' not found")
+
+    env = await flt.env.make("fira:v1.2.7")
+    print(f"New Instance: {env.urls.app}")
+
+    successes = 0
+
+    try:
+        with open(args.json_file, "r") as f:
+            data = json.load(f)
+        problems: List[Problem] = data["problems"]
+
+        print(f"Loaded {len(problems)} problems from '{args.json_file}'")
+
+        for i, problem in enumerate(problems):
+            print(f"Solving problem {i + 1} of {len(problems)}: {problem['id']}")
+            await env.reset()
+
+            def run_nova() -> ActResult:
+                with NovaAct(starting_page=env.urls.app, headless=True) as nova:
+                    return nova.act(problem["problem"], max_steps=MAX_STEPS)
+
+            try:
+                await asyncio.to_thread(run_nova)
+            except Exception as e:
+                print(f"Error: {e}")
+
+            function_name = extract_function_name(problem["verifier_func"])
+            print(f"Verifying {function_name} ({problem['id']})...")
+            response = await env.verify_raw(problem["verifier_func"], function_name)
+            print(response)
+            if response.success:
+                successes += 1
+
+        print(f"Successes: {successes}")
+        print(f"Total: {len(problems)}")
+        print(f"Success rate: {successes / len(problems)}")
+    finally:
+        await env.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fleet_python-0.2.3/examples/nova_act_example.py

@@ -0,0 +1,29 @@
+import asyncio
+import fleet as flt
+from nova_act import NovaAct, ActResult
+
+
+async def main():
+    instance = await flt.env.make("hubspot")
+    cdp_url = await instance.browser().cdp_url()
+
+    loop = asyncio.get_event_loop()
+
+    def run_nova() -> ActResult:
+        with NovaAct(
+            starting_page=instance.urls.app,
+            cdp_endpoint_url=cdp_url,
+            preview={"playwright_actuation": True},
+        ) as nova:
+            future = asyncio.run_coroutine_threadsafe(
+                instance.browser().devtools_url(), loop
+            )
+            print("Devtools URL:", future.result())
+            return nova.act("Create a deal")
+
+    await asyncio.to_thread(run_nova)
+    await instance.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fleet_python-0.2.3/examples/openai_example.py

@@ -0,0 +1,233 @@
+import asyncio
+from openai import AsyncOpenAI
+import fleet as flt
+import json
+from typing import Callable
+
+
+client = AsyncOpenAI()
+
+
+def sanitize_message(msg: dict) -> dict:
+    """Return a copy of the message with image_url omitted for computer_call_output messages."""
+    if msg.get("type") == "computer_call_output":
+        output = msg.get("output", {})
+        if isinstance(output, dict):
+            sanitized = msg.copy()
+            sanitized["output"] = {**output, "image_url": "[omitted]"}
+            return sanitized
+    return msg
+
+
+class Agent:
+    def __init__(
+        self,
+        browser,
+        model="computer-use-preview",
+        tools: list[dict] = [],
+        acknowledge_safety_check_callback: Callable = lambda: False,
+    ):
+        self.model = model
+        self.computer = browser
+        self.tools = tools
+        self.print_steps = True
+        self.debug = False
+        self.show_images = False
+        self.acknowledge_safety_check_callback = acknowledge_safety_check_callback
+
+        if browser:
+            dimensions = browser.get_dimensions()
+            self.tools += [
+                {
+                    "type": "computer-preview",
+                    "display_width": dimensions[0],
+                    "display_height": dimensions[1],
+                    "environment": browser.get_environment(),
+                },
+            ]
+
+    def debug_print(self, *args):
+        if self.debug:
+            print(*args)
+
+    async def handle_item(self, item):
+        """Handle each item; may cause a computer action + screenshot."""
+        if self.debug:
+            print(f"Handling item of type: {item.get('type')}")
+
+        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)
+                await 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)
+            await method(**action_args)
+
+            screenshot_base64 = await self.computer.screenshot()
+
+            # 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()
+                call_output["output"]["current_url"] = current_url
+
+            return [call_output]
+        return []
+
+    async 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])
+
+            # The Responses API rejects unknown keys (e.g. `status`, `encrypted_content`).
+            # Strip them from every item before sending.
+            def _clean_item(msg: dict) -> dict:
+                unwanted_keys = {"status", "encrypted_content"}
+                return {k: v for k, v in msg.items() if k not in unwanted_keys}
+
+            clean_input = [_clean_item(m) for m in (input_items + new_items)]
+
+            response = await client.responses.create(
+                model=self.model,
+                input=clean_input,
+                tools=self.tools,
+                truncation="auto",
+            )
+
+            # The OpenAI SDK returns a Pydantic model object, not a plain dict.
+            # Convert it to a standard Python dict so the rest of the code can
+            # remain unchanged from the previous implementation.
+            response_dict = (
+                response.model_dump()  # pydantic v2
+                if hasattr(response, "model_dump")
+                else (
+                    response.to_dict_recursive()
+                    if hasattr(response, "to_dict_recursive")
+                    else dict(response)
+                )
+            )
+            self.debug_print(response_dict)
+
+            # Guard against missing/empty output in the response
+            if not response_dict.get("output"):
+                if self.debug:
+                    print("Full response:", response_dict)
+                if response_dict.get("error") is not None:
+                    error_msg = response_dict["error"].get("message", "Unknown error")
+                    raise ValueError(f"API Error: {error_msg}")
+                else:
+                    raise ValueError("No output from model")
+
+            # Append each item from the model output to conversation history
+            # in the exact order we received them, **without filtering** so that
+            # required pairs such as reasoning → computer_call are preserved.
+            for item in response_dict["output"]:
+                # First, record the original item itself.
+                new_items.append(item)
+
+                # Next, perform any local side-effects (browser actions, etc.).
+                handled_items = await self.handle_item(item)
+
+                # If the handler generated additional items (e.g. computer_call_output)
+                # we append those *immediately* so the order remains:
+                #   reasoning → computer_call → computer_call_output
+                if handled_items:
+                    new_items += handled_items
+
+        return new_items
+
+
+tools = []
+
+
+async def ainput(prompt: str = "") -> str:
+    """Async version of input()"""
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(None, input, prompt)
+
+
+async def main():
+    # Create a Fleet environment instance
+    instance = await flt.env.make("hubspot")
+
+    # Create the Playwright wrapper
+    browser = flt.FleetPlaywrightWrapper(instance)
+    await browser.start()
+
+    try:
+        agent = Agent(browser, model="computer-use-preview", tools=[])
+        items = [
+            {
+                "role": "developer",
+                "content": "You have access to a clone of Hubspot. You can use the computer to navigate the browser and perform actions.",
+            }
+        ]
+
+        while True:
+            try:
+                user_input = await ainput("> ")
+                items.append({"role": "user", "content": user_input})
+                output_items = await agent.run_full_turn(
+                    items, show_images=False, debug=False
+                )
+                items += output_items
+            except (EOFError, KeyboardInterrupt):
+                print("\nShutting down...")
+                break
+            except Exception as e:
+                print(f"Error during interaction: {e}")
+                # Continue the loop for other errors
+    finally:
+        await browser.close()
+        await instance.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

fleet_python-0.2.3/examples/openai_simple_example.py

@@ -0,0 +1,61 @@
+import asyncio
+from openai import AsyncOpenAI
+import fleet as flt
+
+client = AsyncOpenAI()
+
+
+async def main():
+    instance = await flt.env.make("hubspot")
+
+    browser = flt.FleetPlaywrightWrapper(instance)
+    await browser.start()
+
+    try:
+        width, height = browser.get_dimensions()
+        tools = [
+            {
+                "type": "computer-preview",
+                "display_width": width,
+                "display_height": height,
+                "environment": browser.get_environment(),
+            }
+        ]
+
+        response = await client.responses.create(
+            model="computer-use-preview",
+            input=[
+                {
+                    "role": "developer",
+                    "content": "Create a HubSpot deal",
+                }
+            ],
+            tools=tools,
+            truncation="auto",
+        )
+
+        if len(response.output) != 0:
+            if response.output[0].type == "message":
+                print(response.output[0].content[0].text)
+
+            if response.output[0].type == "computer_call":
+                action = response.output[0].action
+                if action.type == "screenshot":
+                    screenshot_base64 = await browser.screenshot()
+                    result = {
+                        "type": "input_image",
+                        "image_url": f"data:image/png;base64,{screenshot_base64}",
+                        "current_url": browser.get_current_url(),
+                    }
+                else:
+                    result = await browser.execute_computer_action(action)
+
+                print("Computer action result:")
+                print(result)
+    finally:
+        await browser.close()
+        await instance.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fleet_python-0.2.1 → fleet_python-0.2.3}/examples/quickstart.py

@@ -35,7 +35,7 @@ async def main():
     # 1. List available environments
     print("\n📋 Available environments:")
     try:
-        environments = await fleet.env.list_envs()
+        environments = await fleet.instance.list_envs()
         for env in environments:
             print(f"  - {env.env_key}: {env.name}")
             print(f"    Description: {env.description}")
@@ -48,7 +48,7 @@ async def main():
     # 2. Create a new environment instance
     print("\n🚀 Creating new environment...")
     try:
-        env = await fleet.env.make("fira:v1.2.5", region="us-west-1")
+        env = await fleet.instance.make("fira:v1.2.5", region="us-west-1")
         print(f"✅ Environment created with instance ID: {env.instance_id}")
         
         # Execute a simple action
@@ -85,7 +85,7 @@ async def main():
     # 3. List running instances
     print("\n🏃 Listing running instances...")
     try:
-        instances = await fleet.env.list_instances(status="running")
+        instances = await fleet.instance.list_instances(status="running")
         if instances:
             print(f"Found {len(instances)} running instances:")
             for instance in instances:
@@ -99,13 +99,13 @@ async def main():
     print("\n🔗 Connecting to existing instance...")
     try:
         # Only get running instances
-        running_instances = await fleet.env.list_instances(status="running")
+        running_instances = await fleet.instance.list_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.env.get(target_instance.instance_id)
+            env = await fleet.instance.get(target_instance.instance_id)
             print(f"✅ Connected to instance: {env.instance_id}")
             
             # Execute an action on the existing instance

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

@@ -21,7 +21,8 @@ from .exceptions import (
     FleetConfigurationError,
 )
 from .client import Fleet, AsyncFleet, InstanceRequest
-from .env import (
+from .instance import (
+    AsyncInstanceClient,
     ResetRequest,
     ResetResponse,
     CDPDescribeResponse,
@@ -29,6 +30,16 @@ from .env import (
     ChromeStartResponse,
     ChromeStatusResponse,
 )
+from .verifiers import *
+from . import env
+
+# Optional playwright integration
+try:
+    from .playwright import FleetPlaywrightWrapper
+    _PLAYWRIGHT_AVAILABLE = True
+except ImportError:
+    FleetPlaywrightWrapper = None
+    _PLAYWRIGHT_AVAILABLE = False
 
 __version__ = "0.1.1"
 __all__ = [
@@ -39,6 +50,7 @@ __all__ = [
     "FleetConfigurationError",
     "Fleet",
     "AsyncFleet",
+    "AsyncInstanceClient",
     "InstanceRequest",
     "ResetRequest",
     "ResetResponse",
@@ -47,3 +59,7 @@ __all__ = [
     "ChromeStartResponse",
     "ChromeStatusResponse",
 ]
+
+# Add playwright wrapper to exports if available
+if _PLAYWRIGHT_AVAILABLE:
+    __all__.append("FleetPlaywrightWrapper")

{fleet_python-0.2.1 → fleet_python-0.2.3}/fleet/base.py

@@ -4,7 +4,7 @@ from typing import Dict, Any, Optional
 from .models import InstanceResponse
 
 
-class InstanceBase(InstanceResponse):
+class EnvironmentBase(InstanceResponse):
     @property
     def manager_url(self) -> str:
         return f"{self.urls.manager.api}"