fleet-python 0.2.32__py3-none-any.whl → 0.2.34__py3-none-any.whl

examples/exampleResume.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+Interactive Browser Snapshot/Resume Example
+
+This script:
+1. Creates an environment and browser
+2. Lets you interact with it manually
+3. Takes a snapshot when you type 'close'
+4. Resumes from the snapshot with a new environment
+"""
+
+import json
+import os
+import sys
+from datetime import datetime
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from fleet import Fleet
+
+def main():
+    # Initialize Fleet client
+    api_key = os.getenv("FLEET_API_KEY")
+    if not api_key:
+        print("Error: FLEET_API_KEY environment variable not set")
+        sys.exit(1)
+    
+    fleet = Fleet(api_key=api_key)
+    
+    # Initialize environment variables
+    env = None
+    new_env = None
+    
+    try:
+        # Step 1: Create environment and browser
+        print("🚀 Creating new environment...")
+        env_key = "fira:v1.3.2"  
+        
+        env = fleet.make(env_key)
+        print(f"✅ Environment created: {env.instance_id}")
+        print(f"📝 Session ID: {env.session_id}")
+        
+        # Start browser
+        print("\n🌐 Starting browser...")
+        browser = env.browser()
+        browser.start(width=1920, height=1080)
+        
+        # Get browser URLs with session ID for automatic logging
+        cdp_page_url = browser.cdp_page_url()
+        cdp_browser_url = browser.cdp_browser_url()
+        devtools_url = browser.devtools_url()
+        
+        print(f"✅ Browser started!")
+        print(f"🔗 CDP Page URL: {cdp_page_url}")
+        print(f"🔗 CDP Browser URL: {cdp_browser_url}")
+        print(f"🔗 DevTools URL: {devtools_url}")
+        
+        # Show connection info for debugging
+        conn_info = browser.get_connection_info()
+        print(f"📊 Logging enabled: {conn_info['logging_enabled']}")
+        if conn_info['logging_enabled']:
+            print(f"📝 All CDP actions will be automatically logged to session: {env.session_id}")
+        
+        # Step 2: Wait for user interaction
+        print("\n" + "="*60)
+        print("🎮 INTERACTIVE MODE")
+        print("="*60)
+        print("You can now interact with the browser manually.")
+        print("Open the DevTools URL in Chrome to see and control the browser.")
+        print("\nType 'close' and press Enter when you're done to save a snapshot.")
+        print("="*60 + "\n")
+        
+        while True:
+            user_input = input(">>> ").strip().lower()
+            
+            if user_input == "close":
+                break
+            elif user_input == "status":
+                print(f"Environment: {env.instance_id}")
+                print(f"Session: {env.session_id}")
+            else:
+                print("Type 'close' to save snapshot and exit, or 'status' to see current info")
+        
+        # Step 3: Take snapshot
+        print("\n📸 Taking snapshot...")
+        snapshot = env.get_snapshot(browser)
+        
+        # Save snapshot to file
+        snapshot_file = f"snapshot_{env.session_id}_{int(datetime.now().timestamp())}.json"
+        with open(snapshot_file, "w") as f:
+            json.dump(snapshot.model_dump(), f, indent=2)
+        
+        print(f"✅ Snapshot saved to: {snapshot_file}")
+        print(f"   - Tool logs: {len(snapshot.tool_logs)} entries")
+        print(f"   - Action logs: {len(snapshot.action_logs)} entries")
+        print(f"   - Page URL: {snapshot.page_url}")
+        print(f"   - Viewport: {snapshot.viewport_size}")
+        
+        # Close original environment
+        print("\n🏁 Closing original environment...")
+        env.close()
+        env = None  # Mark as closed
+        
+        # Step 4: Resume from snapshot
+        print("\n" + "="*60)
+        print("🔄 RESUMING FROM SNAPSHOT")
+        print("="*60)
+        
+        input("\nPress Enter to resume from snapshot...")
+        
+        print("\n🚀 Creating new environment from snapshot...")
+        new_env, validation = fleet.resume(
+            snapshot,
+            validate=True,
+            playback_speed=2.0  # Replay at 2x speed
+        )
+        
+        print(f"✅ Environment resumed: {new_env.instance_id}")
+        print(f"📝 New session ID: {new_env.session_id}")
+        
+        # Show validation results
+        print(f"\n📊 Validation Results:")
+        print(f"   - Success: {validation.success}")
+        print(f"   - Page match: {validation.page_match}")
+        print(f"   - Action log match: {validation.action_log_match}")
+        
+        if validation.discrepancies:
+            print(f"   - Discrepancies ({len(validation.discrepancies)}):")
+            for disc in validation.discrepancies[:5]:  # Show first 5
+                print(f"     • {disc}")
+            if len(validation.discrepancies) > 5:
+                print(f"     • ... and {len(validation.discrepancies) - 5} more")
+        
+        # Get new browser reference
+        new_browser = new_env.browser()
+        print(f"\n🌐 New browser ready!")
+        print(f"🔗 CDP Page URL: {new_browser.cdp_page_url()}")
+        print(f"🔗 DevTools URL: {new_browser.devtools_url()}")
+        print(f"📝 Resume session logging to: {new_env.session_id}")
+        
+        # Step 5: Keep new environment open for inspection
+        print("\n" + "="*60)
+        print("🎮 RESUMED ENVIRONMENT READY")
+        print("="*60)
+        print("The resumed environment is now ready. You can inspect it to verify")
+        print("it matches your original state.")
+        print("\nType 'done' when finished to close the resumed environment.")
+        print("="*60 + "\n")
+        
+        while True:
+            user_input = input(">>> ").strip().lower()
+            
+            if user_input == "done":
+                break
+            elif user_input == "status":
+                print(f"Environment: {new_env.instance_id}")
+                print(f"Session: {new_env.session_id}")
+            else:
+                print("Type 'done' to close the environment, or 'status' to see current info")
+        
+        # Clean up
+        print("\n🏁 Closing resumed environment...")
+        new_env.close()
+        new_env = None  # Mark as closed
+        print("✅ All done!")
+        
+    except KeyboardInterrupt:
+        print("\n\n⚠️  Interrupted by user")
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+    finally:
+        # Always clean up environments
+        if env is not None:
+            try:
+                print("\n🧹 Cleaning up original environment...")
+                env.close()
+                print("✅ Original environment closed")
+            except Exception as e:
+                print(f"⚠️  Failed to close original environment: {e}")
+        
+        if new_env is not None:
+            try:
+                print("\n🧹 Cleaning up resumed environment...")
+                new_env.close()
+                print("✅ Resumed environment closed")
+            except Exception as e:
+                print(f"⚠️  Failed to close resumed environment: {e}")
+
+
+if __name__ == "__main__":
+    main()

examples/test_cdp_logging.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""
+Test CDP Logging Example
+
+This script demonstrates the new automatic CDP logging functionality.
+All CDP commands and events are now logged automatically at the proxy level.
+"""
+
+import os
+import sys
+from datetime import datetime
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from fleet import Fleet
+
+def main():
+    # Initialize Fleet client
+    api_key = os.getenv("FLEET_API_KEY")
+    if not api_key:
+        print("Error: FLEET_API_KEY environment variable not set")
+        sys.exit(1)
+    
+    fleet = Fleet(api_key=api_key)
+    env = None
+    
+    try:
+        # Create environment
+        print("🚀 Creating new environment...")
+        env_key = "fira:v1.3.2"  # Replace with your actual environment key
+        
+        env = fleet.make(env_key)
+        print(f"✅ Environment created: {env.instance_id}")
+        print(f"📝 Session ID: {env.session_id}")
+        
+        # Start browser
+        print("\n🌐 Starting browser with automatic CDP logging...")
+        browser = env.browser()
+        browser.start(width=1920, height=1080)
+        
+        # Show connection information
+        conn_info = browser.get_connection_info()
+        print("\n📊 Connection Information:")
+        print(f"  Session ID: {conn_info['session_id']}")
+        print(f"  CDP Page URL: {conn_info['cdp_page_url']}")
+        print(f"  CDP Browser URL: {conn_info['cdp_browser_url']}")
+        print(f"  Logging Enabled: {conn_info['logging_enabled']}")
+        
+        if conn_info['logging_enabled']:
+            print(f"\n✅ All CDP actions will be automatically logged!")
+            print(f"   - Connect any CDP client to: {conn_info['cdp_page_url']}")
+            print(f"   - All commands and events will be logged to session: {env.session_id}")
+            print(f"   - Use DevTools at: {conn_info['devtools_url']}")
+        else:
+            print(f"\n⚠️  Logging not enabled - no session ID available")
+        
+        print("\n" + "="*60)
+        print("🎯 LOGGING TEST COMPLETE")
+        print("="*60)
+        print("The browser is ready with automatic CDP logging enabled.")
+        print("Connect any CDP client or Playwright to the URLs above.")
+        print("All actions will be automatically captured in the tool_log table.")
+        print("\nPress Enter to close the environment...")
+        print("="*60 + "\n")
+        
+        input()
+        
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+    finally:
+        if env is not None:
+            try:
+                print("\n🧹 Cleaning up environment...")
+                env.close()
+                print("✅ Environment closed")
+            except Exception as e:
+                print(f"⚠️  Failed to close environment: {e}")
+
+if __name__ == "__main__":
+    main()

