fleet-python 0.2.72b2__py3-none-any.whl → 0.2.73__py3-none-any.whl

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

examples/iterate_verifiers.py

@@ -0,0 +1,519 @@
+import argparse
+import json
+import re
+import sys
+from typing import Dict, Tuple, Optional
+
+
+def extract_function_info(function_code: str) -> Optional[Tuple[str, bool]]:
+    """
+    Extract function name and async status from Python function code.
+    Handles both regular functions (def) and async functions (async def).
+
+    Args:
+        function_code: Python function code as a string
+
+    Returns:
+        A tuple of (function_name, is_async) if found, None otherwise
+    """
+    # Normalize escaped newlines and strip common Markdown code fences
+    code = function_code.replace("\\n", "\n").strip()
+    if "```" in code:
+        # Extract the first fenced block if present
+        fence_blocks = re.findall(r"```[a-zA-Z0-9_+-]*\n([\s\S]*?)\n```", code)
+        if fence_blocks:
+            code = fence_blocks[0].strip()
+
+    # Remove leading decorators (keep them for regex but allow preceding lines)
+    # Robust regex: allow optional decorators and whitespace before the def
+    pattern = r"^\s*(?:@[\w\.\n+() ,]*\n\s*)*(async\s+)?def\s+([A-Za-z_]\w*)\s*\("
+
+    match = re.search(pattern, code, flags=re.MULTILINE)
+    if match:
+        is_async = match.group(1) is not None
+        function_name = match.group(2)
+        return (function_name, is_async)
+
+    # Fallback: search anywhere (not anchored) for a def signature
+    fallback = r"(async\s+)?def\s+([A-Za-z_]\w*)\s*\("
+    match = re.search(fallback, code)
+    if match:
+        is_async = match.group(1) is not None
+        function_name = match.group(2)
+        return (function_name, is_async)
+
+    return None
+
+
+def clean_verifier_code(code: str) -> str:
+    """
+    Clean verifier code by removing markdown code fences and normalizing whitespace.
+
+    Args:
+        code: Raw verifier code string
+
+    Returns:
+        Cleaned code string
+    """
+    # Normalize escaped newlines
+    code = code.replace("\\n", "\n").strip()
+
+    # Remove markdown code fences if present
+    if "```" in code:
+        fence_blocks = re.findall(r"```[a-zA-Z0-9_+-]*\n([\s\S]*?)\n```", code)
+        if fence_blocks:
+            code = fence_blocks[0].strip()
+
+    return code
+
+
+def extract_verifiers_to_file(json_path: str, py_path: str) -> None:
+    """
+    Extract verifiers from JSON file and write them to a Python file with decorators.
+
+    Args:
+        json_path: Path to input JSON file
+        py_path: Path to output Python file
+    """
+    print(f"Reading tasks from: {json_path}")
+
+    # Load JSON file
+    try:
+        with open(json_path, "r", encoding="utf-8") as f:
+            tasks = json.load(f)
+    except FileNotFoundError:
+        print(f"✗ Error: File '{json_path}' not found")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"✗ Error: Invalid JSON in '{json_path}': {e}")
+        sys.exit(1)
+
+    if not isinstance(tasks, list):
+        print("✗ Error: JSON file must contain an array of tasks")
+        sys.exit(1)
+
+    print(f"Found {len(tasks)} task(s)")
+
+    # Extract verifiers
+    verifiers = []
+    missing_verifier = []
+    duplicate_keys = set()
+    seen_keys = set()
+
+    for i, task in enumerate(tasks):
+        task_key = task.get("key") or task.get("id")
+        if not task_key:
+            print(f"⚠ Warning: Task at index {i} has no key or id, skipping")
+            continue
+
+        # Check for duplicate keys
+        if task_key in seen_keys:
+            duplicate_keys.add(task_key)
+            print(f"⚠ Warning: Duplicate task key '{task_key}' found")
+        seen_keys.add(task_key)
+
+        # Get verifier code from multiple possible locations
+        verifier_code = (
+            task.get("verifier_func")
+            or task.get("verifier_code")
+            or task.get("metadata", {}).get("verifier_code")
+        )
+
+        if not verifier_code:
+            missing_verifier.append(task_key)
+            continue
+
+        # Clean the code
+        cleaned_code = clean_verifier_code(verifier_code)
+
+        # Extract function info
+        func_info = extract_function_info(cleaned_code)
+        if not func_info:
+            print(
+                f"⚠ Warning: Could not extract function name from verifier for task '{task_key}'"
+            )
+            continue
+
+        function_name, is_async = func_info
+
+        verifiers.append(
+            {
+                "task_key": task_key,
+                "function_name": function_name,
+                "is_async": is_async,
+                "code": cleaned_code,
+            }
+        )
+
+    if missing_verifier:
+        print(f"\n⚠ Warning: {len(missing_verifier)} task(s) missing verifier code:")
+        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")
+
+    if duplicate_keys:
+        print(f"\n⚠ Warning: {len(duplicate_keys)} duplicate task key(s) found:")
+        for key in list(duplicate_keys)[:10]:
+            print(f"  - {key}")
+
+    print(f"\n✓ Extracted {len(verifiers)} verifier(s)")
+
+    # Count async vs sync
+    async_count = sum(1 for v in verifiers if v["is_async"])
+    sync_count = len(verifiers) - async_count
+    print(f"  - {async_count} async verifier(s)")
+    print(f"  - {sync_count} sync verifier(s)")
+
+    # Write to Python file
+    print(f"\nWriting verifiers to: {py_path}")
+
+    with open(py_path, "w", encoding="utf-8") as f:
+        # Write header
+        f.write('"""Auto-generated verifiers file.\n\n')
+        f.write(f"Extracted from: {json_path}\n")
+        f.write(f"Total verifiers: {len(verifiers)}\n")
+        f.write(f"  - Async: {async_count}\n")
+        f.write(f"  - Sync: {sync_count}\n")
+        f.write('"""\n\n')
+
+        # Write imports
+        f.write("# Import verifier decorators and dependencies\n")
+        f.write("from fleet import (\n")
+        f.write("    verifier,\n")
+        f.write("    AsyncEnv,\n")
+        f.write("    SyncEnv,\n")
+        f.write("    SyncEnv as Environment,\n")
+        f.write("    AsyncEnv as AsyncEnvironment,\n")
+        f.write("    IgnoreConfig,\n")
+        f.write("    TASK_FAILED_SCORE,\n")
+        f.write("    TASK_SUCCESSFUL_SCORE,\n")
+        f.write(")\n")
+        f.write("from fleet.verifiers.verifier import verifier as verifier_sync\n")
+        f.write("\n")
+        f.write("# Standard library imports used in verifiers\n")
+        f.write("import json\n")
+        f.write("import re\n")
+        f.write("import string\n")
+        f.write("from typing import Any\n")
+        f.write("\n")
+        f.write("# Helper functions available in verifier namespace\n")
+        f.write(
+            '_TRANSLATOR = str.maketrans(string.punctuation, " " * len(string.punctuation))\n'
+        )
+        f.write("\n")
+        f.write("def _normalize_text(value: str) -> str:\n")
+        f.write("    text = value.lower().translate(_TRANSLATOR)\n")
+        f.write('    return "".join(text.split())\n')
+        f.write("\n")
+        f.write("def _stringify_content(content: Any) -> str:\n")
+        f.write("    if isinstance(content, (dict, list)):\n")
+        f.write("        return json.dumps(content, sort_keys=True)\n")
+        f.write("    return str(content)\n")
+        f.write("\n")
+        f.write("def normalized_contains(target: str, blob: Any) -> bool:\n")
+        f.write("    normalized_target = _normalize_text(target)\n")
+        f.write("    normalized_blob = _normalize_text(_stringify_content(blob))\n")
+        f.write("    return normalized_target in normalized_blob\n")
+        f.write("\n")
+        f.write("def extract_numbers(text: str) -> list:\n")
+        f.write("    cleaned_text = text.replace(',', '')\n")
+        f.write("    pattern = r'-?\\d+\\.?\\d*'\n")
+        f.write("    matches = re.findall(pattern, cleaned_text)\n")
+        f.write("    return [float(num) for num in matches]\n")
+        f.write("\n")
+        f.write("def contains_number(text: str, target_number) -> bool:\n")
+        f.write("    numbers = extract_numbers(text)\n")
+        f.write("    try:\n")
+        f.write("        if isinstance(target_number, str):\n")
+        f.write("            target_number = target_number.replace(',', '')\n")
+        f.write("        target = float(target_number)\n")
+        f.write("    except (ValueError, AttributeError):\n")
+        f.write("        return False\n")
+        f.write("    return target in numbers\n")
+        f.write("\n")
+        f.write("# " + "=" * 78 + "\n")
+        f.write("# VERIFIERS\n")
+        f.write("# " + "=" * 78 + "\n\n")
+
+        # Write each verifier
+        for i, ver in enumerate(verifiers):
+            # Write separator comment
+            if i > 0:
+                f.write("\n" + "# " + "-" * 78 + "\n\n")
+
+            # Write task key comment
+            f.write(f"# Task: {ver['task_key']}\n")
+            f.write(
+                f"# Function: {ver['function_name']} ({'async' if ver['is_async'] else 'sync'})\n"
+            )
+
+            # Write decorator - use verifier for async, verifier_sync for sync
+            decorator_name = "verifier" if ver["is_async"] else "verifier_sync"
+            f.write(f'@{decorator_name}(key="{ver["task_key"]}")\n')
+
+            # Write function code
+            f.write(ver["code"])
+            f.write("\n")
+
+    print(f"✓ Successfully wrote {len(verifiers)} verifier(s) to '{py_path}'")
+    print("\nNext steps:")
+    print(f"  1. Edit the verifiers in '{py_path}'")
+    print(f"  2. Run: python {sys.argv[0]} apply {json_path} {py_path}")
+
+
+def parse_verifiers_from_file(python_path: str) -> Dict[str, str]:
+    """
+    Parse verifiers from a Python file and extract them by task key.
+
+    Args:
+        python_path: Path to Python file containing verifiers
+
+    Returns:
+        Dictionary mapping task_key to verifier code
+    """
+    print(f"Reading verifiers from: {python_path}")
+
+    try:
+        with open(python_path, "r", encoding="utf-8") as f:
+            content = f.read()
+    except FileNotFoundError:
+        print(f"✗ Error: File '{python_path}' not found")
+        sys.exit(1)
+
+    # Split content by the separator comments to get individual verifier sections
+    # The separator is "# ------------------------------------------------------------------------------"
+    # Each section starts with "# Task: <key>"
+
+    verifiers = {}
+
+    # Split by "# Task: " markers to find each verifier block
+    task_blocks = re.split(r"\n# Task: ", content)
+
+    for block in task_blocks[1:]:  # Skip the first block (header)
+        # Extract task key from the first line
+        lines = block.split("\n")
+        if not lines:
+            continue
+
+        # First line should be the task key
+        task_key = lines[0].strip()
+
+        # Find the @verifier or @verifier_sync decorator to extract the key parameter
+        verifier_match = re.search(
+            r'@verifier(?:_sync)?\(key=["\']([^"\']+)["\']\s*(?:,\s*[^)]+)?\)', block
+        )
+        if verifier_match:
+            task_key = verifier_match.group(1)
+
+        # Find the function definition (async def or def)
+        # Extract from the function start until we hit the separator or end
+        func_pattern = r"((async\s+)?def\s+\w+.*?)(?=\n# -+\n|\n# Task:|\Z)"
+        func_match = re.search(func_pattern, block, re.DOTALL)
+
+        if func_match:
+            function_code = func_match.group(1).strip()
+            verifiers[task_key] = function_code
+
+    # If the above approach didn't work, try a direct pattern match
+    if not verifiers:
+        # Pattern to match @verifier or @verifier_sync decorator with key and the following function
+        # Look for the decorator, then capture everything until we hit a dedented line or separator
+        pattern = r'@verifier(?:_sync)?\(key=["\']([^"\']+)["\']\s*(?:,\s*[^)]+)?\)\s*\n((?:async\s+)?def\s+[^\n]+:(?:\n(?:    |\t).*)*(?:\n(?:    |\t).*)*)'
+
+        matches = re.findall(pattern, content, re.MULTILINE)
+
+        for task_key, function_code in matches:
+            verifiers[task_key] = function_code.strip()
+
+    print(f"✓ Found {len(verifiers)} verifier(s)")
+
+    # Analyze async vs sync
+    async_count = 0
+    sync_count = 0
+    for code in verifiers.values():
+        func_info = extract_function_info(code)
+        if func_info:
+            _, is_async = func_info
+            if is_async:
+                async_count += 1
+            else:
+                sync_count += 1
+
+    print(f"  - {async_count} async verifier(s)")
+    print(f"  - {sync_count} sync verifier(s)")
+
+    return verifiers
+
+
+def apply_verifiers_to_json(json_path: str, python_path: str) -> None:
+    """
+    Apply verifiers from Python file back into JSON task file (updates in-place).
+
+    Args:
+        json_path: Path to JSON file to update
+        python_path: Path to Python file with verifiers
+    """
+    # Parse verifiers from Python file
+    verifiers = parse_verifiers_from_file(python_path)
+
+    # Load JSON file
+    print(f"\nReading tasks from: {json_path}")
+    try:
+        with open(json_path, "r", encoding="utf-8") as f:
+            tasks = json.load(f)
+    except FileNotFoundError:
+        print(f"✗ Error: File '{json_path}' not found")
+        sys.exit(1)
+    except json.JSONDecodeError as e:
+        print(f"✗ Error: Invalid JSON in '{json_path}': {e}")
+        sys.exit(1)
+
+    if not isinstance(tasks, list):
+        print("✗ Error: JSON file must contain an array of tasks")
+        sys.exit(1)
+
+    print(f"Found {len(tasks)} task(s)")
+
+    # Update tasks with new verifiers (only if changed)
+    updated_count = 0
+    updated_keys = []
+    not_found = []
+
+    for task in tasks:
+        task_key = task.get("key") or task.get("id")
+        if not task_key:
+            continue
+
+        if task_key in verifiers:
+            new_code = verifiers[task_key]
+            old_code = task.get("verifier_func", "").strip()
+
+            # Only update if the code actually changed
+            if old_code != new_code.strip():
+                # Update verifier_func with new code
+                task["verifier_func"] = new_code
+
+                # Also update metadata if it exists
+                if "metadata" in task and isinstance(task["metadata"], dict):
+                    task["metadata"]["verifier_code"] = new_code
+
+                # Clear verifier_id and verifier_sha to force re-upload
+                task["verifier_id"] = None
+                task["verifier_sha"] = None
+
+                updated_count += 1
+                updated_keys.append(task_key)
+        else:
+            not_found.append(task_key)
+
+    print(f"\n✓ Updated {updated_count} task(s) with new verifiers")
+
+    if updated_keys:
+        print("\nUpdated task keys:")
+        for key in updated_keys:
+            print(f"  - {key}")
+
+    if not_found:
+        print(f"\n⚠ Warning: {len(not_found)} task(s) not found in Python file:")
+        for key in not_found[:10]:
+            print(f"  - {key}")
+        if len(not_found) > 10:
+            print(f"  ... and {len(not_found) - 10} more")
+
+    # Write output back to the same JSON file
+    print(f"\nWriting updated tasks to: {json_path}")
+
+    try:
+        with open(json_path, "w", encoding="utf-8") as f:
+            json.dump(tasks, f, indent=2, ensure_ascii=False)
+        print(f"✓ Successfully updated {len(tasks)} task(s) in '{json_path}'")
+    except Exception as e:
+        print(f"✗ Error writing JSON file: {e}")
+        sys.exit(1)
+
+
+def validate_verifiers_file(python_path: str) -> None:
+    """
+    Validate that a Python verifiers file can be parsed correctly.
+
+    Args:
+        python_path: Path to Python file with verifiers
+    """
+    verifiers = parse_verifiers_from_file(python_path)
+
+    print("\nValidating verifiers...")
+    errors = []
+
+    for task_key, code in verifiers.items():
+        func_info = extract_function_info(code)
+        if not func_info:
+            errors.append(f"  - {task_key}: Could not extract function info")
+        else:
+            function_name, is_async = func_info
+            print(
+                f"  ✓ {task_key}: {function_name} ({'async' if is_async else 'sync'})"
+            )
+
+    if errors:
+        print(f"\n✗ Found {len(errors)} error(s):")
+        for error in errors:
+            print(error)
+        sys.exit(1)
+    else:
+        print(f"\n✓ All {len(verifiers)} verifier(s) are valid!")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Iterate on verifier code from JSON task files",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Extract verifiers from JSON to Python file
+  %(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 xai-day-10-batch.json verifiers.py
+  
+  # Validate verifiers file
+  %(prog)s validate verifiers.py
+        """,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+    subparsers.required = True
+
+    # Extract command
+    extract_parser = subparsers.add_parser(
+        "extract", help="Extract verifiers from JSON to Python file"
+    )
+    extract_parser.add_argument("json_file", help="Path to JSON file containing tasks")
+    extract_parser.add_argument("py_file", help="Path to output Python file")
+
+    # Apply command
+    apply_parser = subparsers.add_parser(
+        "apply", help="Apply verifiers from Python file back to JSON (updates in-place)"
+    )
+    apply_parser.add_argument("json_file", help="Path to JSON file to update")
+    apply_parser.add_argument("py_file", help="Path to Python file with verifiers")
+
+    # Validate command
+    validate_parser = subparsers.add_parser("validate", help="Validate verifiers file")
+    validate_parser.add_argument("py_file", help="Path to Python file with verifiers")
+
+    args = parser.parse_args()
+
+    # Execute command
+    if args.command == "extract":
+        extract_verifiers_to_file(args.json_file, args.py_file)
+    elif args.command == "apply":
+        apply_verifiers_to_json(args.json_file, args.py_file)
+    elif args.command == "validate":
+        validate_verifiers_file(args.py_file)
+
+
+if __name__ == "__main__":
+    main()

fleet/__init__.py

@@ -73,7 +73,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.71"
+__version__ = "0.2.72"
 
 __all__ = [
     # Core classes

fleet/_async/__init__.py

@@ -44,7 +44,7 @@ from ..types import VerifierFunction
 from .. import env
 from . import global_client as _async_global_client
 
-__version__ = "0.2.71"
+__version__ = "0.2.72"
 
 __all__ = [
     # Core classes

fleet/_async/base.py

@@ -2,6 +2,7 @@ import httpx
 from typing import Dict, Any, Optional
 import json
 import logging
+import time
 import uuid
 
 from ..models import InstanceResponse
@@ -25,7 +26,7 @@ from .exceptions import (
 try:
     from .. import __version__
 except ImportError:
-    __version__ = "0.2.71"
+    __version__ = "0.2.72"
 
 logger = logging.getLogger(__name__)
 
@@ -51,11 +52,14 @@ class BaseWrapper:
             "X-Fleet-SDK-Version": __version__,
         }
         headers["Authorization"] = f"Bearer {self.api_key}"
-        
+
         # Add request ID for idempotency (persists across retries)
         if request_id:
             headers["X-Request-ID"] = request_id
-        
+
+        # Add timestamp for all requests
+        headers["X-Request-Timestamp"] = str(int(time.time() * 1000))
+
         return headers
 
 

fleet/_async/client.py

@@ -172,6 +172,7 @@ class AsyncEnv(EnvironmentBase):
         kwargs: dict,
         timeout: Optional[int] = 30,
         needs_upload: bool = True,
+        verifier_runtime_version: Optional[str] = None,
     ) -> VerifiersExecuteResponse:
         return await _execute_verifier_remote(
             self._load_client,
@@ -184,6 +185,7 @@ class AsyncEnv(EnvironmentBase):
             kwargs,
             timeout,
             needs_upload,
+            verifier_runtime_version,
         )
 
     def __getstate__(self):
@@ -611,6 +613,11 @@ class AsyncFleet:
         if not verifier_id:
             verifier_id = task_json.get("key", task_json.get("id"))
 
+        # Extract verifier_runtime_version from metadata if present
+        verifier_runtime_version = None
+        if "metadata" in task_json and isinstance(task_json["metadata"], dict):
+            verifier_runtime_version = task_json["metadata"].get("verifier_runtime_version")
+
         try:
             if verifier_id and verifier_code:
                 verifier = await self._create_verifier_from_data(
@@ -618,6 +625,7 @@ class AsyncFleet:
                     verifier_key=task_json.get("key", task_json.get("id")),
                     verifier_code=verifier_code,
                     verifier_sha=verifier_sha,
+                    verifier_runtime_version=verifier_runtime_version,
                 )
         except Exception as e:
             error_msg = f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
@@ -641,6 +649,7 @@ class AsyncFleet:
             verifier=verifier,  # Use created verifier or None
             verifier_id=verifier_id,  # Set verifier_id so _rebuild_verifier works
             verifier_sha=verifier_sha,  # Set verifier_sha
+            verifier_runtime_version=verifier_runtime_version,  # Set verifier_runtime_version
             metadata=task_json.get("metadata", {}),  # Default empty metadata
             output_json_schema=task_json.get("output_json_schema"),  # JSON schema for output
         )
@@ -999,7 +1008,7 @@ class AsyncFleet:
         return TaskResponse(**response.json())
 
     async def _create_verifier_from_data(
-        self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str
+        self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str, verifier_runtime_version: Optional[str] = None
     ) -> "AsyncVerifierFunction":
         """Create an AsyncVerifierFunction from verifier data.
 
@@ -1020,6 +1029,7 @@ class AsyncFleet:
             verifier_id=verifier_id,
             verifier_key=verifier_key,
             sha256=verifier_sha,
+            verifier_runtime_version=verifier_runtime_version or "",
         )
 
         # Store the original verifier code for reference
