fleet-python 0.2.122__tar.gz → 0.2.124__tar.gz

fleet_python-0.2.124/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: fleet-python
+Version: 0.2.124
+Summary: Python SDK for Fleet environments
+Author-email: Fleet AI <nic@fleet.so>
+License: Apache-2.0
+Project-URL: Homepage, https://fleetai.com
+Project-URL: Documentation, https://docs.fleetai.com
+Project-URL: Repository, https://github.com/fleet-ai/fleet-sdk
+Project-URL: Issues, https://github.com/fleet-ai/fleet-sdk/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+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: cli
+Requires-Dist: typer>=0.9.0; extra == "cli"
+Requires-Dist: rich>=10.0.0; extra == "cli"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: unasync>=0.6.0; extra == "dev"
+Requires-Dist: python-dotenv>=1.1.1; extra == "dev"
+Requires-Dist: typer>=0.9.0; extra == "dev"
+Requires-Dist: rich>=10.0.0; extra == "dev"
+Provides-Extra: playwright
+Requires-Dist: playwright>=1.40.0; extra == "playwright"
+Provides-Extra: eval
+Requires-Dist: aiohttp>=3.9.0; extra == "eval"
+Requires-Dist: google-genai>=1.0.0; extra == "eval"
+Requires-Dist: mcp==1.24.0; python_version >= "3.10" and extra == "eval"
+Dynamic: license-file
+
+# Fleet SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/fleet-python.svg)](https://pypi.org/project/fleet-python/)
+[![Python versions](https://img.shields.io/pypi/pyversions/fleet-python.svg)](https://pypi.org/project/fleet-python/)
+[![License](https://img.shields.io/pypi/l/fleet-python.svg)](https://pypi.org/project/fleet-python/)
+
+The Fleet Python SDK provides programmatic access to Fleet's environment infrastructure.
+
+## Installation
+
+Install the Fleet SDK using pip:
+
+```bash
+pip install fleet-python
+```
+
+### Alpha/Pre-release Versions
+
+To install the latest alpha or pre-release version:
+
+```bash
+pip install --pre fleet-python
+```
+
+To install a specific alpha version:
+
+```bash
+pip install fleet-python==0.2.64-alpha1
+```
+
+## API Key Setup
+
+Fleet requires an API key for authentication. You can obtain one from the [Fleet Platform](https://fleetai.com/dashboard/api-keys).
+
+Set your API key as an environment variable:
+
+```bash
+export FLEET_API_KEY="sk_your_key_here"
+```
+
+## Basic Usage
+
+```python
+import fleet
+import datetime
+
+# Create environment by key
+env = fleet.env.make("fira")
+
+# Reset environment with seed and options
+env.reset(
+    seed=42,
+    timestamp=int(datetime.datetime.now().timestamp())
+)
+
+# Access environment state ('current' is the resource id for a sqlite database)
+sql = env.state("sqlite://current")
+sql.exec("UPDATE customers SET status = 'active' WHERE id = 123")
+
+# Clean up
+env.close()
+```
+
+## Environment Management
+
+### Creating Instances
+
+```python
+# Create environment instance with explicit version
+env = fleet.env.make("fira:v1.2.5")
+
+# Create environment instance with default (latest) version
+env = fleet.env.make("fira")
+
+```
+
+### Connecting to Existing Instances
+
+```python
+# Connect to a running instance
+env = fleet.env.get("env_instance_id")
+
+# List all running instances
+instances = fleet.env.list_instances()
+for instance in instances:
+    print(f"Instance: {instance.instance_id}")
+    print(f"Type: {instance.environment_type}")
+    print(f"Status: {instance.status}")
+
+# Filter instances by status (running, pending, stopped, error)
+running_instances = fleet.env.list_instances(status_filter="running")
+
+# List available environment types
+available_envs = fleet.env.list_envs()
+```

fleet_python-0.2.124/README.md

@@ -0,0 +1,95 @@
+# Fleet SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/fleet-python.svg)](https://pypi.org/project/fleet-python/)
+[![Python versions](https://img.shields.io/pypi/pyversions/fleet-python.svg)](https://pypi.org/project/fleet-python/)
+[![License](https://img.shields.io/pypi/l/fleet-python.svg)](https://pypi.org/project/fleet-python/)
+
+The Fleet Python SDK provides programmatic access to Fleet's environment infrastructure.
+
+## Installation
+
+Install the Fleet SDK using pip:
+
+```bash
+pip install fleet-python
+```
+
+### Alpha/Pre-release Versions
+
+To install the latest alpha or pre-release version:
+
+```bash
+pip install --pre fleet-python
+```
+
+To install a specific alpha version:
+
+```bash
+pip install fleet-python==0.2.64-alpha1
+```
+
+## API Key Setup
+
+Fleet requires an API key for authentication. You can obtain one from the [Fleet Platform](https://fleetai.com/dashboard/api-keys).
+
+Set your API key as an environment variable:
+
+```bash
+export FLEET_API_KEY="sk_your_key_here"
+```
+
+## Basic Usage
+
+```python
+import fleet
+import datetime
+
+# Create environment by key
+env = fleet.env.make("fira")
+
+# Reset environment with seed and options
+env.reset(
+    seed=42,
+    timestamp=int(datetime.datetime.now().timestamp())
+)
+
+# Access environment state ('current' is the resource id for a sqlite database)
+sql = env.state("sqlite://current")
+sql.exec("UPDATE customers SET status = 'active' WHERE id = 123")
+
+# Clean up
+env.close()
+```
+
+## Environment Management
+
+### Creating Instances
+
+```python
+# Create environment instance with explicit version
+env = fleet.env.make("fira:v1.2.5")
+
+# Create environment instance with default (latest) version
+env = fleet.env.make("fira")
+
+```
+
+### Connecting to Existing Instances
+
+```python
+# Connect to a running instance
+env = fleet.env.get("env_instance_id")
+
+# List all running instances
+instances = fleet.env.list_instances()
+for instance in instances:
+    print(f"Instance: {instance.instance_id}")
+    print(f"Type: {instance.environment_type}")
+    print(f"Status: {instance.status}")
+
+# Filter instances by status (running, pending, stopped, error)
+running_instances = fleet.env.list_instances(status_filter="running")
+
+# List available environment types
+available_envs = fleet.env.list_envs()
+```

{fleet_python-0.2.122 → fleet_python-0.2.124}/examples/example_task.py

@@ -112,7 +112,7 @@ async def main():
     print(f"Task definition:")
     print(f"  Key: {task.key}")
     print(f"  Prompt: {task.prompt}")
-    print(f"  Environment: {task.env_key}")
+    print(f"  Environment: {task.env_id}")
     print(
         f"  Verifier: {task.verifier.key if hasattr(task.verifier, 'key') else 'create_bug_issue'}"
     )

{fleet_python-0.2.122 → fleet_python-0.2.124}/examples/export_tasks.py

@@ -38,12 +38,6 @@ def main():
         help="Output JSON filename (defaults to {team_id}.json)",
         default=None,
     )
-    parser.add_argument(
-        "--skip-missing-verifiers",
-        "-s",
-        action="store_true",
-        help="Skip tasks missing verifier_func instead of erroring",
-    )
 
     args = parser.parse_args()
 
@@ -97,32 +91,16 @@ def main():
             missing_verifier.append(task.key)
 
     if missing_verifier:
-        if args.skip_missing_verifiers:
-            print(
-                f"\n⚠ Skipping {len(missing_verifier)} task(s) missing verifier_func:"
-            )
-            for key in missing_verifier[:10]:  # Show first 10
-                print(f"  - {key}")
-            if len(missing_verifier) > 10:
-                print(f"  ... and {len(missing_verifier) - 10} more")
-            # Filter out tasks without verifiers
-            tasks = [task for task in tasks if task.verifier_func]
-            print(f"\n{len(tasks)} task(s) remaining after filtering")
-            if not tasks:
-                raise ValueError(
-                    "No tasks remaining after filtering. Nothing to export."
-                )
-        else:
-            print(f"\n✗ Error: {len(missing_verifier)} task(s) missing verifier_func:")
-            for key in missing_verifier[:10]:  # Show first 10
-                print(f"  - {key}")
-            if len(missing_verifier) > 10:
-                print(f"  ... and {len(missing_verifier) - 10} more")
-            raise ValueError(
-                "All tasks must have a verifier_func. Cannot export tasks without verifiers."
-            )
-    else:
-        print("✓ All tasks have verifier_func")
+        print(f"\n✗ Error: {len(missing_verifier)} task(s) missing verifier_func:")
+        for key in missing_verifier[:10]:  # Show first 10
+            print(f"  - {key}")
+        if len(missing_verifier) > 10:
+            print(f"  ... and {len(missing_verifier) - 10} more")
+        raise ValueError(
+            "All tasks must have a verifier_func. Cannot export tasks without verifiers."
+        )
+
+    print("✓ All tasks have verifier_func")
 
     # Determine output filename
     output_file = args.output or f"{account.team_id}.json"

fleet_python-0.2.124/examples/export_tasks_filtered.py

@@ -0,0 +1,245 @@
+"""
+Export tasks to JSON, excluding tasks from targets marked as 'unused'.
+
+This script filters out tasks whose task_project_target has status='unused',
+ensuring that broken/invalid targets don't pollute exports.
+
+Usage:
+    python export_tasks_filtered.py --task-project-key my-project
+    python export_tasks_filtered.py --project-key my-project --output tasks.json
+    python export_tasks_filtered.py --env-key my-env
+"""
+
+import argparse
+import json
+import os
+from typing import List, Set
+
+import fleet
+from dotenv import load_dotenv
+from supabase import create_client, Client
+
+load_dotenv()
+
+
+def get_unused_target_ids(supabase: Client, team_id: str) -> Set[str]:
+    """Fetch all target IDs that have status='unused' for the given team."""
+    # Get all task_projects for this team first
+    projects_response = (
+        supabase.table("task_projects")
+        .select("id")
+        .eq("team_id", team_id)
+        .execute()
+    )
+    
+    if not projects_response.data:
+        return set()
+    
+    project_ids = [p["id"] for p in projects_response.data]
+    
+    # Get all targets with status='unused' for these projects
+    targets_response = (
+        supabase.table("task_project_targets")
+        .select("id")
+        .in_("project_id", project_ids)
+        .eq("status", "unused")
+        .execute()
+    )
+    
+    if not targets_response.data:
+        return set()
+    
+    return {t["id"] for t in targets_response.data}
+
+
+def get_task_target_mapping(supabase: Client, task_keys: List[str], team_id: str) -> dict:
+    """Fetch task_project_target_id for each task key."""
+    if not task_keys:
+        return {}
+    
+    # Batch the queries to avoid hitting limits
+    BATCH_SIZE = 100
+    mapping = {}
+    
+    for i in range(0, len(task_keys), BATCH_SIZE):
+        batch_keys = task_keys[i:i + BATCH_SIZE]
+        response = (
+            supabase.table("eval_tasks")
+            .select("key, task_project_target_id")
+            .in_("key", batch_keys)
+            .eq("team_id", team_id)
+            .execute()
+        )
+        
+        for row in response.data or []:
+            mapping[row["key"]] = row.get("task_project_target_id")
+    
+    return mapping
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Export tasks to JSON, excluding tasks from 'unused' targets"
+    )
+    parser.add_argument(
+        "--project-key",
+        "-p",
+        help="Optional project key to filter tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--task-keys",
+        "-t",
+        nargs="+",
+        help="Optional list of task keys to export (space-separated)",
+        default=None,
+    )
+    parser.add_argument(
+        "--task-project-key",
+        "-tpk",
+        help="Optional task project key to filter tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--env-key",
+        "-e",
+        help="Optional environment key to filter tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        help="Output JSON filename (defaults to {team_id}_filtered.json)",
+        default=None,
+    )
+    parser.add_argument(
+        "--include-unused",
+        action="store_true",
+        help="Include tasks from 'unused' targets (disables filtering)",
+    )
+
+    args = parser.parse_args()
+
+    # Validate that only one filter is specified
+    filters_specified = sum(
+        [
+            args.project_key is not None,
+            args.task_keys is not None,
+            args.task_project_key is not None,
+            args.env_key is not None,
+        ]
+    )
+
+    if filters_specified > 1:
+        parser.error(
+            "Cannot specify multiple filters. Use only one of --project-key, --task-keys, --task-project-key, or --env-key."
+        )
+
+    # Get account info
+    account = fleet.env.account()
+    print(f"Exporting from team: {account.team_name}")
+
+    # Initialize Supabase client for filtering
+    supabase_url = os.getenv("SUPABASE_URL") or os.getenv("NEXT_PUBLIC_SUPABASE_URL")
+    supabase_key = os.getenv("SUPABASE_SERVICE_ROLE_KEY") or os.getenv("SUPABASE_KEY")
+    
+    if not supabase_url or not supabase_key:
+        print("⚠ Warning: SUPABASE_URL/SUPABASE_KEY not set - cannot filter by target status")
+        print("  Falling back to unfiltered export")
+        supabase = None
+    else:
+        supabase = create_client(supabase_url, supabase_key)
+
+    # Load tasks
+    if args.project_key:
+        print(f"Loading tasks from project: {args.project_key}")
+        tasks = fleet.load_tasks(project_key=args.project_key)
+    elif args.task_keys:
+        print(f"Loading {len(args.task_keys)} specific task(s): {', '.join(args.task_keys)}")
+        tasks = fleet.load_tasks(keys=args.task_keys)
+    elif args.task_project_key:
+        print(f"Loading tasks from task project: {args.task_project_key}")
+        tasks = fleet.load_tasks(task_project_key=args.task_project_key)
+    elif args.env_key:
+        print(f"Loading tasks from environment: {args.env_key}")
+        tasks = fleet.load_tasks(env_key=args.env_key)
+    else:
+        print("Loading all tasks")
+        tasks = fleet.load_tasks()
+
+    print(f"\nFound {len(tasks)} task(s) before filtering")
+
+    # Filter out tasks from unused targets
+    filtered_tasks = tasks
+    excluded_count = 0
+    
+    if supabase and not args.include_unused:
+        print("\nFiltering out tasks from 'unused' targets...")
+        
+        # Get unused target IDs
+        unused_target_ids = get_unused_target_ids(supabase, account.team_id)
+        
+        if unused_target_ids:
+            print(f"  Found {len(unused_target_ids)} unused target(s)")
+            
+            # Get task -> target mapping
+            task_keys = [t.key for t in tasks]
+            task_target_map = get_task_target_mapping(supabase, task_keys, account.team_id)
+            
+            # Filter tasks
+            filtered_tasks = []
+            for task in tasks:
+                target_id = task_target_map.get(task.key)
+                if target_id in unused_target_ids:
+                    excluded_count += 1
+                else:
+                    filtered_tasks.append(task)
+            
+            print(f"  Excluded {excluded_count} task(s) from unused targets")
+        else:
+            print("  No unused targets found - all tasks included")
+    
+    tasks = filtered_tasks
+    print(f"\n{len(tasks)} task(s) after filtering")
+
+    # Validate that all tasks have verifier_func
+    print("\nValidating tasks have verifier_func...")
+    missing_verifier = []
+    for task in tasks:
+        if not task.verifier_func:
+            missing_verifier.append(task.key)
+
+    if missing_verifier:
+        print(f"\n✗ Error: {len(missing_verifier)} task(s) missing verifier_func:")
+        for key in missing_verifier[:10]:  # Show first 10
+            print(f"  - {key}")
+        if len(missing_verifier) > 10:
+            print(f"  ... and {len(missing_verifier) - 10} more")
+        raise ValueError(
+            "All tasks must have a verifier_func. Cannot export tasks without verifiers."
+        )
+
+    print("✓ All tasks have verifier_func")
+
+    # Determine output filename
+    output_file = args.output or f"{account.team_id}_filtered.json"
+
+    # Export to JSON
+    print(f"\nExporting to: {output_file}")
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(
+            [task.model_dump() for task in tasks],
+            f,
+            indent=2,
+            ensure_ascii=False,
+        )
+
+    print(f"✓ Successfully exported {len(tasks)} task(s) to {output_file}")
+    if excluded_count > 0:
+        print(f"  ({excluded_count} task(s) excluded from unused targets)")
+
+
+if __name__ == "__main__":
+    main()
+
+

{fleet_python-0.2.122 → fleet_python-0.2.124}/examples/import_tasks.py

@@ -35,7 +35,7 @@ async def run_verifier_sanity_check(
     instance_groups = defaultdict(list)
     for task in tasks:
         # Build the instance key
-        env_key = task.env_key or ""
+        env_key = task.env_id or ""
         env_version = task.version or ""
         data_key = task.data_id or ""
         data_version = task.data_version or ""
@@ -238,6 +238,7 @@ async def main():
     task_count = len(tasks_data)
     task_keys = []
     missing_verifier = []
+    tasks_with_output_schema = []
     for task_data in tasks_data:
         task_key = task_data.get("key") or task_data.get("id")
         if task_key:
@@ -250,6 +251,10 @@ async def main():
         if not verifier_code:
             missing_verifier.append(task_key or "(no key)")
 
+        # Check for output_json_schema
+        if task_data.get("output_json_schema"):
+            tasks_with_output_schema.append(task_key or "(no key)")
+
     # Validate all tasks have verifier_func
     if missing_verifier:
         print(f"✗ Error: {len(missing_verifier)} task(s) missing verifier_func:")
@@ -339,6 +344,10 @@ async def main():
             tasks = passed_tasks
             passed_keys = {t.key for t in passed_tasks}
             tasks_data = [td for td in tasks_data if td.get("key") in passed_keys]
+            # Also filter tasks_with_output_schema
+            tasks_with_output_schema = [
+                k for k in tasks_with_output_schema if k in passed_keys
+            ]
 
             print(f"\nProceeding with {len(tasks)} tasks that passed sanity check")
     else:
@@ -388,6 +397,45 @@ async def main():
 
         print(f"✓ Team: {account.team_name}")
 
+        # Print HUGE warning if any tasks have output_json_schema
+        if tasks_with_output_schema:
+            print("\n")
+            print("!" * 80)
+            print("!" * 80)
+            print("!" * 80)
+            print(
+                "!!!                                                                          !!!"
+            )
+            print(
+                "!!!                          ⚠️  WARNING WARNING WARNING  ⚠️                          !!!"
+            )
+            print(
+                "!!!                                                                          !!!"
+            )
+            print(
+                f"!!!  {len(tasks_with_output_schema)} TASK(S) HAVE OUTPUT_JSON_SCHEMA THAT NEED MANUAL COPYING!  !!!"
+            )
+            print(
+                "!!!                                                                          !!!"
+            )
+            print(
+                "!!!  The output_json_schema field is NOT automatically imported!            !!!"
+            )
+            print(
+                "!!!  You MUST manually copy the output schemas to each task!                !!!"
+            )
+            print(
+                "!!!                                                                          !!!"
+            )
+            print("!" * 80)
+            print("!" * 80)
+            print("!" * 80)
+            print("\nTasks with output_json_schema:")
+            for i, key in enumerate(tasks_with_output_schema[:20], 1):
+                print(f"  {i}. {key}")
+            if len(tasks_with_output_schema) > 20:
+                print(f"  ... and {len(tasks_with_output_schema) - 20} more")
+            print("\n⚠️  REMEMBER TO MANUALLY COPY OUTPUT SCHEMAS! ⚠️\n")
     except Exception as e:
         print(f"\n✗ Error importing tasks: {e}")
         sys.exit(1)

{fleet_python-0.2.122 → fleet_python-0.2.124}/examples/iterate_verifiers.py

@@ -677,12 +677,12 @@ def main():
         epilog="""
 Examples:
   # Extract verifiers from JSON to Python file
-  %(prog)s extract batch.json verifiers.py
+  %(prog)s extract xai-day-10-batch.json verifiers.py
   
   # Edit verifiers.py...
   
   # Apply changes back to JSON file (updates in-place)
-  %(prog)s apply batch.json verifiers.py
+  %(prog)s apply xai-day-10-batch.json verifiers.py
   
   # Validate verifiers file
   %(prog)s validate verifiers.py