fleet-python 0.2.61__tar.gz → 0.2.63__tar.gz

{fleet_python-0.2.61/fleet_python.egg-info → fleet_python-0.2.63}/PKG-INFO

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

fleet_python-0.2.63/examples/import_tasks.py

@@ -0,0 +1,313 @@
+import asyncio
+import argparse
+import json
+import sys
+from collections import defaultdict
+from typing import Dict, List, Tuple
+import fleet
+from fleet._async.tasks import Task
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def run_verifier_sanity_check(
+    tasks: List[Task],
+    client: fleet.AsyncFleet,
+) -> Tuple[bool, Dict[str, str]]:
+    """
+    Run sanity check by spinning up instances and running verifiers.
+
+    Args:
+        tasks: List of Task objects to verify
+        client: AsyncFleet client instance
+
+    Returns:
+        Tuple of (all_passed, error_dict) where error_dict maps task_key to error message
+    """
+    print("\n" + "=" * 60)
+    print("Running verifier sanity check...")
+    print("=" * 60)
+
+    # Group tasks by env_key×env_version×data_key×data_version
+    instance_groups = defaultdict(list)
+    for task in tasks:
+        # Build the instance key
+        env_key = task.env_id or ""
+        env_version = task.version or ""
+        data_key = task.data_id or ""
+        data_version = task.data_version or ""
+
+        instance_key = f"{env_key}×{env_version}×{data_key}×{data_version}"
+        instance_groups[instance_key].append(task)
+
+    print(f"\nFound {len(instance_groups)} unique environment/data combinations:")
+    for instance_key, group_tasks in instance_groups.items():
+        print(f"  {instance_key}: {len(group_tasks)} task(s)")
+
+    # Create all instances in parallel
+    print(f"\nCreating {len(instance_groups)} instance(s) in parallel...")
+    instance_map = {}
+
+    async def create_instance(instance_key: str) -> Tuple[str, object]:
+        """Create a single instance."""
+        try:
+            env_key, env_version, data_key, data_version = instance_key.split("×")
+
+            # Build env_key_str and data_key_str
+            if env_version:
+                env_key_str = f"{env_key}:{env_version}"
+            else:
+                env_key_str = env_key
+
+            if data_key and data_version:
+                data_key_str = f"{data_key}:{data_version}"
+            elif data_key:
+                data_key_str = data_key
+            else:
+                data_key_str = None
+
+            print(
+                f"  Creating instance: {env_key_str}"
+                + (f" with data {data_key_str}" if data_key_str else "")
+            )
+            env = await client.make(env_key=env_key_str, data_key=data_key_str)
+            return instance_key, env
+        except Exception as e:
+            print(f"  ✗ Failed to create instance for {instance_key}: {e}")
+            return instance_key, None
+
+    # Create instances concurrently
+    instance_results = await asyncio.gather(
+        *[create_instance(key) for key in instance_groups.keys()],
+        return_exceptions=True,
+    )
+
+    for result in instance_results:
+        if isinstance(result, Exception):
+            print(f"  ✗ Exception creating instance: {result}")
+            return False, {"__instance_creation__": str(result)}
+        instance_key, env = result
+        if env is None:
+            return False, {instance_key: "Failed to create instance"}
+        instance_map[instance_key] = env
+
+    print(f"✓ Created {len(instance_map)} instance(s)")
+
+    # Run all verifiers in parallel with concurrency limit
+    max_concurrent_verifiers = 5  # Limit concurrent verifier executions
+    print(
+        f"\nRunning {len(tasks)} verifier(s) in parallel (max {max_concurrent_verifiers} concurrent)..."
+    )
+    errors = {}
+    semaphore = asyncio.Semaphore(max_concurrent_verifiers)
+
+    async def run_single_verifier(task, instance_key: str) -> Tuple[str, bool, str]:
+        """Run a single verifier and return (task_key, success, error_message)."""
+        async with semaphore:
+            try:
+                env = instance_map[instance_key]
+                task_key = task.key
+
+                # Run the verifier
+                if task.verifier is None:
+                    return task_key, False, "No verifier found"
+
+                result = await task.verify_async(env)
+
+                # For sanity check: we expect verifiers to return 0.0 (TASK_FAILED_SCORE)
+                # since we're running on fresh instances with no task completion.
+                # This confirms the verifier runs without errors.
+                if isinstance(result, float):
+                    if result == 0.0:
+                        print(f"  ✓ {task_key}: {result:.2f} (correctly returns 0.0)")
+                        return task_key, True, ""
+                    else:
+                        print(
+                            f"  ⚠ {task_key}: {result:.2f} (expected 0.0 on fresh instance)"
+                        )
+                        return (
+                            task_key,
+                            False,
+                            f"Expected 0.0 but got {result:.2f} on fresh instance",
+                        )
+                else:
+                    # Non-float result - verifier ran but didn't return expected type
+                    print(f"  ⚠ {task_key}: {result} (expected float 0.0)")
+                    return (
+                        task_key,
+                        False,
+                        f"Expected float 0.0 but got {type(result).__name__}: {result}",
+                    )
+
+            except Exception as e:
+                task_key = task.key
+                error_msg = f"{type(e).__name__}: {str(e)}"
+                print(f"  ✗ {task_key}: {error_msg}")
+                return task_key, False, error_msg
+
+    # Run verifiers concurrently with semaphore
+    verifier_results = await asyncio.gather(
+        *[
+            run_single_verifier(task, instance_key)
+            for instance_key, group_tasks in instance_groups.items()
+            for task in group_tasks
+        ],
+        return_exceptions=True,
+    )
+
+    # Process results
+    for result in verifier_results:
+        if isinstance(result, Exception):
+            print(f"  ✗ Exception running verifier: {result}")
+            errors["__verifier_exception__"] = str(result)
+        else:
+            task_key, success, error_msg = result
+            if not success:
+                errors[task_key] = error_msg
+
+    # Clean up instances
+    print(f"\nCleaning up {len(instance_map)} instance(s)...")
+    cleanup_tasks = [env.close() for env in instance_map.values()]
+    await asyncio.gather(*cleanup_tasks, return_exceptions=True)
+    print("✓ Cleanup complete")
+
+    # Summary
+    passed_count = len(tasks) - len(errors)
+    print("\n" + "=" * 60)
+    print(f"Sanity check complete: {passed_count}/{len(tasks)} passed")
+
+    if errors:
+        print(f"\n✗ {len(errors)} verifier(s) failed:")
+        for task_key, error_msg in list(errors.items())[:10]:
+            print(f"  - {task_key}: {error_msg}")
+        if len(errors) > 10:
+            print(f"  ... and {len(errors) - 10} more")
+        print("\nFix the verifiers and try again.")
+        return False, errors
+    else:
+        print("✓ All verifiers passed!")
+        return True, {}
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="Import tasks from a JSON file")
+    parser.add_argument("json_file", help="Path to the JSON file containing tasks")
+    parser.add_argument(
+        "--project-key",
+        "-p",
+        help="Optional project key to associate with the tasks",
+        default=None,
+    )
+    parser.add_argument(
+        "--yes",
+        "-y",
+        action="store_true",
+        help="Skip confirmation prompt and import automatically",
+    )
+    parser.add_argument(
+        "--skip-sanity-check",
+        action="store_true",
+        help="Skip the verifier sanity check (not recommended)",
+    )
+
+    args = parser.parse_args()
+
+    # Load and parse the 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)
+
+    # Extract task information and validate verifier_func
+    task_count = len(tasks_data)
+    task_keys = []
+    missing_verifier = []
+    for task_data in tasks_data:
+        task_key = task_data.get("key") or task_data.get("id")
+        if task_key:
+            task_keys.append(task_key)
+        else:
+            task_keys.append("(no key)")
+
+        # Check for verifier_func
+        verifier_code = task_data.get("verifier_func") or task_data.get("verifier_code")
+        if not verifier_code:
+            missing_verifier.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:")
+        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")
+        print("\nAll tasks must have a verifier_func to be imported.")
+        sys.exit(1)
+
+    # Get account info
+    account = await fleet.env.account_async()
+
+    # Print summary
+    print(f"Importing to team: {account.team_name}")
+    print(f"\nFound {task_count} task(s) in '{args.json_file}':")
+    print("\nTask keys:")
+    for i, key in enumerate(task_keys, 1):
+        print(f"  {i}. {key}")
+
+    if args.project_key:
+        print(f"\nProject key: {args.project_key}")
+    else:
+        print("\nProject key: (none)")
+
+    # Load tasks as Task objects
+    client = fleet.AsyncFleet()
+    tasks = []
+    print("\nLoading tasks...")
+    for task_data in tasks_data:
+        try:
+            task = await client.load_task_from_json(
+                task_data, raise_on_verifier_error=True
+            )
+            tasks.append(task)
+        except Exception as e:
+            task_key = task_data.get("key") or task_data.get("id", "unknown")
+            print(f"✗ Failed to load task {task_key}: {e}")
+            sys.exit(1)
+    print(f"✓ Loaded {len(tasks)} tasks")
+
+    # Run sanity check (unless skipped)
+    if not args.skip_sanity_check:
+        success, errors = await run_verifier_sanity_check(tasks, client)
+        if not success:
+            sys.exit(1)
+    else:
+        print("\n⚠️  Skipping sanity check (--skip-sanity-check)")
+
+    # Confirmation prompt (unless --yes flag is provided)
+    if not args.yes:
+        print("\n" + "=" * 60)
+        response = input("Type 'YES' to proceed with import: ")
+        if response != "YES":
+            print("Import cancelled.")
+            sys.exit(0)
+
+    # Import tasks
+    print("\nImporting tasks...")
+    try:
+        results = await fleet.import_tasks_async(
+            args.json_file, project_key=args.project_key
+        )
+        print(f"\n✓ Successfully imported {len(results)} task(s)")
+    except Exception as e:
+        print(f"\n✗ Error importing tasks: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{fleet_python-0.2.61 → fleet_python-0.2.63}/fleet/_async/tasks.py

@@ -274,10 +274,18 @@ def verifier_from_string(
     """
     try:
         import inspect
+        import re
         from .verifiers.verifier import AsyncVerifierFunction
         from fleet.verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
         from fleet.verifiers.db import IgnoreConfig
 
+        # Strip @verifier decorator if present to avoid double-wrapping
+        # Remove lines like: @verifier(key="...")
+        cleaned_code = re.sub(r'@verifier\([^)]*\)\s*\n', '', verifier_func)
+        # Also remove the verifier import if present
+        cleaned_code = re.sub(r'from fleet import.*verifier.*\n', '', cleaned_code)
+        cleaned_code = re.sub(r'import.*verifier.*\n', '', cleaned_code)
+
         # Create a local namespace for executing the code
         local_namespace = {
             "TASK_SUCCESSFUL_SCORE": TASK_SUCCESSFUL_SCORE,
@@ -286,13 +294,15 @@ def verifier_from_string(
             "Environment": object,  # Add Environment type if needed
         }
 
-        # Execute the verifier code in the namespace
-        exec(verifier_func, globals(), local_namespace)
+        # Execute the cleaned verifier code in the namespace
+        exec(cleaned_code, globals(), local_namespace)
 
-        # Find the function that was defined
+        # Find the function that was defined (not imported)
+        # Functions defined via exec have co_filename == '<string>'
+        # Imported functions have their actual module file path
         func_obj = None
         for name, obj in local_namespace.items():
-            if inspect.isfunction(obj):
+            if inspect.isfunction(obj) and obj.__code__.co_filename == "<string>":
                 func_obj = obj
                 break
 

{fleet_python-0.2.61 → fleet_python-0.2.63}/fleet/tasks.py

@@ -265,10 +265,18 @@ def verifier_from_string(
     """
     try:
         import inspect
+        import re
         from .verifiers import SyncVerifierFunction
         from .verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
         from .verifiers.db import IgnoreConfig
 
+        # Strip @verifier decorator if present to avoid double-wrapping
+        # Remove lines like: @verifier(key="...")
+        cleaned_code = re.sub(r'@verifier\([^)]*\)\s*\n', '', verifier_func)
+        # Also remove the verifier import if present
+        cleaned_code = re.sub(r'from fleet import.*verifier.*\n', '', cleaned_code)
+        cleaned_code = re.sub(r'import.*verifier.*\n', '', cleaned_code)
+
         # Create a globals namespace with all required imports
         exec_globals = globals().copy()
         exec_globals.update(
@@ -283,13 +291,15 @@ def verifier_from_string(
         # Create a local namespace for executing the code
         local_namespace = {}
 
-        # Execute the verifier code in the namespace
-        exec(verifier_func, exec_globals, local_namespace)
+        # Execute the cleaned verifier code in the namespace
+        exec(cleaned_code, exec_globals, local_namespace)
 
-        # Find the function that was defined
+        # Find the function that was defined (not imported)
+        # Functions defined via exec have co_filename == '<string>'
+        # Imported functions have their actual module file path
         func_obj = None
         for name, obj in local_namespace.items():
-            if inspect.isfunction(obj):
+            if inspect.isfunction(obj) and obj.__code__.co_filename == "<string>":
                 func_obj = obj
                 break
 

{fleet_python-0.2.61 → fleet_python-0.2.63/fleet_python.egg-info}/PKG-INFO

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

{fleet_python-0.2.61 → fleet_python-0.2.63}/fleet_python.egg-info/SOURCES.txt

@@ -78,4 +78,6 @@ fleet_python.egg-info/dependency_links.txt
 fleet_python.egg-info/requires.txt
 fleet_python.egg-info/top_level.txt
 scripts/fix_sync_imports.py
-scripts/unasync.py
+scripts/unasync.py
+tests/__init__.py
+tests/test_verifier_from_string.py

{fleet_python-0.2.61 → fleet_python-0.2.63}/fleet_python.egg-info/top_level.txt

@@ -2,3 +2,4 @@ dist
 examples
 fleet
 scripts
+tests

{fleet_python-0.2.61 → fleet_python-0.2.63}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fleet-python"
-version = "0.2.61"
+version = "0.2.63"
 description = "Python SDK for Fleet environments"
 authors = [
     {name = "Fleet AI", email = "nic@fleet.so"},

fleet_python-0.2.63/tests/__init__.py

@@ -0,0 +1 @@
+"""Tests package for fleet-sdk."""

fleet_python-0.2.63/tests/test_verifier_from_string.py

@@ -0,0 +1,420 @@
+"""Comprehensive tests for verifier_from_string function.
+
+Tests both sync (fleet/tasks.py) and async (fleet/_async/tasks.py) versions.
+"""
+
+import pytest
+from fleet.tasks import verifier_from_string as sync_verifier_from_string
+from fleet._async.tasks import verifier_from_string as async_verifier_from_string
+
+
+class TestSyncVerifierFromString:
+    """Tests for sync version of verifier_from_string."""
+
+    def test_basic_verifier_without_imports(self):
+        """Test basic verifier function without any imports."""
+        code = """
+def my_verifier(env):
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.key == "test-key"
+        assert verifier.func.__name__ == "my_verifier"
+
+    def test_verifier_with_from_fleet_import_verifier(self):
+        """Test the bug case: 'from fleet import verifier' should not be selected."""
+        code = """
+from fleet import verifier
+
+def my_actual_verifier(env):
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        # The function name should be 'my_actual_verifier', not 'verifier'
+        assert verifier.func.__name__ == "my_actual_verifier"
+
+    def test_verifier_with_from_fleet_verifiers_import_verifier(self):
+        """Test bug case: 'from fleet.verifiers import verifier'."""
+        code = """
+from fleet.verifiers import verifier
+
+def check_something(env):
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "check_something"
+
+    def test_verifier_with_from_fleet_verifiers_verifier_import_verifier(self):
+        """Test bug case: 'from fleet.verifiers.verifier import verifier'."""
+        code = """
+from fleet.verifiers.verifier import verifier
+
+def validate_task(env):
+    return 0.5
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "validate_task"
+
+    def test_verifier_with_multiple_imports(self):
+        """Test verifier with multiple import statements."""
+        code = """
+from fleet import verifier
+from fleet.verifiers.db import IgnoreConfig
+import json
+
+def complex_verifier(env):
+    data = json.dumps({"status": "ok"})
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "complex_verifier"
+
+    def test_verifier_with_legitimate_imports(self):
+        """Test verifier with legitimate imports (not fleet-related)."""
+        code = """
+import json
+import os
+
+def my_verifier(env):
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "my_verifier"
+
+    def test_verifier_using_task_scores(self):
+        """Test verifier that uses TASK_SUCCESSFUL_SCORE and TASK_FAILED_SCORE."""
+        code = """
+def my_verifier(env):
+    if True:
+        return TASK_SUCCESSFUL_SCORE
+    return TASK_FAILED_SCORE
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "my_verifier"
+
+    def test_verifier_using_ignore_config(self):
+        """Test verifier that uses IgnoreConfig."""
+        code = """
+def my_verifier(env):
+    config = IgnoreConfig()
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "my_verifier"
+
+    def test_no_function_defined_raises_error(self):
+        """Test that code with no function raises ValueError."""
+        code = """
+x = 1
+y = 2
+"""
+        with pytest.raises(ValueError, match="No function found in verifier code"):
+            sync_verifier_from_string(
+                verifier_func=code,
+                verifier_id="test-verifier",
+                verifier_key="test-key",
+                sha256="test-sha",
+            )
+
+    def test_only_imports_no_function_raises_error(self):
+        """Test that code with only imports and no function raises ValueError."""
+        code = """
+from fleet import verifier
+import json
+"""
+        with pytest.raises(ValueError, match="No function found in verifier code"):
+            sync_verifier_from_string(
+                verifier_func=code,
+                verifier_id="test-verifier",
+                verifier_key="test-key",
+                sha256="test-sha",
+            )
+
+    def test_verifier_with_multiple_functions(self):
+        """Test that first user-defined function is selected when multiple exist."""
+        code = """
+def helper_function():
+    return "helper"
+
+def my_verifier(env):
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        # Should pick the first function (order depends on dict iteration)
+        assert verifier.func.__name__ in ["helper_function", "my_verifier"]
+
+    def test_verifier_with_decorator_usage(self):
+        """Test verifier that would use @verifier decorator in normal usage."""
+        code = """
+from fleet.verifiers.verifier import verifier
+
+def actual_verifier_function(env, project_key: str = "TEST"):
+    # This is the function that should be selected
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "actual_verifier_function"
+
+    def test_verifier_metadata_stored_correctly(self):
+        """Test that verifier metadata is stored correctly."""
+        code = """
+def my_verifier(env):
+    return 1.0
+"""
+        sha256_val = "abcd1234"
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier-id",
+            verifier_key="test-key",
+            sha256=sha256_val,
+        )
+        assert verifier.key == "test-key"
+        assert verifier.verifier_id == "test-verifier-id"
+        assert verifier._sha256 == sha256_val
+        assert verifier._verifier_code == code
+
+
+class TestAsyncVerifierFromString:
+    """Tests for async version of verifier_from_string."""
+
+    def test_basic_async_verifier_without_imports(self):
+        """Test basic async verifier function without any imports."""
+        code = """
+async def my_async_verifier(env):
+    return 1.0
+"""
+        verifier = async_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+
+    def test_async_verifier_with_from_fleet_import_verifier(self):
+        """Test async bug case: 'from fleet import verifier'."""
+        code = """
+from fleet import verifier
+
+async def my_actual_async_verifier(env):
+    return 1.0
+"""
+        verifier = async_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "my_actual_async_verifier"
+
+    def test_async_verifier_with_multiple_imports(self):
+        """Test async verifier with multiple import statements."""
+        code = """
+from fleet import verifier
+from fleet.verifiers.db import IgnoreConfig
+import asyncio
+
+async def complex_async_verifier(env):
+    await asyncio.sleep(0)
+    return 1.0
+"""
+        verifier = async_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "complex_async_verifier"
+
+    def test_sync_function_in_async_module(self):
+        """Test that sync functions also work in async module."""
+        code = """
+from fleet import verifier
+
+def sync_verifier_in_async_module(env):
+    return 1.0
+"""
+        verifier = async_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier is not None
+        assert verifier.func.__name__ == "sync_verifier_in_async_module"
+
+    def test_async_no_function_defined_raises_error(self):
+        """Test that async code with no function raises ValueError."""
+        code = """
+x = 1
+y = 2
+"""
+        with pytest.raises(ValueError, match="No function found in verifier code"):
+            async_verifier_from_string(
+                verifier_func=code,
+                verifier_id="test-verifier",
+                verifier_key="test-key",
+                sha256="test-sha",
+            )
+
+    def test_async_only_imports_raises_error(self):
+        """Test that async code with only imports raises ValueError."""
+        code = """
+from fleet import verifier
+import asyncio
+"""
+        with pytest.raises(ValueError, match="No function found in verifier code"):
+            async_verifier_from_string(
+                verifier_func=code,
+                verifier_id="test-verifier",
+                verifier_key="test-key",
+                sha256="test-sha",
+            )
+
+
+class TestRealWorldScenarios:
+    """Test real-world scenarios from the bug report."""
+
+    def test_original_bug_report_scenario(self):
+        """Test the exact scenario from the bug report."""
+        code = """from fleet import verifier
+def blahblah():
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        # Should select 'blahblah', not the imported 'verifier'
+        assert verifier.func.__name__ == "blahblah"
+
+    def test_example_verifier_pattern(self):
+        """Test a pattern similar to example_verifier.py."""
+        code = """import fleet
+from fleet.verifiers.verifier import verifier
+from fleet.verifiers.db import IgnoreConfig
+
+
+def validate_finish_blue_green_deployment(
+    env, final_answer: str = None
+) -> int:
+    '''Validate that DEBT-722 and DEBT-720 are marked as Done'''
+    return 1.0
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier.func.__name__ == "validate_finish_blue_green_deployment"
+
+    def test_example_task_pattern_sync(self):
+        """Test a pattern similar to example_task.py sync verifier."""
+        code = """from fleet.verifiers.verifier import verifier
+from fleet.verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
+
+
+def create_bug_issue_sync(
+    env, project_key: str = "SCRUM", issue_title: str = "Sample Bug"
+) -> float:
+    '''Synchronous verifier for remote execution.'''
+    try:
+        return TASK_SUCCESSFUL_SCORE
+    except Exception as e:
+        return TASK_FAILED_SCORE
+"""
+        verifier = sync_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier.func.__name__ == "create_bug_issue_sync"
+
+    def test_example_task_pattern_async(self):
+        """Test a pattern similar to example_task.py async verifier."""
+        code = """from fleet.verifiers.verifier import verifier
+from fleet.verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
+
+
+async def create_bug_issue_async(
+    env, project_key: str = "SCRUM", issue_title: str = "Sample Bug"
+) -> float:
+    '''Async verifier for local execution with async environments.'''
+    try:
+        return TASK_SUCCESSFUL_SCORE
+    except Exception as e:
+        return TASK_FAILED_SCORE
+"""
+        verifier = async_verifier_from_string(
+            verifier_func=code,
+            verifier_id="test-verifier",
+            verifier_key="test-key",
+            sha256="test-sha",
+        )
+        assert verifier.func.__name__ == "create_bug_issue_async"

fleet_python-0.2.61/examples/import_tasks.py

@@ -1,102 +0,0 @@
-import asyncio
-import argparse
-import json
-import sys
-import fleet
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-async def main():
-    parser = argparse.ArgumentParser(description="Import tasks from a JSON file")
-    parser.add_argument("json_file", help="Path to the JSON file containing tasks")
-    parser.add_argument(
-        "--project-key",
-        "-p",
-        help="Optional project key to associate with the tasks",
-        default=None,
-    )
-    parser.add_argument(
-        "--yes",
-        "-y",
-        action="store_true",
-        help="Skip confirmation prompt and import automatically",
-    )
-
-    args = parser.parse_args()
-
-    # Load and parse the 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)
-
-    # Extract task information and validate verifier_func
-    task_count = len(tasks_data)
-    task_keys = []
-    missing_verifier = []
-    for task_data in tasks_data:
-        task_key = task_data.get("key") or task_data.get("id")
-        if task_key:
-            task_keys.append(task_key)
-        else:
-            task_keys.append("(no key)")
-        
-        # Check for verifier_func
-        verifier_code = task_data.get("verifier_func") or task_data.get("verifier_code")
-        if not verifier_code:
-            missing_verifier.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:")
-        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")
-        print("\nAll tasks must have a verifier_func to be imported.")
-        sys.exit(1)
-
-    # Get account info
-    account = await fleet.env.account_async()
-
-    # Print summary
-    print(f"Importing to team: {account.team_name}")
-    print(f"\nFound {task_count} task(s) in '{args.json_file}':")
-    print("\nTask keys:")
-    for i, key in enumerate(task_keys, 1):
-        print(f"  {i}. {key}")
-
-    if args.project_key:
-        print(f"\nProject key: {args.project_key}")
-    else:
-        print("\nProject key: (none)")
-
-    # Confirmation prompt (unless --yes flag is provided)
-    if not args.yes:
-        print("\n" + "=" * 60)
-        response = input("Type 'YES' to proceed with import: ")
-        if response != "YES":
-            print("Import cancelled.")
-            sys.exit(0)
-
-    # Import tasks
-    print("\nImporting tasks...")
-    try:
-        results = await fleet.import_tasks_async(
-            args.json_file, project_key=args.project_key
-        )
-        print(f"\n✓ Successfully imported {len(results)} task(s)")
-    except Exception as e:
-        print(f"\n✗ Error importing tasks: {e}")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())