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

examples/example_verifier.py

@@ -1,16 +1,20 @@
-import fleet as flt
+import fleet
 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
+    env, final_answer: str | None = None
 ) -> int:
     """Validate that DEBT-722 and DEBT-720 are marked as Done"""
+    # Ensure resources are loaded for remote execution
+    env.instance.load()
     before = env.db("seed")
     after = env.db("current")
 
+    print("test")
+
     # Check final state
     try:
         after.table("issues").eq("id", "DEBT-722").assert_eq("board_list", "Done")
@@ -58,8 +62,17 @@ def validate_finish_blue_green_deployment(
 
 
 def main():
-    env = flt.env.make("fira:v1.3.1")
+    env = fleet.env.make("fira")
     print(f"New Instance: {env.instance_id}")
+    
+    # Check available resources
+    try:
+        resources = env.instance.resources()
+        print("Available resources:")
+        for resource in resources:
+            print(f"  - {resource.type}: {resource.name}")
+    except Exception as e:
+        print(f"Could not list resources: {e}")
 
     print(validate_finish_blue_green_deployment(env))
     print(validate_finish_blue_green_deployment.remote(env))

examples/gemini_example.py

@@ -5,7 +5,7 @@ from typing import List, Dict, Any, Optional, Tuple, TypedDict
 from pathlib import Path
 from google import genai
 from google.genai import types
-import fleet as flt
+import fleet
 from dotenv import load_dotenv
 import base64
 import re
@@ -30,7 +30,7 @@ class Problem(TypedDict):
 class GeminiAgent:
     def __init__(
         self,
-        browser: flt.FleetPlaywrightWrapper,
+        browser: fleet.FleetPlaywrightWrapper,
         model: str = MODEL,
         print_steps: bool = True,
         debug: bool = False,
@@ -262,13 +262,13 @@ def evaluate_problem(
 
     try:
         # Create environment
-        env = flt.env.make(env_key)
+        env = fleet.env.make(env_key)
         print(
             f"[Problem {problem_idx + 1}/{total_problems}] Created environment for {problem['id']}: {env.urls.app}"
         )
 
         # Create browser wrapper
-        browser = flt.FleetPlaywrightWrapper(env)
+        browser = fleet.FleetPlaywrightWrapper(env)
         browser.start()
 
         # Create agent
@@ -314,10 +314,10 @@ def evaluate_problem(
 
 def interactive_mode():
     # Create a Fleet environment instance
-    instance = flt.env.make("hubspot")
+    instance = fleet.env.make("hubspot")
 
     # Create the browser wrapper
-    browser = flt.FleetPlaywrightWrapper(instance)
+    browser = fleet.FleetPlaywrightWrapper(instance)
     browser.start()
 
     try:

examples/json_tasks_example.py

@@ -4,7 +4,7 @@ import argparse
 import json
 from typing import TypedDict, List, Optional, Tuple
 from pathlib import Path
-import fleet as flt
+import fleet
 from nova_act import NovaAct, ActResult
 from dotenv import load_dotenv
 
@@ -36,7 +36,7 @@ async def process_problem(
     env = None
     try:
         # Create a new environment instance for this problem
-        env = await flt.env.make_async(env_key)
+        env = await fleet.env.make_async(env_key)
         print(
             f"[Problem {problem_idx + 1}/{total_problems}] Created environment for {problem['id']}: {env.urls.app}"
         )

examples/nova_act_example.py

@@ -1,5 +1,5 @@
 import asyncio
-import fleet as flt
+import fleet
 from nova_act import NovaAct, ActResult
 from dotenv import load_dotenv
 
@@ -7,7 +7,7 @@ load_dotenv()
 
 
 async def main():
-    instance = await flt.env.make_async("hubspot:v1.2.7")
+    instance = await fleet.env.make_async("hubspot:v1.2.7")
     cdp_url = await instance.browser().cdp_url()
 
     loop = asyncio.get_event_loop()

examples/openai_example.py

@@ -1,5 +1,5 @@
 from openai import OpenAI
-import fleet as flt
+import fleet
 import json
 from typing import Callable
 from dotenv import load_dotenv
@@ -191,10 +191,10 @@ tools = []
 
 def main():
     # Create a Fleet environment instance
-    instance = flt.env.make("hubspot")
+    instance = fleet.env.make("hubspot")
 
     # Create the Playwright wrapper
-    browser = flt.FleetPlaywrightWrapper(instance)
+    browser = fleet.FleetPlaywrightWrapper(instance)
     browser.start()
 
     try:

examples/openai_simple_example.py

@@ -1,5 +1,5 @@
 from openai import OpenAI
-import fleet as flt
+import fleet
 from dotenv import load_dotenv
 
 load_dotenv()
@@ -8,9 +8,9 @@ client = OpenAI()
 
 
 def main():
-    instance = flt.env.make("hubspot")
+    instance = fleet.env.make("hubspot")
 
-    browser = flt.FleetPlaywrightWrapper(instance)
+    browser = fleet.FleetPlaywrightWrapper(instance)
     browser.start()
 
     try:

examples/query_builder_example.py

@@ -1,5 +1,5 @@
 import asyncio
-import fleet as flt
+import fleet
 from dotenv import load_dotenv
 
 load_dotenv()
@@ -8,7 +8,7 @@ load_dotenv()
 async def main():
     # Create a new instance
     print("Creating new Hubspot instance...")
-    env = await flt.env.make_async("hubspot:v1.2.7")
+    env = await fleet.env.make_async("hubspot:v1.2.7")
     print(f"New Instance: {env.instance_id}")
 
     try:
@@ -21,7 +21,7 @@ async def main():
 
         # Example 1: Query with the builder pattern
         print("\n=== Query Builder Examples ===")
-        
+
         # Find all entries of type 'deal'
         print("\n1. Finding all deals:")
         deals = await db.table("entries").eq("type", "deal").all()
@@ -86,14 +86,18 @@ async def main():
         )
         """
         await db.exec(insert_query)
-        
+
         # Verify insertion with query builder
         new_deal = await db.table("entries").eq("id", 99999).first()
         if new_deal:
             print(f"✓ Successfully inserted: {new_deal['name']}")
-            
+
             # Assert specific field value
-            await db.table("entries").eq("id", 99999).assert_eq("name", "Test Deal via Query Builder")
+            await (
+                db.table("entries")
+                .eq("id", 99999)
+                .assert_eq("name", "Test Deal via Query Builder")
+            )
             print("✓ Name assertion passed")
 
         # Using IN clause
@@ -114,4 +118,4 @@ async def main():
 
 
 if __name__ == "__main__":
-    asyncio.run(main()) 
+    asyncio.run(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/__init__.py

@@ -14,6 +14,8 @@
 
 """Fleet Python SDK - Environment-based AI agent interactions."""
 
+from typing import Optional, List
+
 from .exceptions import (
     FleetError,
     FleetAPIError,
@@ -52,6 +54,8 @@ from .types import VerifierFunction
 
 # Create a module-level env attribute for convenient access
 from . import env
+from . import global_client as _global_client
+from ._async import global_client as _async_global_client
 
 __version__ = "0.1.0"
 
@@ -63,7 +67,7 @@ __all__ = [
     "AsyncEnv",
     # Models
     "InstanceResponse",
-    "SyncEnv", 
+    "SyncEnv",
     "Resource",
     "ResetResponse",
     # Task models
@@ -71,21 +75,72 @@ __all__ = [
     "VerifierFunction",
     # Exceptions
     "FleetError",
-    "FleetAPIError", 
+    "FleetAPIError",
     "FleetTimeoutError",
     "FleetConfigurationError",
     # Verifiers (async is default)
     "verifier",
-    "verifier_sync", 
+    "verifier_sync",
     "AsyncVerifierFunction",
     "SyncVerifierFunction",
     "DatabaseSnapshot",
-    "IgnoreConfig", 
+    "IgnoreConfig",
     "SnapshotDiff",
     "TASK_FAILED_SCORE",
     "TASK_SUCCESSFUL_SCORE",
     # Environment module
     "env",
+    # Global client helpers
+    "configure",
+    "get_client",
+    "reset_client",
     # Version
     "__version__",
-]
+]
+
+
+def load_tasks(env_key: Optional[str] = None) -> List[Task]:
+    """Load tasks without explicitly creating a client.
+
+    Example:
+        tasks = fleet.load_tasks(env_key="fira")
+    """
+    # Use global client by default so users can configure once
+    return _global_client.get_client().load_tasks(env_key=env_key)
+
+
+def configure(
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    max_retries: int | None = None,
+    timeout: float | None = None,
+):
+    """Configure global clients (sync and async) once per process.
+
+    Both sync and async default clients will be (re)created with the provided settings.
+    """
+    if max_retries is None:
+        from .config import DEFAULT_MAX_RETRIES as _MR
+
+        max_retries = _MR
+    if timeout is None:
+        from .config import DEFAULT_TIMEOUT as _TO
+
+        timeout = _TO
+    _global_client.configure(
+        api_key=api_key, base_url=base_url, max_retries=max_retries, timeout=timeout
+    )
+    _async_global_client.configure(
+        api_key=api_key, base_url=base_url, max_retries=max_retries, timeout=timeout
+    )
+
+
+def get_client() -> Fleet:
+    """Get the global sync client."""
+    return _global_client.get_client()
+
+
+def reset_client():
+    """Reset both sync and async global clients."""
+    _global_client.reset_client()
+    _async_global_client.reset_client()

fleet/_async/__init__.py

@@ -1 +1,258 @@
-# This file makes the _async directory a proper Python package
+# Copyright 2025 Fleet AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Fleet Python SDK - Async Environment-based AI agent interactions."""
+
+from typing import Optional, List
+
+from ..exceptions import (
+    FleetError,
+    FleetAPIError,
+    FleetTimeoutError,
+    FleetRateLimitError,
+    FleetInstanceLimitError,
+    FleetConfigurationError,
+)
+from .client import AsyncFleet, AsyncEnv
+from ..models import InstanceResponse, Environment, AccountResponse
+from ..instance.models import Resource, ResetResponse
+
+# Import async verifiers
+from .verifiers import (
+    verifier,
+    AsyncVerifierFunction,
+)
+
+# Import async tasks
+from .tasks import Task
+
+# Import shared types
+from ..types import VerifierFunction
+
+# Create a module-level env attribute for convenient access
+from .. import env
+from . import global_client as _async_global_client
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Core classes
+    "AsyncFleet",
+    "AsyncEnv",
+    # Models
+    "InstanceResponse",
+    "Resource",
+    "ResetResponse",
+    # Task models
+    "Task",
+    "VerifierFunction",
+    # Exceptions
+    "FleetError",
+    "FleetAPIError",
+    "FleetTimeoutError",
+    "FleetConfigurationError",
+    # Verifiers
+    "verifier",
+    "AsyncVerifierFunction",
+    # Environment module
+    "env",
+    # Global client helpers
+    "configure",
+    "get_client",
+    "reset_client",
+    # Module-level functions
+    "load_tasks",
+    "list_envs", 
+    "list_regions",
+    "environment",
+    "make",
+    "make_for_task",
+    "instances",
+    "instance", 
+    "delete",
+    "load_tasks_from_file",
+    "load_task_array_from_string",
+    "load_task_from_string", 
+    "load_task_from_json",
+    "export_tasks",
+    "import_tasks",
+    "account",
+    # Version
+    "__version__",
+]
+
+
+async def load_tasks(
+    env_key: Optional[str] = None,
+    keys: Optional[List[str]] = None,
+    version: Optional[str] = None,
+    team_id: Optional[str] = None
+) -> List[Task]:
+    """Load tasks 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
+
+    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 global client by default so users can configure once
+    return await _async_global_client.get_client().load_tasks(
+        env_key=env_key, 
+        keys=keys, 
+        version=version, 
+        team_id=team_id
+    )
+
+
+async def list_envs() -> List[Environment]:
+    """List all available environments."""
+    return await _async_global_client.get_client().list_envs()
+
+
+async def list_regions() -> List[str]:
+    """List all available regions."""
+    return await _async_global_client.get_client().list_regions()
+
+
+async def environment(env_key: str) -> Environment:
+    """Get environment details by key."""
+    return await _async_global_client.get_client().environment(env_key)
+
+
+async def make(env_key: str, region: Optional[str] = None) -> AsyncEnv:
+    """Create a new environment instance.
+    
+    Example:
+        env = await fleet.make("fira")
+    """
+    return await _async_global_client.get_client().make(env_key, region)
+
+
+async def make_for_task(task: Task) -> AsyncEnv:
+    """Create an environment instance for a specific task."""
+    return await _async_global_client.get_client().make_for_task(task)
+
+
+async def instances(status: Optional[str] = None, region: Optional[str] = None) -> List[AsyncEnv]:
+    """List existing environment instances."""
+    return await _async_global_client.get_client().instances(status, region)
+
+
+async def instance(instance_id: str) -> AsyncEnv:
+    """Get an existing environment instance by ID."""
+    return await _async_global_client.get_client().instance(instance_id)
+
+
+async def delete(instance_id: str) -> InstanceResponse:
+    """Delete an environment instance."""
+    return await _async_global_client.get_client().delete(instance_id)
+
+
+async def load_tasks_from_file(filename: str) -> List[Task]:
+    """Load tasks from a JSON file.
+    
+    Example:
+        tasks = await fleet.load_tasks_from_file("my_tasks.json")
+    """
+    return await _async_global_client.get_client().load_tasks_from_file(filename)
+
+
+async def load_task_array_from_string(serialized_tasks: str) -> List[Task]:
+    """Load tasks from a JSON string containing an array of tasks.
+    
+    Example:
+        tasks = await fleet.load_task_array_from_string(json_string)
+    """
+    return await _async_global_client.get_client().load_task_array_from_string(serialized_tasks)
+
+
+async def load_task_from_string(task_string: str) -> Task:
+    """Load a single task from a JSON string.
+    
+    Example:
+        task = await fleet.load_task_from_string(task_json_string)
+    """
+    return await _async_global_client.get_client().load_task_from_string(task_string)
+
+
+async def load_task_from_json(task_json: dict) -> Task:
+    """Load a single task from a dictionary.
+    
+    Example:
+        task = await fleet.load_task_from_json(task_dict)
+    """
+    return await _async_global_client.get_client().load_task_from_json(task_json)
+
+
+async def export_tasks(env_key: Optional[str] = None, filename: Optional[str] = None) -> Optional[str]:
+    """Export tasks to a JSON file.
+    
+    Example:
+        await fleet.export_tasks("fira", "fira_tasks.json")
+    """
+    return await _async_global_client.get_client().export_tasks(env_key, filename)
+
+
+async def import_tasks(filename: str):
+    """Import tasks from a JSON file.
+    
+    Example:
+        await fleet.import_tasks("tasks.json")
+    """
+    return await _async_global_client.get_client().import_tasks(filename)
+
+
+async def account() -> AccountResponse:
+    """Get account information including instance limits and usage."""
+    return await _async_global_client.get_client().account()
+
+
+def configure(
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    max_retries: int | None = None,
+    timeout: float | None = None,
+):
+    """Configure global async client once per process.
+
+    Args:
+        api_key: API key for authentication
+        base_url: Base URL for the API
+        max_retries: Maximum number of retries
+        timeout: Request timeout in seconds
+    """
+    if max_retries is None:
+        from ..config import DEFAULT_MAX_RETRIES as _MR
+        max_retries = _MR
+    if timeout is None:
+        from ..config import DEFAULT_TIMEOUT as _TO
+        timeout = _TO
+    _async_global_client.configure(
+        api_key=api_key, base_url=base_url, max_retries=max_retries, timeout=timeout
+    )
+
+
+def get_client() -> AsyncFleet:
+    """Get the global async client."""
+    return _async_global_client.get_client()
+
+
+def reset_client():
+    """Reset the async global client."""
+    _async_global_client.reset_client()

fleet/_async/base.py

@@ -46,6 +46,7 @@ class BaseWrapper:
         headers["Authorization"] = f"Bearer {self.api_key}"
         # Debug log
         import logging
+
         logger = logging.getLogger(__name__)
         logger.debug(f"Headers being sent: {headers}")
         return headers
@@ -89,7 +90,7 @@ class AsyncWrapper(BaseWrapper):
     def _handle_error_response(self, response: httpx.Response) -> None:
         """Handle HTTP error responses and convert to appropriate Fleet exceptions."""
         status_code = response.status_code
-        
+
         # Debug log 500 errors
         if status_code == 500:
             logger.error(f"Got 500 error from {response.url}")