@@ -1104,6 +1114,7 @@ async def _execute_verifier_remote(
     kwargs: dict,
     timeout: Optional[int] = 30,
     needs_upload: bool = True,
+    verifier_runtime_version: Optional[str] = None,
 ) -> VerifiersExecuteResponse:
     # Pickle args and kwargs together
     # The first arg should be None as a placeholder for env
@@ -1127,6 +1138,10 @@ async def _execute_verifier_remote(
         bundle_b64 = base64.b64encode(bundle_data).decode("utf-8")
         request_data["bundle"] = bundle_b64
 
+    # Add verifier_runtime_version if present
+    if verifier_runtime_version:
+        request_data["verifier_runtime_version"] = verifier_runtime_version
+
     # Debug logging
     # logger.debug(
     #     f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"

fleet/_async/verifiers/verifier.py

@@ -42,6 +42,7 @@ class AsyncVerifierFunction:
         verifier_id: Optional[str] = None,
         sha256: Optional[str] = None,
         raw_code: Optional[str] = None,
+        verifier_runtime_version: Optional[str] = None,
     ):
         self.func = func
         self.key = key
@@ -52,6 +53,7 @@ class AsyncVerifierFunction:
         self._bundle_data: Optional[bytes] = None  # Cached bundle data
         self._raw_code: Optional[str] = raw_code  # Store raw code if provided
         self._is_async = asyncio.iscoroutinefunction(func)
