fleet-python 0.2.12__py3-none-any.whl → 0.2.15__py3-none-any.whl

examples/diff_example.py

@@ -0,0 +1,161 @@
+import asyncio
+import fleet as flt
+from fleet.verifiers import IgnoreConfig
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+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}")
+
+        # Get the database resource
+        db = env.db()
+
+        # Take initial snapshot
+        print("\n=== Taking Initial Snapshot ===")
+        snapshot1 = await db.snapshot("initial_state")
+        print(f"Snapshot created: {snapshot1.name}")
+        
+        # Show current entries
+        entries_count = await db.table("entries").count()
+        print(f"Initial entry count: {entries_count}")
+
+        # Make some changes
+        print("\n=== Making Database Changes ===")
+        
+        # 1. Insert a new deal
+        print("\n1. Inserting new deal...")
+        await db.exec("""
+            INSERT INTO entries (id, name, type, owner_id, createdDate, lastModifiedDate, createdAt, updatedAt, properties)
+            VALUES (
+                99001,
+                'Test Deal 1',
+                'deal',
+                1,
+                datetime('now'),
+                datetime('now'),
+                datetime('now'),
+                datetime('now'),
+                '{}'
+            )
+        """)
+        
+        # 2. Update an existing entry
+        print("2. Updating existing entry...")
+        await db.exec("""
+            UPDATE entries 
+            SET name = 'Updated Contact Name'
+            WHERE id = 1
+        """)
+        
+        # 3. Insert another entry
+        print("3. Inserting another deal...")
+        await db.exec("""
+            INSERT INTO entries (id, name, type, owner_id, createdDate, lastModifiedDate, createdAt, updatedAt, properties)
+            VALUES (
+                99002,
+                'Test Deal 2',
+                'deal',
+                1,
+                datetime('now'),
+                datetime('now'),
+                datetime('now'),
+                datetime('now'),
+                '{}'
+            )
+        """)
+
+        # Take second snapshot
+        print("\n=== Taking Second Snapshot ===")
+        snapshot2 = await db.snapshot("after_changes")
+        print(f"Snapshot created: {snapshot2.name}")
+        
+        new_entries_count = await db.table("entries").count()
+        print(f"New entry count: {new_entries_count}")
+
+        # Compare snapshots
+        print("\n=== Comparing Snapshots ===")
+        
+        # Configure what to ignore in diff
+        ignore_config = IgnoreConfig(
+            tables={"pageviews"},  # Ignore entire pageviews table
+            fields={"createdDate", "lastModifiedDate", "createdAt", "updatedAt"},  # Ignore timestamp fields
+        )
+        
+        diff = await snapshot1.diff(snapshot2, ignore_config)
+        
+        # Test 1: Validate all expected changes
+        print("\nTest 1: Validating expected changes...")
+        expected_changes = [
+            # New deals added
+            {"table": "entries", "pk": 99001, "field": None, "after": "__added__"},
+            {"table": "entries", "pk": 99002, "field": None, "after": "__added__"},
+            # Name updated
+            {"table": "entries", "pk": 1, "field": "name", "after": "Updated Contact Name"},
+        ]
+        
+        try:
+            await diff.expect_only(expected_changes)
+            print("✓ All changes validated successfully!")
+        except AssertionError as e:
+            print(f"✗ Validation failed: {e}")
+
+        # Test 2: Try with incorrect expectations (should fail)
+        print("\nTest 2: Testing with incorrect expectations...")
+        incorrect_changes = [
+            {"table": "entries", "pk": 99001, "field": None, "after": "__added__"},
+            # Missing the second insert and the update
+        ]
+        
+        try:
+            await diff.expect_only(incorrect_changes)
+            print("✗ This should have failed!")
+        except AssertionError as e:
+            print("✓ Correctly detected unexpected changes")
+            print(f"   Error (first 200 chars): {str(e)[:200]}...")
+
+        # Test 3: Query snapshot data directly
+        print("\n=== Querying Snapshot Data ===")
+        
+        # Query from first snapshot
+        print("\nQuerying from initial snapshot:")
+        initial_entry = await snapshot1.table("entries").eq("id", 1).first()
+        if initial_entry:
+            print(f"Entry 1 name in snapshot1: {initial_entry['name']}")
+        
+        # Query from second snapshot
+        print("\nQuerying from second snapshot:")
+        updated_entry = await snapshot2.table("entries").eq("id", 1).first()
+        if updated_entry:
+            print(f"Entry 1 name in snapshot2: {updated_entry['name']}")
+        
+        # Count deals in each snapshot
+        deals_before = await snapshot1.table("entries").eq("type", "deal").all()
+        deals_after = await snapshot2.table("entries").eq("type", "deal").all()
+        print(f"\nDeals in snapshot1: {len(deals_before)}")
+        print(f"Deals in snapshot2: {len(deals_after)}")
+        
+        # Show new deals
+        print("\nNew deals added:")
+        for deal in deals_after:
+            if deal['id'] in [99001, 99002]:
+                print(f"  - {deal['name']} (id: {deal['id']})")
+
+    finally:
+        # Delete the instance
+        print("\n\nDeleting instance...")
+        await env.close()
+        print("Instance deleted.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

examples/dsl_example.py

@@ -84,6 +84,14 @@ async def main():
         print(f"Error: {response.error}")
         print(f"Message: {response.message}")
 
+        # Get the database resource
+        db = env.db()
+        
+        # Take a snapshot before insertion
+        print("\nTaking snapshot before insertion...")
+        snapshot_before = await db.snapshot("before_insertion")
+        print(f"Snapshot created: {snapshot_before.name}")
+
         # Insert the deal entry
         print("\nInserting deal entry...")
         insert_query = """
@@ -103,7 +111,6 @@ async def main():
         """
 
         print("RESOURCES", await env.resources())
-        db = env.db()
         insert_result = await db.exec(insert_query)
         print(f"Insert result: {insert_result}")
 
@@ -112,6 +119,48 @@ async def main():
         query_result = await db.query("SELECT * FROM entries WHERE id = 32302")
         print(f"Query result: {query_result}")
 
+        # Also verify using the new query builder
+        print("\nVerifying with query builder:")
+        entry = await db.table("entries").eq("id", 32302).first()
+        if entry:
+            print(f"Found entry: {entry['name']} (type: {entry['type']})")
+            # Can also use assertions
+            await db.table("entries").eq("id", 32302).assert_eq("type", "deal")
+            print("✓ Entry type assertion passed")
+
+        # Take a snapshot after insertion
+        print("\nTaking snapshot after insertion...")
+        snapshot_after = await db.snapshot("after_insertion")
+        print(f"Snapshot created: {snapshot_after.name}")
+
+        # Compare snapshots
+        print("\nComparing snapshots...")
+        ignore_config = IgnoreConfig(
+            tables={"pageviews"},
+            table_fields={
+                "entries": {"createdDate", "lastModifiedDate", "createdAt", "updatedAt"},
+            },
+        )
+        
+        diff = await snapshot_before.diff(snapshot_after, ignore_config)
+        
+        # Check diff results
+        print("\nDiff validation:")
+        expected_changes = [
+            {
+                "table": "entries",
+                "pk": 32302,
+                "field": None,
+                "after": "__added__",
+            }
+        ]
+        
+        try:
+            await diff.expect_only(expected_changes)
+            print("✓ Diff validation passed - only expected changes detected")
+        except AssertionError as e:
+            print(f"✗ Diff validation failed: {e}")
+
         # Run verifier after insertion (should succeed)
         print("\nRunning verifier after insertion...")
         response = await env.verify(validate_new_deal_creation)

examples/example.py

@@ -16,7 +16,7 @@ async def main():
     print("Environments:", len(environments))
 
     # Create a new instance
-    env = await flt.env.make_async("hubspot:v1.2.7")
+    env = await flt.env.make_async("hubspot")
     print(f"New Instance: {env.instance_id} ({env.region})")
 
     response = await env.reset(seed=42)

examples/example_action_log.py

@@ -0,0 +1,28 @@
+#!/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():
+    # Create a new instance
+    env = await flt.env.make_async("fira:v1.3.2")
+    print(f"New Instance: {env.instance_id} ({env.region})")
+    print("URL:", env.urls.app)
+
+    print(await env.resources())
+
+    sqlite = env.db("action_log")
+    print("SQLite:", await sqlite.describe())
+
+    print("Query:", await sqlite.query("SELECT * FROM action_log"))
+
+    await env.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/example_mcp_anthropic.py

@@ -0,0 +1,77 @@
+import asyncio
+import fleet as flt
+from anthropic import AsyncAnthropic
+from mcp import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = AsyncAnthropic()
+
+
+async def main():
+    env = flt.env.make("fira:v1.3.3")
+    print("Created environment:", env.urls.app)
+    print("MCP URL:", env.mcp.url)
+
+    async with streamablehttp_client(url=env.mcp.url) as streams:
+        async with ClientSession(read_stream=streams[0], write_stream=streams[1]) as session:
+            await session.initialize()
+
+            list_tools = await session.list_tools()
+            available_tools = [
+                {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "input_schema": tool.inputSchema,
+                }
+                for tool in list_tools.tools
+            ]
+
+
+            messages = [
+                {
+                    "role": "user",
+                    "content": "Get the current authorized user.",
+                },
+            ]
+            response = await client.beta.messages.create(
+                model="claude-sonnet-4-20250514",
+                max_tokens=1000,
+                messages=messages,
+                tools=available_tools,
+            )
+
+            tool_results = []
+            output_text = []
+            for content in response.content:
+                if content.type == "text":
+                    output_text.append(content.text)
+                elif content.type == "tool_use":
+                    tool_name = content.name
+                    tool_args = content.input
+
+                    result = await session.call_tool(tool_name, tool_args)
+                    tool_results.append({"call": tool_name, "result": result})
+                    output_text.append(f"[Calling tool {tool_name} with args {tool_args}]")
+
+                    if hasattr(content, "text") and content.text:
+                        messages.append({"role": "assistant", "content": content.text})
+                    messages.append({"role": "user", "content": result.content})
+
+                    response = await client.messages.create(
+                        model="claude-sonnet-4-20250514",
+                        max_tokens=1000,
+                        messages=messages,
+                    )
+
+                    output_text.append(response.content[0].text)
+
+            print("\n".join(output_text))
+
+    env.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/example_mcp_openai.py

@@ -0,0 +1,27 @@
+import fleet as flt
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = OpenAI()
+
+
+def main():
+    env = flt.env.make("fira:v1.3.3")
+    print("Created environment:", env.urls.app)
+    print("MCP URL:", env.mcp.url)
+
+    response = client.responses.create(
+        model="gpt-4.1",
+        tools=[env.mcp.openai()],
+        input="Get the current authorized user.",
+    )
+
+    print(response.output_text)
+
+    env.close()
+
+
+if __name__ == "__main__":
+    main()

examples/example_sync.py

@@ -15,7 +15,7 @@ def main():
     print("Instances:", len(instances))
 
     # Create a new instance
-    env = flt.env.make("hubspot:v1.2.7")
+    env = flt.env.make("hubspot")
     print("New Instance:", env.instance_id)
 
     response = env.reset(seed=42)

examples/example_task.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""Example demonstrating task with verifier for Jira environment.
+
+This example shows how to create a simple task with the @verifier decorator
+that can be verified in a Jira environment.
+
+Note: The remote execution environment only supports synchronous verifiers.
+For async environments, we need separate sync and async verifiers.
+"""
+
+import os
+import asyncio
+from datetime import datetime
+from fleet import AsyncFleet, verifier, TASK_SUCCESSFUL_SCORE, Task
+from dotenv import load_dotenv
+
+# Constants for task failure
+TASK_FAILED_SCORE = 0.0
+
+load_dotenv()
+
+
+# For remote execution, use a synchronous verifier
+# This won't work locally with async environments, but works remotely
+@verifier(key="create_bug_issue_sync")
+def create_bug_issue_sync(
+    env, project_key: str = "SCRUM", issue_title: str = "Sample Bug"
+) -> float:
+    """Synchronous verifier for remote execution.
+    
+    Note: This is designed for remote execution where env.db() returns sync resources.
+    """
+    # Define constants locally for remote execution
+    TASK_SUCCESSFUL_SCORE = 1.0
+    TASK_FAILED_SCORE = 0.0
+    
+    try:
+        # Get the database resource
+        db = env.db()
+
+        # Query for issues with the specified title and project
+        query = """
+        SELECT id, issue_type, name, project_key 
+        FROM issues 
+        WHERE project_key = ? AND name = ? AND issue_type = 'Bug'
+        """
+
+        result = db.query(query, args=[project_key, issue_title])
+
+        if result.rows and len(result.rows) > 0:
+            print(f"✓ Found bug issue: {result.rows[0][0]} - {result.rows[0][2]}")
+            return TASK_SUCCESSFUL_SCORE
+        else:
+            print(
+                f"✗ No bug issue found with title '{issue_title}' in project {project_key}"
+            )
+            return TASK_FAILED_SCORE
+
+    except Exception as e:
+        print(f"✗ Error checking for bug issue: {e}")
+        return TASK_FAILED_SCORE
+
+
+# For local execution with async environments
+@verifier(key="create_bug_issue_async")
+async def create_bug_issue_async(
+    env, project_key: str = "SCRUM", issue_title: str = "Sample Bug"
+) -> float:
+    """Async verifier for local execution with async environments."""
+    try:
+        # Get the database resource
+        db = env.db()
+
+        # Query for issues with the specified title and project
+        query = """
+        SELECT id, issue_type, name, project_key 
+        FROM issues 
+        WHERE project_key = ? AND name = ? AND issue_type = 'Bug'
+        """
+
+        result = await db.query(query, args=[project_key, issue_title])
+
+        if result.rows and len(result.rows) > 0:
+            print(f"✓ Found bug issue: {result.rows[0][0]} - {result.rows[0][2]}")
+            return TASK_SUCCESSFUL_SCORE
+        else:
+            print(
+                f"✗ No bug issue found with title '{issue_title}' in project {project_key}"
+            )
+            return TASK_FAILED_SCORE
+
+    except Exception as e:
+        print(f"✗ Error checking for bug issue: {e}")
+        return TASK_FAILED_SCORE
+
+
+async def main():
+    """Run the task example."""
+    print("=== Fleet Task Example with Jira ===\n")
+    print("Note: Remote execution only supports synchronous verifiers.\n")
+
+    # Create task using the async verifier for local execution
+    task = Task(
+        key="create-sample-bug",
+        prompt="Create a new bug issue titled 'Login button not working' in the SCRUM project",
+        env_id="fira:v1.3.1",
+        verifier=create_bug_issue_async,
+        metadata={"category": "issue_creation", "difficulty": "easy"},
+    )
+
+    print(f"Task definition:")
+    print(f"  Key: {task.key}")
+    print(f"  Prompt: {task.prompt}")
+    print(f"  Environment: {task.env_id}")
+    print(f"  Verifier: {task.verifier.key if hasattr(task.verifier, 'key') else 'create_bug_issue'}")
+    print(f"  Created at: {task.created_at}")
+    print(f"  Metadata: {task.metadata}")
+    print()
+
+    # Create Fleet client and environment
+    fleet_client = AsyncFleet()
+
+    print("Creating Jira environment...")
+    try:
+        # Create a new Jira v1.3.1 environment
+        env = await fleet_client.make("fira:v1.3.1")
+        print(f"✓ Environment created: {env.instance_id}")
+        print(f"  URL: {env.manager_url}")
+        print()
+
+        # Run the async verifier locally
+        print("Running async verifier locally...")
+        result = await create_bug_issue_async(
+            env, project_key="SCRUM", issue_title="Login button not working"
+        )
+        print(f"  Initial check result: {result}")
+        print()
+
+        # Test remote execution with sync verifier
+        print("Testing remote execution with sync verifier...")
+        try:
+            # Use the sync verifier for remote execution
+            remote_result = await create_bug_issue_sync.remote(
+                env, project_key="SCRUM", issue_title="Login button not working"
+            )
+            print(f"  ✓ Remote check result: {remote_result}")
+            print(f"  ✓ Both returned failure as expected (issue doesn't exist yet)")
+        except NotImplementedError as e:
+            print(f"  ℹ️  {e}")
+        except Exception as e:
+            print(f"  ✗ Remote execution failed: {e}")
+        print()
+
+        # Demonstrate that async verifiers can't run remotely
+        print("Attempting remote execution with async verifier...")
+        try:
+            await create_bug_issue_async.remote(env)
+        except NotImplementedError as e:
+            print(f"  ✓ Expected error: {e}")
+        print()
+
+        # Create the issue
+        print("Creating the bug issue programmatically...")
+        db = env.db()
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+        await db.exec(
+            """
+            INSERT INTO issues (id, project_key, issue_type, name, status, created_at, updated_at)
+            VALUES ('SCRUM-9999', 'SCRUM', 'Bug', 'Login button not working', 'Todo', ?, ?)
+        """,
+            args=[timestamp, timestamp],
+        )
+
+        print("✓ Bug issue created")
+        print()
+
+        # Run verifier again locally
+        print("Running async verifier locally after creating the issue...")
+        result = await create_bug_issue_async(
+            env, project_key="SCRUM", issue_title="Login button not working"
+        )
+        print(f"  Final check result: {result}")
+        print(f"  Task {'completed successfully' if result == TASK_SUCCESSFUL_SCORE else 'failed'}!")
+        print()
+
+        # Clean up
+        print("Cleaning up...")
+        await env.close()
+        print("✓ Environment closed")
+
+    except Exception as e:
+        print(f"✗ Error: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/example_verifier.py

@@ -0,0 +1,71 @@
+import fleet as flt
+from fleet.verifiers.verifier import verifier
+from fleet.verifiers.db import IgnoreConfig
+
+
+@verifier(key="validate_finish_blue_green_deployment")
+def validate_finish_blue_green_deployment(
+    env: flt.Environment, final_answer: str | None = None
+) -> int:
+    """Validate that DEBT-722 and DEBT-720 are marked as Done"""
+    before = env.db("seed")
+    after = env.db("current")
+
+    # Check final state
+    try:
+        after.table("issues").eq("id", "DEBT-722").assert_eq("board_list", "Done")
+    except:
+        return 0
+    try:
+        after.table("issues").eq("id", "DEBT-720").assert_eq("board_list", "Done")
+    except:
+        return 0
+
+    # Configure ignore settings for this validation
+    ignore_config = IgnoreConfig(
+        tables={"activities", "pageviews"},
+        table_fields={
+            "issues": {"updated_at", "created_at", "rowid"},
+            "boards": {"updated_at", "created_at", "rowid"},
+            "projects": {"updated_at", "created_at", "rowid"},
+            "sprints": {"updated_at", "created_at", "rowid"},
+            "users": {"updated_at", "created_at", "rowid"},
+        },
+    )
+
+    # Enforce invariant: nothing else changed (with ignore configuration)
+    try:
+        before.diff(after, ignore_config).expect_only(
+            [
+                {
+                    "table": "issues",
+                    "pk": "DEBT-722",
+                    "field": "board_list",
+                    "after": "Done",
+                },
+                {
+                    "table": "issues",
+                    "pk": "DEBT-720",
+                    "field": "board_list",
+                    "after": "Done",
+                },
+            ]
+        )
+    except:
+        return 0
+
+    return 1
+
+
+def main():
+    env = flt.env.make("fira:v1.3.1")
+    print(f"New Instance: {env.instance_id}")
+
+    print(validate_finish_blue_green_deployment(env))
+    print(validate_finish_blue_green_deployment.remote(env))
+
+    env.close()
+
+
+if __name__ == "__main__":
+    main()