fleet-python 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

examples/dsl_example.py

@@ -1,112 +1,128 @@
-from fleet.verifiers import DatabaseSnapshot, IgnoreConfig
+import asyncio
+import fleet as flt
+from fleet.verifiers import DatabaseSnapshot, IgnoreConfig, TASK_SUCCESSFUL_SCORE
 
-async def validate_give_me_more_tasks(
+
+def validate_new_deal_creation(
     before: DatabaseSnapshot,
     after: DatabaseSnapshot,
     transcript: str | None = None,
 ) -> int:
-    """Validate that bugs are moved to sprint 3 and assigned correctly."""
-
-    # Get user IDs
-    raj_user = after.table("users").eq("name", "Raj Patel").first()
-    sarah_kim_user = after.table("users").eq("name", "Sarah Kim").first()
-
-    if not raj_user:
-        raise AssertionError("User 'Raj Patel' not found")
-    if not sarah_kim_user:
-        raise AssertionError("User 'Sarah Kim' not found")
-
-    raj_id = raj_user["id"]
-    sarah_kim_id = sarah_kim_user["id"]
-
-    # Verify SCRUM-555 (data pipeline bug) is assigned to Sarah Kim
-    after.table("issues").eq("id", "SCRUM-555").assert_eq("owner", sarah_kim_id)
-
-    # Verify other bugs are assigned to Raj Patel
-    other_bugs = [
-        "SCRUM-780",
-        "SCRUM-781",
-        "SCRUM-790",
-        "SCRUM-822",
-        "SCRUM-882",
-        "SCRUM-897",
-        "SCRUM-956",
-        "SCRUM-1331",
-        "SCRUM-1312",
-        "SCRUM-1210",
-        "SCRUM-1230",
-        "SCRUM-1282",
-    ]
-    for bug_id in other_bugs:
-        after.table("issues").eq("id", bug_id).assert_eq("owner", raj_id)
-
-    # Verify all bugs are in sprint_3
-    all_bugs = ["SCRUM-555"] + other_bugs
-    for bug_id in all_bugs:
-        after.table("sprint_issues").eq("issue_id", bug_id).assert_eq(
-            "sprint_id", "sprint_3"
+    """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={"activities", "pageviews", "sprint_issues"},
+        tables={"pageviews"},
         table_fields={
-            "issues": {"updated_at", "created_at", "rowid"},
-            "users": {"updated_at", "created_at", "rowid"},
-            "sprint_issues": {"updated_at", "created_at", "rowid"},
+            "entries": {"createdDate", "lastModifiedDate", "createdAt", "updatedAt"},
         },
     )
 
     # Build expected changes
-    expected_changes: list[dict] = []
-
-    # Assignment changes
-    expected_changes.append(
+    expected_changes = [
         {
-            "table": "issues",
-            "pk": "SCRUM-555",
-            "field": "owner",
-            "after": sarah_kim_id,
+            "table": "entries",
+            "pk": 32302,
+            "field": None,
+            "after": "__added__",
         }
-    )
-    for bug_id in other_bugs:
-        expected_changes.append(
-            {
-                "table": "issues",
-                "pk": bug_id,
-                "field": "owner",
-                "after": raj_id,
-            }
-        )
+    ]
 
-    # Sprint changes
-    for bug_id in all_bugs:
-        # Remove from previous sprint if present
-        before_assignment = (
-            before.table("sprint_issues").eq("issue_id", bug_id).first()
-        )
-        if before_assignment:
-            old_sprint = before_assignment.get("sprint_id")
-            expected_changes.append(
-                {
-                    "table": "sprint_issues",
-                    "pk": (old_sprint, bug_id),
-                    "field": None,
-                    "after": "__removed__",
-                }
-            )
-
-        # Add to sprint_3
-        expected_changes.append(
-            {
-                "table": "sprint_issues",
-                "pk": ("sprint_3", bug_id),
-                "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_async("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"}'
         )
+        """
 
-    # Enforce invariant
-    before.diff(after, ignore_config).expect_only(expected_changes)
+        print("RESOURCES", await env.resources())
+        db = env.db()
+        insert_result = await db.exec(insert_query)
+        print(f"Insert result: {insert_result}")
 
-    return TASK_SUCCESSFUL_SCORE
+        # 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())

examples/example.py

@@ -6,11 +6,11 @@ import fleet as flt
 
 
 async def main():
-    environments = await flt.env.list_envs()
+    environments = await flt.env.list_envs_async()
     print("Environments:", len(environments))
 
     # Create a new instance
-    env = await flt.env.make("hubspot:v1.2.7")
+    env = await flt.env.make_async("hubspot:v1.2.7")
     print("New Instance:", env.instance_id)
 
     response = await env.reset(seed=42)

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_async("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())

examples/nova_act_example.py

@@ -1,180 +1,29 @@
-"""
-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")
+from nova_act import NovaAct, ActResult
 
 
 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 flt.env.make_async("hubspot:v1.2.7")
+    cdp_url = await instance.browser().cdp_url()
 
-    instance = await fleet.instance("05bd8217")
+    loop = asyncio.get_event_loop()
 
-    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
+    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")
 
-    except Exception as e:
-        print(f"❌ Error in main flow: {type(e).__name__}: {str(e)}")
-        import traceback
-        traceback.print_exc()
+    await asyncio.to_thread(run_nova)
+    await instance.close()
 
 
 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()
+    asyncio.run(main())