+        self.verifier_runtime_version = verifier_runtime_version
 
         # Copy function metadata
         functools.update_wrapper(self, func)
@@ -251,6 +253,7 @@ Remote traceback:
                     args_array=args_array,
                     kwargs=kwargs,
                     needs_upload=True,
+                    verifier_runtime_version=self.verifier_runtime_version,
                 )
 
                 # logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
@@ -267,6 +270,7 @@ Remote traceback:
                     args_array=args_array,
                     kwargs=kwargs,
                     needs_upload=False,
+                    verifier_runtime_version=self.verifier_runtime_version,
                 )
 
             return response
@@ -287,6 +291,7 @@ Remote traceback:
                     args_array=args_array,
                     kwargs=kwargs,
                     needs_upload=True,
+                    verifier_runtime_version=self.verifier_runtime_version,
                 )
                 return response
             else:

fleet/base.py

@@ -2,6 +2,7 @@ import httpx
 from typing import Dict, Any, Optional
 import json
 import logging
+import time
 import uuid
 
 from .models import InstanceResponse
@@ -25,7 +26,7 @@ from .exceptions import (
 try:
     from . import __version__
 except ImportError:
-    __version__ = "0.2.71"
+    __version__ = "0.2.72"
 
 logger = logging.getLogger(__name__)
 
@@ -51,11 +52,14 @@ class BaseWrapper:
             "X-Fleet-SDK-Version": __version__,
         }
         headers["Authorization"] = f"Bearer {self.api_key}"