fleet/client.py

@@ -50,7 +50,7 @@ from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import SQLiteResource
 from .resources.browser import BrowserResource
-from .resources.mcp import MCPResource
+from ..resources.mcp import MCPResource
 
 logger = logging.getLogger(__name__)
 
@@ -254,7 +254,9 @@ class Fleet:
     def execute_verifier_remote(
         self, bundle_data: bytes, args: tuple, kwargs: dict, timeout: Optional[int] = 30
     ) -> VerifiersExecuteResponse:
-        return _execute_verifier_remote(self.client, bundle_data, args, kwargs, timeout)
+        return _execute_verifier_remote(
+            self.client, bundle_data, args, kwargs, timeout
+        )
 
     def delete(self, instance_id: str) -> InstanceResponse:
         return _delete_instance(self.client, instance_id)
@@ -265,7 +267,9 @@ class Fleet:
 
         return self.load_task_array_from_string(tasks_data)
 
-    def load_task_array_from_string(self, serialized_tasks: List[Dict]) -> List[Task]:
+    def load_task_array_from_string(
+        self, serialized_tasks: List[Dict]
+    ) -> List[Task]:
         tasks = []
 
         json_tasks = json.loads(serialized_tasks)
@@ -303,11 +307,20 @@ class Fleet:
         )
         return task
 
