fleet-python 0.2.60__tar.gz → 0.2.62__tar.gz

{fleet_python-0.2.60 → fleet_python-0.2.62}/PKG-INFO

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

{fleet_python-0.2.60 → fleet_python-0.2.62}/examples/export_tasks.py

@@ -21,6 +21,12 @@ def main():
         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(
         "--output",
         "-o",
@@ -31,9 +37,17 @@ def main():
     args = parser.parse_args()
 
     # Validate that only one filter is specified
-    if args.project_key and args.task_keys:
+    filters_specified = sum(
+        [
+            args.project_key is not None,
+            args.task_keys is not None,
+            args.task_project_key is not None,
+        ]
+    )
+
+    if filters_specified > 1:
         parser.error(
-            "Cannot specify both --project-key and --task-keys. Use one or neither."
+            "Cannot specify multiple filters. Use only one of --project-key, --task-keys, or --task-project-key."
         )
 
     # Get account info
@@ -49,6 +63,9 @@ def main():
             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)
     else:
         print("Loading all tasks")
         tasks = fleet.load_tasks()

{fleet_python-0.2.60 → fleet_python-0.2.62}/fleet/_async/client.py

@@ -397,6 +397,7 @@ class AsyncFleet:
             verifier_id=verifier_id,  # Set verifier_id so _rebuild_verifier works
             verifier_sha=verifier_sha,  # Set verifier_sha
             metadata=task_json.get("metadata", {}),  # Default empty metadata
+            output_json_schema=task_json.get("output_json_schema"),  # JSON schema for output
         )
         return task
 
@@ -407,6 +408,7 @@ class AsyncFleet:
         version: Optional[str] = None,
         team_id: Optional[str] = None,
         project_key: Optional[str] = None,
+        task_project_key: Optional[str] = None,
         data_id: Optional[str] = None,
         data_version: Optional[str] = None,
     ) -> List[Task]:
@@ -418,6 +420,7 @@ class AsyncFleet:
             version: Optional version to filter tasks by (client-side filter)
             team_id: Optional team_id to filter by (admin only)
             project_key: Optional project key to filter tasks by
+            task_project_key: Optional task project key to filter tasks by
             data_id: Optional data identifier to filter tasks by
             data_version: Optional data version to filter tasks by
 
@@ -433,6 +436,8 @@ class AsyncFleet:
             params["team_id"] = team_id
         if project_key is not None:
             params["project_key"] = project_key
+        if task_project_key is not None:
+            params["task_project_key"] = task_project_key
         if data_id is not None:
             params["data_id"] = data_id
         if data_version is not None:
@@ -547,6 +552,7 @@ class AsyncFleet:
                 verifier_func=verifier_func,  # Set verifier code
                 verifier=verifier,  # Use created verifier or None
                 metadata={},  # Default empty metadata
+                output_json_schema=getattr(task_response, "output_json_schema", None),  # Get output_json_schema if available
             )
             tasks.append(task)
 

{fleet_python-0.2.60/fleet → fleet_python-0.2.62/fleet/_async}/models.py

@@ -55,9 +55,7 @@ class Instance(BaseModel):
 
 class InstanceRequest(BaseModel):
     env_key: str = Field(..., title="Env Key")
-    env_version: Optional[str] = Field(None, title="Env Version")
-    data_key: Optional[str] = Field(None, title="Data Key")
-    data_version: Optional[str] = Field(None, title="Data Version")
+    version: Optional[str] = Field(None, title="Version")
     region: Optional[str] = Field("us-west-1", title="Region")
     seed: Optional[int] = Field(None, title="Seed")
     timestamp: Optional[int] = Field(None, title="Timestamp")
@@ -67,7 +65,6 @@ class InstanceRequest(BaseModel):
     task_id: Optional[str] = Field(None, title="Task Id")
     force_pull: Optional[bool] = Field(None, title="Force Pull")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
-    image_type: Optional[str] = Field(None, title="Image Type")
     created_from: Optional[str] = Field(None, title="Created From")
 
 