-        
+
         # Add request ID for idempotency (persists across retries)
         if request_id:
             headers["X-Request-ID"] = request_id
-        
+
+        # Add timestamp for all requests
+        headers["X-Request-Timestamp"] = str(int(time.time() * 1000))
+
         return headers
 
 

fleet/client.py

@@ -181,6 +181,7 @@ class SyncEnv(EnvironmentBase):
         kwargs: dict,
         timeout: Optional[int] = 30,
         needs_upload: bool = True,
+        verifier_runtime_version: Optional[str] = None,
     ) -> VerifiersExecuteResponse:
         return _execute_verifier_remote(
             self._load_client,
@@ -193,6 +194,7 @@ class SyncEnv(EnvironmentBase):
             kwargs,
             timeout,
             needs_upload,
+            verifier_runtime_version,
         )
 
     def __getstate__(self):
@@ -620,6 +622,11 @@ class Fleet:
         if not verifier_id:
             verifier_id = task_json.get("key", task_json.get("id"))
 
+        # Extract verifier_runtime_version from metadata if present
+        verifier_runtime_version = None
+        if "metadata" in task_json and isinstance(task_json["metadata"], dict):
+            verifier_runtime_version = task_json["metadata"].get("verifier_runtime_version")
+
         try:
             if verifier_id and verifier_code:
                 verifier = self._create_verifier_from_data(
@@ -627,6 +634,7 @@ class Fleet:
                     verifier_key=task_json.get("key", task_json.get("id")),
                     verifier_code=verifier_code,
                     verifier_sha=verifier_sha,
+                    verifier_runtime_version=verifier_runtime_version,
                 )
         except Exception as e:
             error_msg = f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