-    def load_tasks(self, env_key: Optional[str] = None) -> List[Task]:
-        """Load tasks for the authenticated team, optionally filtered by environment.
+    def load_tasks(
+        self, 
+        env_key: Optional[str] = None,
+        keys: Optional[List[str]] = None,
+        version: Optional[str] = None,
+        team_id: Optional[str] = None
+    ) -> List[Task]:
+        """Load tasks for the authenticated team, with optional filtering.
 
         Args:
             env_key: Optional environment key to filter tasks by
+            keys: Optional list of task keys to filter by
+            version: Optional version to filter tasks by (client-side filter)
+            team_id: Optional team_id to filter by (admin only)
 
         Returns:
             List[Task] containing Task objects
@@ -315,6 +328,10 @@ class Fleet:
         params = {}
         if env_key is not None:
             params["env_key"] = env_key
+        if keys is not None:
+            params["task_keys"] = keys
+        if team_id is not None:
+            params["team_id"] = team_id
 
         response = self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
@@ -375,6 +392,10 @@ class Fleet:
             )
             tasks.append(task)
 
+        # Apply client-side filtering for version if specified
+        if version is not None:
+            tasks = [task for task in tasks if task.version == version]
+
         return tasks
 
     def export_tasks(
@@ -464,7 +485,7 @@ class Fleet:
     def _create_verifier_from_data(
         self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str
     ) -> "SyncVerifierFunction":
-        """Create a SyncVerifierFunction from verifier data.
+        """Create an AsyncVerifierFunction from verifier data.
 
         Args:
             verifier_id: The verifier ID
@@ -473,10 +494,16 @@ class Fleet:
             verifier_sha: The verifier SHA256
 
         Returns:
-            SyncVerifierFunction created from the verifier code
+            AsyncVerifierFunction created from the verifier code
         """
-        from .tasks import verifier_from_string
+        from ..tasks import verifier_from_string
         from .verifiers.verifier import SyncVerifierFunction
+
+        # Convert async verifier code to sync
+        if 'async def' in verifier_code:
+            verifier_code = verifier_code.replace('async def', 'def')
+        if 'await ' in verifier_code:
+            verifier_code = verifier_code.replace('await ', '')
         
         # Use verifier_from_string to create the verifier
         verifier_func = verifier_from_string(
@@ -486,10 +513,10 @@ class Fleet:
             sha256=verifier_sha,
         )
         
-        # Ensure we return a SyncVerifierFunction
+        # Ensure we return an AsyncVerifierFunction
         if not isinstance(verifier_func, SyncVerifierFunction):
             raise TypeError(
-                f"Expected SyncVerifierFunction but got {type(verifier_func).__name__}"
+                f"Expected AsyncVerifierFunction but got {type(verifier_func).__name__}"
             )
         
         # Store the original verifier code for reference

fleet/env/client.py

@@ -7,7 +7,7 @@ def make(env_key: str, region: Optional[str] = None) -> SyncEnv:
     return Fleet().make(env_key, region=region)
 
 
-def make_for_task(task: Task) -> SyncEnv:
+def make_for_task_async(task: Task) -> SyncEnv:
     return Fleet().make_for_task(task)
 
 

fleet/global_client.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from typing import Optional
 
 from .client import Fleet
-from .config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
+from ..config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
 
 
 _default_client: Optional[Fleet] = None

fleet/instance/client.py

@@ -63,7 +63,9 @@ class InstanceClient:
     def load(self) -> None:
         self._load_resources()
 
-    def reset(self, reset_request: Optional[ResetRequest] = None) -> ResetResponse:
+    def reset(
+        self, reset_request: Optional[ResetRequest] = None
+    ) -> ResetResponse:
         response = self.client.request(
             "POST", "/reset", json=reset_request.model_dump() if reset_request else None
         )

fleet/resources/mcp.py

@@ -1,7 +1,7 @@
 from typing import Dict
 
 
-class MCPResource:
+class SyncMCPResource:
     def __init__(self, url: str, env_key: str):
         self.url = url
         self._env_key = env_key
@@ -22,33 +22,34 @@ class MCPResource:
         }
 
     def list_tools(self):
-        import requests
+        import aiohttp
 
         """
-        Make a request to list available tools from the MCP endpoint.
-
+        Make an async request to list available tools from the MCP endpoint.
+        
         Returns:
             List of available tools with name, description, and input_schema
         """
-        payload = {"jsonrpc": "2.0", "method": "tools/list", "params": {}, "id": 2}
-
-        response = requests.post(self.url, json=payload)
-        data = response.json()
-
-        # Extract tools from the response
-        if "result" in data and "tools" in data["result"]:
-            tools = data["result"]["tools"]
-
-            available_tools = [
-                {
-                    "name": tool.get("name"),
-                    "description": tool.get("description"),
-                    "input_schema": tool.get("inputSchema"),
-                }
-                for tool in tools
-            ]
-
-            return available_tools
-        else:
-            # Handle error or empty response
-            return []
+        with aiohttp.ClientSession() as session:
+            payload = {"jsonrpc": "2.0", "method": "tools/list", "params": {}, "id": 2}
+
+            with session.post(self.url, json=payload) as response:
+                data = response.json()
+
+                # Extract tools from the response
+                if "result" in data and "tools" in data["result"]:
+                    tools = data["result"]["tools"]
+
+                    available_tools = [
+                        {
+                            "name": tool.get("name"),
+                            "description": tool.get("description"),
+                            "input_schema": tool.get("inputSchema"),
+                        }
+                        for tool in tools
+                    ]
+
+                    return available_tools
+                else:
+                    # Handle error or empty response
+                    return []

fleet/resources/sqlite.py

@@ -651,7 +651,9 @@ class SQLiteResource(Resource):
         )
         return DescribeResponse(**response.json())
 
-    def query(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
+    def query(
+        self, query: str, args: Optional[List[Any]] = None
+    ) -> QueryResponse:
         return self._query(query, args, read_only=True)
 
     def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
@@ -693,8 +695,12 @@ class SQLiteResource(Resource):
             AsyncSnapshotDiff: Object containing the differences between the two databases
         """
         # Create snapshots of both databases
-        before_snapshot = self.snapshot(name=f"before_{datetime.utcnow().isoformat()}")
-        after_snapshot = other.snapshot(name=f"after_{datetime.utcnow().isoformat()}")
+        before_snapshot = self.snapshot(
+            name=f"before_{datetime.utcnow().isoformat()}"
+        )
+        after_snapshot = other.snapshot(
+            name=f"after_{datetime.utcnow().isoformat()}"
+        )
 
         # Return the diff between the snapshots
         return before_snapshot.diff(after_snapshot, ignore_config)

fleet/tasks.py

@@ -2,10 +2,10 @@
 
 from __future__ import annotations
 
-import asyncio
 import re
 from datetime import datetime
 from typing import Any, Dict, Optional, List
+from uuid import UUID
 
 from pydantic import BaseModel, Field, validator
 
@@ -13,133 +13,6 @@ from pydantic import BaseModel, Field, validator
 from fleet.types import VerifierFunction
 
 
-def verifier_from_string(
-    verifier_func: str,
-    verifier_id: Optional[str] = None,
-    verifier_key: Optional[str] = None,
-    sha256: Optional[str] = None,
-) -> VerifierFunction:
-    """Create a verifier function from a string of Python code.
-    
-    This function creates either a SyncVerifierFunction or AsyncVerifierFunction
-    based on whether the code contains async function definitions.
-    
-    Args:
-        verifier_func: String containing the verifier function code
-        verifier_id: Optional verifier ID to use
-        verifier_key: Optional verifier key to use (defaults to function name)
-        sha256: Optional SHA256 hash of existing server-side bundle
-        
-    Returns:
-        VerifierFunction: Either SyncVerifierFunction or AsyncVerifierFunction
-        
-    Raises:
-        ValueError: If function name cannot be extracted from the code
-    """
-    from fleet.verifiers.parse import extract_function_name, convert_new_to_old_verifier
-    from fleet.verifiers.verifier import SyncVerifierFunction
-    from fleet._async.verifiers.verifier import AsyncVerifierFunction
-    from fleet.verifiers.db import IgnoreConfig, DatabaseSnapshot
-    
-    # Determine if this is an async verifier
-    is_async = "async def" in verifier_func
-    
-    # Store original code for later
-    original_code = verifier_func
-    
-    # Check if this is a new format verifier (has before/after parameters)
-    if (
-        "before: DatabaseSnapshot" in verifier_func
-        and "after: DatabaseSnapshot" in verifier_func
-    ):
-        # Convert new format to old format
-        verifier_func = convert_new_to_old_verifier(verifier_func)
-        # Update function name since wrapper adds _wrapper suffix
-        original_name = extract_function_name(verifier_func.split("\n")[0])
-        if original_name and original_name.endswith("_wrapper"):
-            function_name = original_name
-        else:
-            function_name = extract_function_name(verifier_func)
-    else:
-        # Extract function name from code
-        function_name = extract_function_name(verifier_func)
-    
-    if not function_name:
-        raise ValueError("Could not extract function name from verifier code")
-    
-    # Create a namespace for the function
-    namespace = {
-        "__builtins__": __builtins__,
-        "Environment": object,  # Placeholder, will be provided at runtime
-        "IgnoreConfig": IgnoreConfig,
-        "DatabaseSnapshot": DatabaseSnapshot,
-        "TASK_FAILED_SCORE": 0,
-        "TASK_SUCCESSFUL_SCORE": 1,
-    }
-    
-    # Execute the code to create the function
-    exec(verifier_func, namespace)
-    
-    # Get the function from the namespace
-    if function_name not in namespace:
-        raise ValueError(f"Function {function_name} not found after execution")
-    
-    func = namespace[function_name]
-    
-    # Use provided key or default to function name
-    key = verifier_key or function_name
-    
-    # Create appropriate verifier function
-    if is_async:
-        # Create AsyncVerifierFunction
-        return AsyncVerifierFunction(
-            func=func,
-            key=key,
-            verifier_id=verifier_id,
-            sha256=sha256,
-            raw_code=original_code,
-            extra_requirements=None,
-        )
-    else:
-        # For sync verifiers, we need to handle the case where the original was async
-        # but got converted during unasync processing
-        if "async def" in original_code and "await " in original_code:
-            # Convert async code to sync for SyncVerifierFunction
-            sync_code = original_code.replace("async def", "def")
-            sync_code = sync_code.replace("await ", "")
-            
-            # Re-execute with sync code
-            namespace = {
-                "__builtins__": __builtins__,
-                "Environment": object,
-                "IgnoreConfig": IgnoreConfig,
-                "DatabaseSnapshot": DatabaseSnapshot,
-                "TASK_FAILED_SCORE": 0,
-                "TASK_SUCCESSFUL_SCORE": 1,
-            }
-            exec(sync_code, namespace)
-            func = namespace[function_name]
-            
-            return SyncVerifierFunction(
-                func=func,
-                key=key,
-                verifier_id=verifier_id,
-                sha256=sha256,
-                raw_code=sync_code,
-                extra_requirements=None,
-            )
-        else:
-            # Already sync code
-            return SyncVerifierFunction(
-                func=func,
-                key=key,
-                verifier_id=verifier_id,
-                sha256=sha256,
-                raw_code=original_code,
-                extra_requirements=None,
-            )
-
-
 class Task(BaseModel):
     """A task model representing a single task in the Fleet system."""
 
@@ -206,7 +79,7 @@ class Task(BaseModel):
             if inspect.iscoroutine(result):
                 # Check if we're already in an event loop
                 try:
-                    _ = asyncio.get_running_loop()
+                    loop = asyncio.get_running_loop()
                     # We're in an async context, can't use asyncio.run()
                     raise RuntimeError(
                         "Cannot run async verifier in sync mode while event loop is running. "
@@ -251,13 +124,32 @@ class Task(BaseModel):
         return Fleet().make(env_key=self.env_key, region=region)
 
 
-def load_tasks(env_key: Optional[str] = None) -> List[Task]:
-    """Convenience function to load tasks without initializing a client.
+def load_tasks(
+    env_key: Optional[str] = None,
+    keys: Optional[List[str]] = None,
+    version: Optional[str] = None,
+    team_id: Optional[str] = None
+) -> List[Task]:
+    """Convenience function to load tasks with optional filtering.
 
-    Creates an `AsyncFleet` client under the hood and returns the tasks list.
+    Args:
+        env_key: Optional environment key to filter tasks by
+        keys: Optional list of task keys to filter by
+        version: Optional version to filter tasks by
+        team_id: Optional team_id to filter by (admin only)
+
+    Examples:
+        tasks = await fleet.load_tasks(env_key="fira")
+        tasks = await fleet.load_tasks(keys=["task1", "task2"])
+        tasks = await fleet.load_tasks(env_key="fira", version="v1.0")
     """
     # Use the global client by default so users can pre-configure it once
     from .global_client import get_client
 
     client = get_client()
-    return client.load_tasks(env_key=env_key)
+    return client.load_tasks(
+        env_key=env_key, 
+        keys=keys, 
+        version=version, 
+        team_id=team_id
+    )

fleet/verifiers/verifier.py

@@ -162,6 +162,13 @@ class SyncVerifierFunction:
 
     def remote(self, env: SyncEnv, *args, **kwargs) -> float:
         """Remote execution of the verifier function with SHA-based bundle caching."""
+        # Async verifiers are now supported by the backend
+        # if self._is_async:
+        #     raise NotImplementedError(
+        #         f"Async verifier '{self.key}' cannot be executed remotely. "
+        #         "The remote execution environment only supports synchronous functions. "
+        #         "Please provide a synchronous version of your verifier."
+        #     )
 
         args_array = list(args)
         args_array.append({"env": env.instance_id})

{fleet_python-0.2.32.dist-info → fleet_python-0.2.34.dist-info}/METADATA

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

{fleet_python-0.2.32.dist-info → fleet_python-0.2.34.dist-info}/RECORD

@@ -1,6 +1,7 @@
 examples/diff_example.py,sha256=iLlpBW_NBjzXBqlvYwjx74uxYZkMGJfea6s3tJhvuNY,5684
 examples/dsl_example.py,sha256=yFLgM-Was4-w575xJgPk9DIBmXa34hLJsIB4XwTADOE,7252
 examples/example.py,sha256=yn9mqS2yJ6896s25btnJx9-_SLLbyS-Fu-SIcas6jok,1081
+examples/exampleResume.py,sha256=hzdL9QfYtwlje5geWS2cgWgjcnLX4UtXSAd-92F66Lw,7044
 examples/example_account.py,sha256=t5_Tnr7DcLYfNpEAbuBySQIqsqiQQGySuiItIghCjAM,225
 examples/example_action_log.py,sha256=pwvLro_Fkrw4DII002bHGuWfoZ6QRvUMDD9BnMqJgLQ,622
 examples/example_client.py,sha256=M9Mfi1FcD2LtSDVk89R_-tgG98swvDYy4qx2zVayJ-0,1025
@@ -17,14 +18,15 @@ examples/openai_example.py,sha256=dEWERrTEP5xBiGkLkQjBQGd2NqoxX6gcW6XteBPsWFQ,82
 examples/openai_simple_example.py,sha256=HmiufucrAZne7tHq9uoEsDWlEhjNC265bQAyIGBRU2o,1745
 examples/query_builder_example.py,sha256=-cOMfWGNifYfYEt_Ds73XpwATZvFDL6F4KTkVxdMjzg,3951
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
+examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
 fleet/__init__.py,sha256=LYJ8zS6Ldo5wLpRqsFMoiikkyosTmm7sRTUY4SnJAgE,3880
 fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
-fleet/client.py,sha256=WC_fYzf28PXHWAqtp4aE97hbmAeNxzzu1TEbzpgbvMk,21366
+fleet/client.py,sha256=JG9soTIkGK_uRezHU79PFn7PBXeN1iNpun1D4JDFTyE,22310
 fleet/config.py,sha256=uY02ZKxVoXqVDta-0IMWaYJeE1CTXF_fA9NI6QUutmU,319
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
+fleet/global_client.py,sha256=oSWhV1cggVKQ0ec0YDOGu6Zr0Tgdcx3oKMM6s2Y9fQw,1073
 fleet/models.py,sha256=9tDjgcgKPMnf-R_MDh-Ocp_UMbyJ8tJyjb15XqU0N94,12454
-fleet/tasks.py,sha256=rNUh-80xq_-Am3WJKNWEtQczBnxgvpAUR4zRd22mJ-4,9771
+fleet/tasks.py,sha256=1AlNhe0WRggj3pIwTeaxMhpmMqI0MGBVjEmODVu37YI,5648
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
 fleet/_async/__init__.py,sha256=1X00u-0Zu4S-e8MGE9nJWbZEt3H-DHZA-gfwN-JuP2U,7415
 fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
@@ -47,16 +49,16 @@ fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMT
 fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
 fleet/_async/verifiers/verifier.py,sha256=lwVIV5ZpWJhM87tXShtjwN5KP7n5XDcPq0XX7AjV6_E,14343
 fleet/env/__init__.py,sha256=6-zgP705M61tCquiDKw29dBZGq1US9mtsB1gQngJ4FQ,664
-fleet/env/client.py,sha256=WcYc4_k7iUP-CSzhurHqcQXjl43O0C5pliVlk019n_M,799
+fleet/env/client.py,sha256=I4pjnXGzifZSr7iZFdn0cTX6nLuGYo-sCt-qk4ez29Y,805
 fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
 fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
-fleet/instance/client.py,sha256=6Jc3OMmm7mPit7SWRCf8ZTfqyFgOOMJIawsqRnOY_Nw,5894
+fleet/instance/client.py,sha256=O6B0A2Z0b5SxOLs4TipZ9Ol8yG-b-LG15vVOKMmd6BQ,5908
 fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/resources/base.py,sha256=AXZzT0_yWHkT497q3yekfr0xsD4cPGMCC6y7C43TIkk,663
 fleet/resources/browser.py,sha256=hRNM0YMsVQUAraZGNi_B-KXxLpuddy4ntoEDFSw7czU,1295
-fleet/resources/mcp.py,sha256=ptWC4sOhk5Slwr7p3USgGX0nM0K98726BxP8BhtSLaU,1486
-fleet/resources/sqlite.py,sha256=dof2oQr7-GxscpyIZXlKJvp59AYoiF9_Ghdq5EzdVdY,25705
+fleet/resources/mcp.py,sha256=c6O4vVJnXANuHMGMe4IPxgp4zBEbFaGm6_d9e6j8Myc,1695
+fleet/resources/sqlite.py,sha256=rwpYmfyw8CjlA-HEsD4fCqYS8wFMxaTiX_tO3gJxDjg,25763
 fleet/verifiers/__init__.py,sha256=IlImvlfgMRQ2V6f4_n7skXYBV8ZoUUjnWaFKnYQQsU8,459
 fleet/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
 fleet/verifiers/code.py,sha256=A1i_UabZspbyj1awzKVQ_HRxgMO3fU7NbkxYyTrp7So,48
@@ -64,11 +66,11 @@ fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
 fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,3260
 fleet/verifiers/parse.py,sha256=0bAbj9VvT__yU4ZVREUK-Tn9dukh9LCpmfVsgj1DfP4,8508
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
-fleet/verifiers/verifier.py,sha256=jbWRqBUX0Cu6NPzU_2yCXAR_Avq1rJdcBIxJPH1Inhs,13896
-fleet_python-0.2.32.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet/verifiers/verifier.py,sha256=53oBWAf0yy3bZmZx9eH9AWIf65H7OP2UUm0YwWCL6Mc,14286
+fleet_python-0.2.34.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=0XKTkAV7WdMxRfk8-x4Ts1LjSbUpyI0tPL0DcTQ_38w,7308
 scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
-fleet_python-0.2.32.dist-info/METADATA,sha256=hw7hTd_JKk8DxieuOXfjpLIUb2-R1_65AMMz0Sa1T4c,3354
-fleet_python-0.2.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.32.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.32.dist-info/RECORD,,
+fleet_python-0.2.34.dist-info/METADATA,sha256=WmolSCZR49qXHttFTyPhRnEJxj6po_YbDeUhOnk4t9M,3354
+fleet_python-0.2.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.34.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.34.dist-info/RECORD,,