fleet-python 0.2.66b2__py3-none-any.whl → 0.2.105__py3-none-any.whl

examples/export_tasks.py

@@ -17,8 +17,7 @@ def main():
     parser.add_argument(
         "--task-keys",
         "-t",
-        nargs="+",
-        help="Optional list of task keys to export (space-separated)",
+        help="Optional list of task keys to export (comma-separated)",
         default=None,
     )
     parser.add_argument(
@@ -27,6 +26,12 @@ def main():
         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",
@@ -42,12 +47,13 @@ def main():
             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, or --task-project-key."
+            "Cannot specify multiple filters. Use only one of --project-key, --task-keys, --task-project-key, or --env-key."
         )
 
     # Get account info
@@ -59,13 +65,18 @@ def main():
         print(f"Loading tasks from project: {args.project_key}")
         tasks = fleet.load_tasks(project_key=args.project_key)
     elif args.task_keys:
+        # Split comma-separated task keys and strip whitespace
+        task_keys_list = [key.strip() for key in args.task_keys.split(",")]
         print(
-            f"Loading {len(args.task_keys)} specific task(s): {', '.join(args.task_keys)}"
+            f"Loading {len(task_keys_list)} specific task(s): {', '.join(task_keys_list)}"
         )
-        tasks = fleet.load_tasks(keys=args.task_keys)
+        tasks = fleet.load_tasks(keys=task_keys_list)
     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()

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()
+
+

examples/fetch_tasks.py