@@ -650,6 +658,7 @@ class Fleet:
             verifier=verifier,  # Use created verifier or None
             verifier_id=verifier_id,  # Set verifier_id so _rebuild_verifier works
             verifier_sha=verifier_sha,  # Set verifier_sha
+            verifier_runtime_version=verifier_runtime_version,  # Set verifier_runtime_version
             metadata=task_json.get("metadata", {}),  # Default empty metadata
             output_json_schema=task_json.get("output_json_schema"),  # JSON schema for output
         )
@@ -1007,7 +1016,7 @@ class Fleet:
         return TaskResponse(**response.json())
 
     def _create_verifier_from_data(
-        self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str
+        self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str, verifier_runtime_version: Optional[str] = None
     ) -> "SyncVerifierFunction":
         """Create an AsyncVerifierFunction from verifier data.
 
@@ -1029,6 +1038,7 @@ class Fleet:
             verifier_id=verifier_id,
             verifier_key=verifier_key,
             sha256=verifier_sha,
+            verifier_runtime_version=verifier_runtime_version or "",
         )
 
         # Store the original verifier code for reference
@@ -1113,6 +1123,7 @@ def _execute_verifier_remote(
     kwargs: dict,
     timeout: Optional[int] = 30,
     needs_upload: bool = True,
+    verifier_runtime_version: Optional[str] = None,
 ) -> VerifiersExecuteResponse:
     # Pickle args and kwargs together
     # The first arg should be None as a placeholder for env
@@ -1136,6 +1147,10 @@ def _execute_verifier_remote(
         bundle_b64 = base64.b64encode(bundle_data).decode("utf-8")
         request_data["bundle"] = bundle_b64
 
+    # Add verifier_runtime_version if present
+    if verifier_runtime_version:
+        request_data["verifier_runtime_version"] = verifier_runtime_version
+
     # Debug logging
     # logger.debug(
     #     f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"

fleet/tasks.py

@@ -36,6 +36,7 @@ class Task(BaseModel):
     )
     verifier_id: Optional[str] = Field(None, description="Verifier identifier")
     verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
+    verifier_runtime_version: Optional[str] = Field(None, description="Verifier runtime version")
     metadata: Optional[Dict[str, Any]] = Field(
         default_factory=dict, description="Additional task metadata"
     )
@@ -199,6 +200,7 @@ class Task(BaseModel):
                 verifier_id=verifier_id,
                 verifier_key=self.key,
                 sha256=self.verifier_sha or "",
+                verifier_runtime_version=self.verifier_runtime_version or "",
             )
             self.verifier = verifier
 
@@ -273,7 +275,7 @@ class Task(BaseModel):
 
 
 def verifier_from_string(
-    verifier_func: str, verifier_id: str, verifier_key: str, sha256: str = ""
+    verifier_func: str, verifier_id: str, verifier_key: str, sha256: str = "", verifier_runtime_version: str = ""
 ) -> "VerifierFunction":
     """Create a verifier function from string code.
 
