fleet-python 0.2.13__tar.gz → 0.2.16__tar.gz

{fleet_python-0.2.13 → fleet_python-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.13
+Version: 0.2.16
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -25,6 +25,8 @@ Requires-Dist: pydantic>=2.0.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: httpx-retries>=0.4.0
 Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: modulegraph2>=0.2.0
+Requires-Dist: cloudpickle==3.1.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
@@ -114,44 +116,3 @@ running_instances = flt.env.list_instances(status_filter="running")
 # List available environment types
 available_envs = flt.env.list_envs()
 ```
-
-## Development
-
-### Code Structure
-
-This SDK uses `unasync` to maintain both async and sync versions of the code from a single source:
-
-- **`fleet/_async/`** - The source code (async version) - **EDIT THIS**
-- **`fleet/`** - The generated sync version - **DO NOT EDIT** (auto-generated)
-
-### Making Changes
-
-⚠️ **Important**: All code modifications should be made in the `fleet/_async/` directory. The synchronous versions in `fleet/` are automatically generated.
-
-1. Make your changes in `fleet/_async/`
-2. Run `make unasync` to generate the sync versions
-3. Test both async and sync versions
-4. Commit all changes (both async source and generated sync files)
-
-Example workflow:
-```bash
-# Edit the async source files
-vim fleet/_async/client.py
-
-# Generate sync versions
-make unasync
-
-# Run tests
-python examples/examle.py
-
-# Commit both source and generated files
-git add fleet/_async/ fleet/
-git commit -m "Add new feature"
-```
-
-### Why This Structure?
-
-- Single source of truth for business logic
-- Automatic sync/async API generation
-- Consistent behavior between sync and async versions
-- Easier maintenance and testing

{fleet_python-0.2.13 → fleet_python-0.2.16}/README.md

@@ -74,44 +74,3 @@ running_instances = flt.env.list_instances(status_filter="running")
 # List available environment types
 available_envs = flt.env.list_envs()
 ```
-
-## Development
-
-### Code Structure
-
-This SDK uses `unasync` to maintain both async and sync versions of the code from a single source:
-
-- **`fleet/_async/`** - The source code (async version) - **EDIT THIS**
-- **`fleet/`** - The generated sync version - **DO NOT EDIT** (auto-generated)
-
-### Making Changes
-
-⚠️ **Important**: All code modifications should be made in the `fleet/_async/` directory. The synchronous versions in `fleet/` are automatically generated.
-
-1. Make your changes in `fleet/_async/`
-2. Run `make unasync` to generate the sync versions
-3. Test both async and sync versions
-4. Commit all changes (both async source and generated sync files)
-
-Example workflow:
-```bash
-# Edit the async source files
-vim fleet/_async/client.py
-
-# Generate sync versions
-make unasync
-
-# Run tests
-python examples/examle.py
-
-# Commit both source and generated files
-git add fleet/_async/ fleet/
-git commit -m "Add new feature"
-```
-
-### Why This Structure?
-
-- Single source of truth for business logic
-- Automatic sync/async API generation
-- Consistent behavior between sync and async versions
-- Easier maintenance and testing

fleet_python-0.2.16/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()) 

{fleet_python-0.2.13 → fleet_python-0.2.16}/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)

fleet_python-0.2.16/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())

fleet_python-0.2.16/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())

fleet_python-0.2.16/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()

fleet_python-0.2.16/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())