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

fleet/_async/tasks.py

@@ -289,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
 

fleet/tasks.py

@@ -286,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
 

{fleet_python-0.2.61.dist-info → fleet_python-0.2.62.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.61
+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.61.dist-info → fleet_python-0.2.62.dist-info}/RECORD

@@ -28,7 +28,7 @@ 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=-8WG10SMkXUljRqD_8pfajCr4PS9qYDVLAZ8RxdJMb0,13392
-fleet/tasks.py,sha256=DcdubsXohptHqGAA-vkUyo8O0La50Wbgi2X8kUgcCqE,16724
+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
@@ -36,7 +36,7 @@ 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=6x3IPYuWz1v6zWjujqgzK2CpR2HB5Rme4LQFLyvUDXE,13164
-fleet/_async/tasks.py,sha256=QB6rzQPx6RbavE-BMwMyMMIPpCjapj87tqkrHGTZ8dE,16752
+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.61.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.61.dist-info/METADATA,sha256=P4SV6i9skVoxetYm96_p0hAtq3XFK1eV5e9NpW9WbDM,3304
-fleet_python-0.2.61.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.61.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.61.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.61.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"