@@ -380,6 +382,7 @@ def verifier_from_string(
             verifier_id=verifier_id,
             sha256=sha256,
             raw_code=verifier_func,
+            verifier_runtime_version=verifier_runtime_version if verifier_runtime_version else None,
         )
 
         # Store additional metadata

fleet/verifiers/verifier.py

@@ -53,6 +53,7 @@ class SyncVerifierFunction:
         verifier_id: Optional[str] = None,
         sha256: Optional[str] = None,
         raw_code: Optional[str] = None,
+        verifier_runtime_version: Optional[str] = None,
     ):
         self.func = func
         self.key = key
@@ -63,6 +64,7 @@ class SyncVerifierFunction:
         self._bundle_data: Optional[bytes] = None  # Cached bundle data
         self._raw_code: Optional[str] = raw_code  # Store raw code if provided
         self._is_async = inspect.iscoroutinefunction(func)
+        self.verifier_runtime_version = verifier_runtime_version
 
         # Copy function metadata
         functools.update_wrapper(self, func)
@@ -262,6 +264,7 @@ Remote traceback:
                     args_array=args_array,
                     kwargs=kwargs,
                     needs_upload=True,
+                    verifier_runtime_version=self.verifier_runtime_version,
                 )
 
                 # logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
@@ -279,6 +282,7 @@ Remote traceback:
                     args_array=args_array,
                     kwargs=kwargs,
                     needs_upload=False,