@@ -157,6 +154,7 @@ class TaskRequest(BaseModel):
     verifier_id: Optional[str] = Field(None, title="Verifier Id")
     version: Optional[str] = Field(None, title="Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    output_json_schema: Optional[Dict[str, Any]] = Field(None, title="Output Json Schema")
 
 
 class TaskUpdateRequest(BaseModel):
@@ -183,8 +181,11 @@ class TaskResponse(BaseModel):
     verifier_id: Optional[str] = Field(None, title="Verifier Id")
     verifier_func: Optional[str] = Field(None, title="Verifier Func")
     version: Optional[str] = Field(None, title="Version")
+    data_id: Optional[str] = Field(None, title="Data Id")
+    data_version: Optional[str] = Field(None, title="Data Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
     verifier: Optional[VerifierData] = Field(None, title="Verifier")
+    output_json_schema: Optional[Dict[str, Any]] = Field(None, title="Output Json Schema")
 
 
 class ValidationError(BaseModel):

{fleet_python-0.2.60 → fleet_python-0.2.62}/fleet/_async/tasks.py

@@ -38,6 +38,9 @@ class Task(BaseModel):
     metadata: Optional[Dict[str, Any]] = Field(
         default_factory=dict, description="Additional task metadata"
     )
+    output_json_schema: Optional[Dict[str, Any]] = Field(
+        None, description="JSON schema for expected output format"
+    )
 
     @validator("key")
     def validate_key_format(cls, v):
@@ -286,10 +289,12 @@ def verifier_from_string(
         # Execute the verifier code in the namespace
         exec(verifier_func, 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
 
@@ -329,6 +334,7 @@ async def load_tasks(
     version: Optional[str] = None,
     team_id: Optional[str] = None,
     project_key: Optional[str] = None,
+    task_project_key: Optional[str] = None,
     data_id: Optional[str] = None,
     data_version: Optional[str] = None,
 ) -> List[Task]:
@@ -340,6 +346,7 @@ async def load_tasks(
         version: Optional version to filter tasks by
         team_id: Optional team_id to filter by (admin only)
         project_key: Optional project key to filter tasks by
+        task_project_key: Optional task project key to filter tasks by
         data_id: Optional data identifier to filter tasks by
         data_version: Optional data version to filter tasks by
 
@@ -359,6 +366,7 @@ async def load_tasks(
         version=version,
         team_id=team_id,
         project_key=project_key,
+        task_project_key=task_project_key,
         data_id=data_id,
         data_version=data_version,
     )

{fleet_python-0.2.60 → fleet_python-0.2.62}/fleet/client.py

@@ -395,6 +395,7 @@ class Fleet:
             verifier_id=verifier_id,  # Set verifier_id so _rebuild_verifier works
             verifier_sha=verifier_sha,  # Set verifier_sha
             metadata=task_json.get("metadata", {}),  # Default empty metadata
+            output_json_schema=task_json.get("output_json_schema"),  # JSON schema for output
         )
         return task
 
@@ -405,6 +406,7 @@ class Fleet:
         version: Optional[str] = None,
         team_id: Optional[str] = None,
         project_key: Optional[str] = None,
+        task_project_key: Optional[str] = None,
         data_id: Optional[str] = None,
         data_version: Optional[str] = None,
     ) -> List[Task]:
@@ -416,6 +418,7 @@ class Fleet:
             version: Optional version to filter tasks by (client-side filter)
             team_id: Optional team_id to filter by (admin only)
             project_key: Optional project key to filter tasks by
+            task_project_key: Optional task project key to filter tasks by
             data_id: Optional data identifier to filter tasks by
             data_version: Optional data version to filter tasks by
 
@@ -431,6 +434,8 @@ class Fleet:
             params["team_id"] = team_id
         if project_key is not None:
             params["project_key"] = project_key
+        if task_project_key is not None:
+            params["task_project_key"] = task_project_key
         if data_id is not None:
             params["data_id"] = data_id
         if data_version is not None:
@@ -553,6 +558,7 @@ class Fleet:
                 verifier_func=verifier_func,  # Set verifier code
                 verifier=verifier,  # Use created verifier or None
                 metadata={},  # Default empty metadata
+                output_json_schema=getattr(task_response, "output_json_schema", None),  # Get output_json_schema if available
             )
             tasks.append(task)
 

{fleet_python-0.2.60/fleet/_async → fleet_python-0.2.62/fleet}/models.py

@@ -55,7 +55,9 @@ class Instance(BaseModel):
 
 class InstanceRequest(BaseModel):
     env_key: str = Field(..., title="Env Key")
-    version: Optional[str] = Field(None, title="Version")
+    env_version: Optional[str] = Field(None, title="Env Version")
+    data_key: Optional[str] = Field(None, title="Data Key")
+    data_version: Optional[str] = Field(None, title="Data Version")
     region: Optional[str] = Field("us-west-1", title="Region")
     seed: Optional[int] = Field(None, title="Seed")
     timestamp: Optional[int] = Field(None, title="Timestamp")
@@ -65,6 +67,7 @@ class InstanceRequest(BaseModel):
     task_id: Optional[str] = Field(None, title="Task Id")
     force_pull: Optional[bool] = Field(None, title="Force Pull")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    image_type: Optional[str] = Field(None, title="Image Type")
     created_from: Optional[str] = Field(None, title="Created From")
 
 
@@ -154,6 +157,9 @@ class TaskRequest(BaseModel):
     verifier_id: Optional[str] = Field(None, title="Verifier Id")
     version: Optional[str] = Field(None, title="Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    output_json_schema: Optional[Dict[str, Any]] = Field(
+        None, title="Output Json Schema"
+    )
 
 
 class TaskUpdateRequest(BaseModel):
@@ -180,8 +186,13 @@ class TaskResponse(BaseModel):
     verifier_id: Optional[str] = Field(None, title="Verifier Id")
     verifier_func: Optional[str] = Field(None, title="Verifier Func")
     version: Optional[str] = Field(None, title="Version")
+    data_id: Optional[str] = Field(None, title="Data Id")
+    data_version: Optional[str] = Field(None, title="Data Version")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
     verifier: Optional[VerifierData] = Field(None, title="Verifier")
+    output_json_schema: Optional[Dict[str, Any]] = Field(
+        None, title="Output Json Schema"
+    )
 
 
 class ValidationError(BaseModel):

{fleet_python-0.2.60 → fleet_python-0.2.62}/fleet/tasks.py

@@ -39,6 +39,9 @@ class Task(BaseModel):
     metadata: Optional[Dict[str, Any]] = Field(
         default_factory=dict, description="Additional task metadata"
     )
+    output_json_schema: Optional[Dict[str, Any]] = Field(
+        None, description="JSON schema for expected output format"
+    )
 
     @validator("key")
     def validate_key_format(cls, v):
@@ -283,10 +286,12 @@ def verifier_from_string(
         # Execute the verifier code in the namespace
         exec(verifier_func, 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
 
@@ -330,6 +335,7 @@ def load_tasks(
     version: Optional[str] = None,
     team_id: Optional[str] = None,
     project_key: Optional[str] = None,
+    task_project_key: Optional[str] = None,
     data_id: Optional[str] = None,
     data_version: Optional[str] = None,
 ) -> List[Task]:
@@ -341,6 +347,7 @@ def load_tasks(
         version: Optional version to filter tasks by
         team_id: Optional team_id to filter by (admin only)
         project_key: Optional project key to filter tasks by
+        task_project_key: Optional task project key to filter tasks by
         data_id: Optional data identifier to filter tasks by
         data_version: Optional data version to filter tasks by
 
@@ -360,6 +367,7 @@ def load_tasks(
         version=version,
         team_id=team_id,
         project_key=project_key,
+        task_project_key=task_project_key,
         data_id=data_id,
         data_version=data_version,
     )

{fleet_python-0.2.60 → fleet_python-0.2.62}/fleet_python.egg-info/PKG-INFO

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

{fleet_python-0.2.60 → fleet_python-0.2.62}/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.60 → fleet_python-0.2.62}/fleet_python.egg-info/top_level.txt

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

{fleet_python-0.2.60 → fleet_python-0.2.62}/pyproject.toml

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

fleet_python-0.2.62/tests/__init__.py

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

fleet_python-0.2.62/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"