fleet-python 0.2.60__py3-none-any.whl → 0.2.62__py3-none-any.whl

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/_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/_async/models.py

@@ -154,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):
@@ -180,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/_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/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/models.py

@@ -157,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):
@@ -183,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/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.dist-info → fleet_python-0.2.62.dist-info}/METADATA

@@ -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.dist-info → fleet_python-0.2.62.dist-info}/RECORD

@@ -11,7 +11,7 @@ examples/example_sync.py,sha256=EkuWmUzB1ZsBJQk6ZRflB793rKsuRHeSg5HJZHVhBB0,975
 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=e5CaHga_1IV2W7PGPjQjOZtMrLAhoPNt74V6qRY99EE,2700
+examples/export_tasks.py,sha256=cJ_8xND7Q3IOM1JfJPR-DH3aLfHo_KmKJeO-1IVUFrQ,3237
 examples/gemini_example.py,sha256=qj9WDazQTYNiRHNeUg9Tjkp33lJMwbx8gDfpFe1sDQo,16180
 examples/import_tasks.py,sha256=pb60dOXnOn-G1INQxV1wujeHmmY2oWz9Ddj9SbMm1pk,3139
 examples/json_tasks_example.py,sha256=CYPESGGtOo0fmsDdLidujTfsE4QlJHw7rOhyVqPJ_Ls,5329
@@ -23,20 +23,20 @@ examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
 fleet/__init__.py,sha256=yC4HIcbtPAPOgI0lLri3l8nbXkNee9JOihKAc7SXYkY,4201
 fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
-fleet/client.py,sha256=-bjVlA9Iw7dg9XdHVUMvXpTesxzZ_tfw8eD_1D04SW0,32057
+fleet/client.py,sha256=2zbX2a_cAfrpJMp48nfiIKPFCXE04ahtmogaymibtgg,32499
 fleet/config.py,sha256=uY02ZKxVoXqVDta-0IMWaYJeE1CTXF_fA9NI6QUutmU,319
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
-fleet/models.py,sha256=d9eish0KO3t4VCNu8h8Q_6K1Xj-crYo5Fejtle0Ur28,13056
-fleet/tasks.py,sha256=DlxQu9sftsW0jxKwdIE4_DsVxv1v3t6Mf3iKSwFQM3M,16435
+fleet/models.py,sha256=-8WG10SMkXUljRqD_8pfajCr4PS9qYDVLAZ8RxdJMb0,13392
+fleet/tasks.py,sha256=STR34InS14rMq1DFPsCeAASarsvUqf_ODK_jitT8ORU,16914
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
 fleet/_async/__init__.py,sha256=Wi8Tjj-Lfnxi4cPOkAxh2lynnpEBNni6mI6Iq80uOro,8054
 fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
-fleet/_async/client.py,sha256=DWI0nUpR3eD_onAbmiPvKemcqZ7adqLJTt0qXKBOMn4,32505
+fleet/_async/client.py,sha256=Uu9o8LpUce8vOoFxqG0RDe4VtJpu1BJGIFbVecuO71g,32947
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
-fleet/_async/models.py,sha256=GX-sRciZDenW2O7Qx9w_ftOkJyE4ph1-92WMq6lynHE,12856
-fleet/_async/tasks.py,sha256=VFP00oAeyGvXkVOutLmrvKuM77BGLAc9ZoCH_Z2nXmg,16463
+fleet/_async/models.py,sha256=6x3IPYuWz1v6zWjujqgzK2CpR2HB5Rme4LQFLyvUDXE,13164
+fleet/_async/tasks.py,sha256=LiDDIrmT9mIqlUna-I903n4yVpLxbmxUSv4lPdaBcDE,16942
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=C5WG5Ir_McXaFPZNdkQjj0w4V7xMIcw3QyVP5g-3kVk,1237
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
@@ -69,10 +69,12 @@ fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,
 fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
 fleet/verifiers/verifier.py,sha256=_lcxXVm8e0xRrK2gNJy9up7pW1zOkPRY5n5lQ85S8jg,14197
-fleet_python-0.2.60.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.62.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=X9fWLTpiPGkSHsjyQUDepOJkxOqw1DPj7nd8wFlFqLQ,8368
 scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
-fleet_python-0.2.60.dist-info/METADATA,sha256=V0DNVpqY8l-Q0Gq8xfOPVZGxUbRaYfmeRvU3NBkwnaY,3304
-fleet_python-0.2.60.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.60.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.60.dist-info/RECORD,,
+tests/__init__.py,sha256=Re1SdyxH8NfyL1kjhi7SQkGP1mYeWB-D6UALqdIMd8I,35
+tests/test_verifier_from_string.py,sha256=Lxi3TpFHFb-hG4-UhLKZJkqo84ax9YJY8G6beO-1erM,13581
+fleet_python-0.2.62.dist-info/METADATA,sha256=pkly98qTBJVHA9jkevvz_v3UKZyGa2-_RFVlbVGLlSg,3304
+fleet_python-0.2.62.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.62.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
+fleet_python-0.2.62.dist-info/RECORD,,

{fleet_python-0.2.60.dist-info → fleet_python-0.2.62.dist-info}/top_level.txt

@@ -1,3 +1,4 @@
 examples
 fleet
 scripts
+tests

tests/__init__.py

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

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"