+                    verifier_runtime_version=self.verifier_runtime_version,
                 )
                 return response
 
@@ -298,6 +302,7 @@ Remote traceback:
                     args_array=args_array,
                     kwargs=kwargs,
                     needs_upload=True,
+                    verifier_runtime_version=self.verifier_runtime_version,
                 )
                 return response
             else:

{fleet_python-0.2.72b2.dist-info → fleet_python-0.2.73.dist-info}/METADATA

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

{fleet_python-0.2.72b2.dist-info → fleet_python-0.2.73.dist-info}/RECORD

@@ -12,8 +12,10 @@ examples/example_task.py,sha256=dhG6STAkNsTdHs9cO1RFH9WfuvRmq5bRC211hTeFrk8,7088
 examples/example_tasks.py,sha256=xTL8UWVAuolSX6swskfrAcmDrLIzn45dJ7YPWCwoEBU,514
 examples/example_verifier.py,sha256=0vwNITIG3m4CkSPwIxNXcGx9TqrxEsCGqK2A8keKZMM,2392
 examples/export_tasks.py,sha256=Sk2Id4i5tZeVs4ZFQoAn-ABFZv7ewyv4pqtZ-Z-tIEI,3574
+examples/fetch_tasks.py,sha256=3A4F0OSUTwUddTOoDNlI-CSxeOnpl3E3zHBh0Qsw9A8,6865
 examples/gemini_example.py,sha256=qj9WDazQTYNiRHNeUg9Tjkp33lJMwbx8gDfpFe1sDQo,16180
 examples/import_tasks.py,sha256=McF5MbHenPZ7HTjQfNoHHevot0EBILMSsWtroicVT30,11619
+examples/iterate_verifiers.py,sha256=vYinKK3JJwJdk8j5BkES6rN6Thjc04xfeft1WKDQnvw,18174
 examples/json_tasks_example.py,sha256=CYPESGGtOo0fmsDdLidujTfsE4QlJHw7rOhyVqPJ_Ls,5329
 examples/nova_act_example.py,sha256=rH23Lp74Okf0rn8ynMdWjK2aviEf5NLPH4k_53Pyxho,831
 examples/openai_example.py,sha256=dEWERrTEP5xBiGkLkQjBQGd2NqoxX6gcW6XteBPsWFQ,8231
@@ -21,18 +23,18 @@ examples/openai_simple_example.py,sha256=HmiufucrAZne7tHq9uoEsDWlEhjNC265bQAyIGB
 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=HRXR5gVBiGzIY4lgvt-2ni6t3J_4nLnexzXxk2Qzc5w,4218
-fleet/base.py,sha256=zE4I8P0TEV0DuqxcspxUvZz0FxC_zegonZZLAiiZ0Yc,9501
-fleet/client.py,sha256=SpKwHVOQiP0QErW7KCH7YEhXEmqTnTfMOMMubbqGEFE,43338
+fleet/__init__.py,sha256=g3iCjVyltxf8RE1h-7UKeGGpLuQW-mjdAG9zQ65qvS0,4218
+fleet/base.py,sha256=rn-Jpu37cw_ogMRaW6FWwDh_L6-807CJnBSkiJ_Ggxw,9609
+fleet/client.py,sha256=9NjDhcBA1iEqKvdahhgGN1p4OX-S8opWPyb0j7H662A,44205
 fleet/config.py,sha256=n_wh9Sahu3gGE7nHJ7kqNFUH1qDiBtF4bgZq9MvIBMU,319
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
 fleet/models.py,sha256=7ZRUVBT0_6tiJkotWLTj52oVaeDfP4OsjjkWJxhf8CA,15409