@@ -0,0 +1,230 @@
+import argparse
+import asyncio
+import json
+import sys
+from typing import List, Dict, Any, Optional, Tuple
+import fleet
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def fetch_task(
+    task_key: str, semaphore: asyncio.Semaphore
+) -> Tuple[str, Optional[Dict[str, Any]], Optional[str]]:
+    """
+    Fetch a single task from the Fleet API.
+
+    Args:
+        task_key: Task key to fetch
+        semaphore: Semaphore to limit concurrent requests
+
+    Returns:
+        Tuple of (task_key, task_data_dict, error_message)
+    """
+    async with semaphore:
+        try:
+            # Use load_tasks with keys parameter to get Task objects
+            tasks = await fleet.load_tasks_async(keys=[task_key])
+            if tasks:
+                task = tasks[0]
+                # Convert to dict using model_dump() like export_tasks.py does
+                return task_key, task.model_dump(), None
+            else:
+                return task_key, None, "Task not found"
+        except Exception as e:
+            error_msg = f"{type(e).__name__}: {str(e)}"
+            return task_key, None, error_msg
+
+
+async def fetch_tasks_batch(
+    task_keys: List[str], max_concurrent: int = 20
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Fetch multiple tasks concurrently from the Fleet API.
+
+    Args:
+        task_keys: List of task keys to fetch
+        max_concurrent: Maximum number of concurrent requests
+
+    Returns:
+        Dictionary mapping task_key to task data
+    """
+    print(f"\nFetching {len(task_keys)} task(s) from Fleet API...")
+    print(f"Max concurrent requests: {max_concurrent}")
+
+    semaphore = asyncio.Semaphore(max_concurrent)
+
+    # Fetch all tasks concurrently
+    results = await asyncio.gather(
+        *[fetch_task(key, semaphore) for key in task_keys],
+        return_exceptions=True,
+    )
+
+    # Process results
+    fetched_tasks = {}
+    errors = []
+
+    for result in results:
+        if isinstance(result, Exception):
+            errors.append(f"Unexpected error: {result}")
+            continue
+
+        task_key, task_data, error = result
+
+        if error:
+            errors.append(f"{task_key}: {error}")
+            print(f"  ✗ {task_key}: {error}")
+        elif task_data:
+            # Task data is already a dict from model_dump()
+            fetched_tasks[task_key] = task_data
+            print(f"  ✓ {task_key}")
+
+    print(f"\n✓ Successfully fetched {len(fetched_tasks)} task(s)")
+
+    if errors:
+        print(f"\n⚠ {len(errors)} error(s) occurred:")
+        for error in errors[:10]:  # Show first 10
+            print(f"  - {error}")
+        if len(errors) > 10:
+            print(f"  ... and {len(errors) - 10} more")
+
+    return fetched_tasks
+
+
+async def main():
+    parser = argparse.ArgumentParser(
+        description="Fetch tasks from Fleet API and update JSON file",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Fetch tasks and update in-place
+  %(prog)s tasks.json
+
+  # Fetch tasks and save to a new file
+  %(prog)s tasks.json --output updated_tasks.json
+
+  # Limit concurrent requests
+  %(prog)s tasks.json --max-concurrent 10
+        """,
+    )
+
+    parser.add_argument("json_file", help="Path to JSON file containing tasks")
+    parser.add_argument(
+        "--output",
+        "-o",
+        help="Path to output JSON file (defaults to overwriting input)",
+        default=None,
+    )
+    parser.add_argument(
+        "--max-concurrent",
+        "-c",
+        type=int,
+        default=20,
+        help="Maximum number of concurrent API requests (default: 20)",
+    )
+
+    args = parser.parse_args()
+
+    # Load JSON file
+    print(f"Reading tasks from: {args.json_file}")
+    try:
+        with open(args.json_file, "r", encoding="utf-8") as f:
+            tasks_data = json.load(f)
+    except FileNotFoundError:
+        print(f"✗ Error: File '{args.json_file}' not found")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"✗ Error: Invalid JSON in '{args.json_file}': {e}")
+        sys.exit(1)
+
+    if not isinstance(tasks_data, list):
+        print("✗ Error: JSON file must contain an array of tasks")
+        sys.exit(1)
+
+    print(f"Found {len(tasks_data)} task(s) in file")
+
+    # Extract task keys
+    task_keys = []
+    missing_keys = []
+
+    for i, task in enumerate(tasks_data):
+        task_key = task.get("key") or task.get("id")
+        if task_key:
+            task_keys.append(task_key)
+        else:
+            missing_keys.append(f"Task at index {i}")
+
+    if missing_keys:
+        print(f"\n⚠ Warning: {len(missing_keys)} task(s) missing key/id:")
+        for key in missing_keys[:10]:
+            print(f"  - {key}")
+        if len(missing_keys) > 10:
+            print(f"  ... and {len(missing_keys) - 10} more")
+
+    if not task_keys:
+        print("\n✗ Error: No valid task keys found in JSON file")
+        sys.exit(1)
+
+    print(f"\nExtracted {len(task_keys)} task key(s)")
+
+    # Get account info
+    account = await fleet.env.account_async()
+    print(f"Fetching from team: {account.team_name}")
+
+    # Fetch tasks from API
+    fetched_tasks = await fetch_tasks_batch(task_keys, args.max_concurrent)
+
+    if not fetched_tasks:
+        print("\n✗ Error: No tasks were successfully fetched")
+        sys.exit(1)
+
+    # Update tasks in the original data
+    updated_count = 0
+    not_found = []
+
+    print("\nUpdating task data...")
+    for i, task in enumerate(tasks_data):
+        task_key = task.get("key") or task.get("id")
+
+        if task_key in fetched_tasks:
+            # Replace entire task with fetched data
+            tasks_data[i] = fetched_tasks[task_key]
+            updated_count += 1
+        else:
+            not_found.append(task_key or f"index {i}")
+
+    print(f"✓ Updated {updated_count} task(s)")
+
+    if not_found:
+        print(f"\n⚠ Warning: {len(not_found)} task(s) not fetched:")
+        for key in not_found[:10]:
+            print(f"  - {key}")
+        if len(not_found) > 10:
+            print(f"  ... and {len(not_found) - 10} more")
+
+    # Write output
+    output_file = args.output or args.json_file
+    print(f"\nWriting updated tasks to: {output_file}")
+
+    try:
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(tasks_data, f, indent=2, ensure_ascii=False)
+        print(f"✓ Successfully wrote {len(tasks_data)} task(s) to '{output_file}'")
+    except Exception as e:
+        print(f"✗ Error writing output file: {e}")
+        sys.exit(1)
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("Summary:")
+    print(f"  Total tasks in file: {len(tasks_data)}")
+    print(f"  Successfully fetched: {len(fetched_tasks)}")
+    print(f"  Updated in file: {updated_count}")
+    print(f"  Failed to fetch: {len(task_keys) - len(fetched_tasks)}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+