-fleet/tasks.py,sha256=Oe42Op0k8rQ9mPXffa_Pwoc1JBHu51wKyLyeI83JA6w,20406
+fleet/tasks.py,sha256=7PqxpG_CRYJLiEFewpRPdiFU30Trc9B6UAAqKtF3iy4,20719
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
-fleet/_async/__init__.py,sha256=uN9LVRW1WFGEt2aDOCyGhJYgiswziQ1hZIB-jDArxRk,9101
-fleet/_async/base.py,sha256=UL7BHkobj2eN5-Am52-r0a3Fvt2aNJjkXyhTAwFTUok,9522
-fleet/_async/client.py,sha256=U1UBXIsUKJ3n5DxTFDdcNpgZFVZt7YMDCeD9NycE5Ys,43399
+fleet/_async/__init__.py,sha256=80CAiLFSyLyjdWNIdUNxdvTl0kqWH83505DuDCzFJzY,9101
+fleet/_async/base.py,sha256=tTn7AD4xH-9ZuwuGPmeH6dgQVP8r7abB90LykLTVGn0,9630
+fleet/_async/client.py,sha256=eBB6c3NI3XY0S2Q-yj_QdN2zXdZsGXJgp9ROVpG6EY0,44266
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
 fleet/_async/models.py,sha256=-3xv2QyoHsvYcWmdKLf9Z93md8XB17DBeJCxdRCB3bo,13571
@@ -49,7 +51,7 @@ fleet/_async/resources/mcp.py,sha256=TLEsLiFhfVfZFs0Fu_uDPm-h4FPdvqgQblYqs-PTHhc
 fleet/_async/resources/sqlite.py,sha256=smzDpSyjSswKnFEZhO-tbonMrItHTKl-9E-CRu2t7sM,51881
 fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
 fleet/_async/verifiers/bundler.py,sha256=9aWWXFsovBPcndE06IATn5jaeli5fRORAYeenF9heN0,26264
-fleet/_async/verifiers/verifier.py,sha256=Zvok2Mog09l885StW429Rg_8_4bd-gaYUGIgpILeb_I,14207
+fleet/_async/verifiers/verifier.py,sha256=iSa-rO-E1R3IQTFS9Z7jbQvQVtsDkilITQP9IIQU2JA,14556
 fleet/env/__init__.py,sha256=BVPZ4AYTznL6AYNrVmjr1yLF16qBcT1U56jWwF7AJ5o,964
 fleet/env/client.py,sha256=N9oF2hGSNmfVacTnyQhIEocoN3BA5fMa-arbpVeNi-E,3221
 fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
@@ -68,8 +70,8 @@ fleet/verifiers/db.py,sha256=LAh1HambBInH_D9q9E2Z41YNkCOI9JJfpWPFqztjpfQ,27922
 fleet/verifiers/decorator.py,sha256=RuTjjDijbicNfMSjA7HcTpKueEki5dzNOdTuHS7UoZs,3262
 fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
-fleet/verifiers/verifier.py,sha256=npnTBB-A1Cl66gNOGPR6UaybvcDy6C6_hWchyIJeDyc,14252
-fleet_python-0.2.72b2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet/verifiers/verifier.py,sha256=iqGevW7dSd0J5RdRQjpu-zioy_FYAXnzMfkuB3-QmO0,14601
+fleet_python-0.2.73.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=X9fWLTpiPGkSHsjyQUDepOJkxOqw1DPj7nd8wFlFqLQ,8368
 scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
 tests/__init__.py,sha256=Re1SdyxH8NfyL1kjhi7SQkGP1mYeWB-D6UALqdIMd8I,35
@@ -78,7 +80,7 @@ tests/test_instance_dispatch.py,sha256=CvU4C3LBIqsYZdEsEFfontGjyxAZfVYyXnGwxyIvX
 tests/test_sqlite_resource_dual_mode.py,sha256=Mh8jBd-xsIGDYFsOACKKK_5DXMUYlFFS7W-jaY6AjG4,8734
 tests/test_sqlite_shared_memory_behavior.py,sha256=fKx_1BmLS3b8x-9pMgjMycpnaHWY8P-2ZuXEspx6Sbw,4082
 tests/test_verifier_from_string.py,sha256=Lxi3TpFHFb-hG4-UhLKZJkqo84ax9YJY8G6beO-1erM,13581
-fleet_python-0.2.72b2.dist-info/METADATA,sha256=sfbqYC5oJI-MKlwTK_1qNgB7QheXKOUGDHnufWBdNR0,3306
-fleet_python-0.2.72b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.72b2.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
-fleet_python-0.2.72b2.dist-info/RECORD,,
+fleet_python-0.2.73.dist-info/METADATA,sha256=n9YCaiF3pd1HdNwRxOvBhsLb6PA4DrPy8g1U7Al85d4,3304
+fleet_python-0.2.73.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.73.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
+fleet_python-0.2.73.dist-info/RECORD,,