fleet-python 0.2.46__tar.gz → 0.2.47__tar.gz

{fleet_python-0.2.46 → fleet_python-0.2.47}/PKG-INFO

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

{fleet_python-0.2.46 → fleet_python-0.2.47}/fleet/_async/models.py

@@ -273,6 +273,12 @@ class VerifiersExecuteResponse(BaseModel):
     result: Optional[Any] = Field(
         None, description="The return value of the function", title="Result"
     )
+    verifier_id: Optional[str] = Field(
+        None, description="ID of the verifier", title="Verifier Id"
+    )
+    execution_id: Optional[str] = Field(
+        None, description="ID of the execution record", title="Execution Id"
+    )
     error: Optional[Dict[str, Any]] = Field(
         None, description="Error details if verification failed", title="Error"
     )

{fleet_python-0.2.46 → fleet_python-0.2.47}/fleet/_async/tasks.py

@@ -3,13 +3,16 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Any, Dict, Optional, List
+from typing import Any, Dict, Optional, List, TYPE_CHECKING
 
 from pydantic import BaseModel, Field, validator
 
 # Import the shared VerifierFunction type that works for both async and sync
 from fleet.types import VerifierFunction
 
+if TYPE_CHECKING:
+    from fleet._async.models import VerifiersExecuteResponse
+
 
 class Task(BaseModel):
     """A task model representing a single task in the Fleet system."""
@@ -24,9 +27,9 @@ class Task(BaseModel):
     version: Optional[str] = Field(None, description="Task version")
     verifier_func: Optional[str] = Field(None, description="Verifier function code")
     verifier: Optional[Any] = Field(
-        None, 
+        None,
         description="Verifier function with decorator (async or sync)",
-        exclude=True  # Exclude from JSON serialization
+        exclude=True,  # Exclude from JSON serialization
     )
     verifier_id: Optional[str] = Field(None, description="Verifier identifier")
     verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
@@ -68,7 +71,7 @@ class Task(BaseModel):
         # If verifier doesn't exist but verifier_func does, rebuild it
         if not self.verifier and self.verifier_func:
             self._rebuild_verifier()
-            
+
         if self.verifier:
             import asyncio
             import inspect
@@ -102,7 +105,7 @@ class Task(BaseModel):
         # If verifier doesn't exist but verifier_func does, rebuild it
         if not self.verifier and self.verifier_func:
             self._rebuild_verifier()
-            
+
         if self.verifier:
             result = self.verifier.remote(*args, **kwargs)
             # If it's a coroutine, await it
@@ -115,6 +118,65 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
+    async def verify_detailed_async(
+        self, *args, **kwargs
+    ) -> "VerifiersExecuteResponse":
+        """Verify the task and return the full execute response model.
+
+        For async environments, awaits the async verifier.
+        Works with both sync and async verifiers in async contexts.
+        """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
+        if self.verifier:
+            result = self.verifier.remote_with_response(*args, **kwargs)
+            # If it's a coroutine, await it
+            import inspect
+
+            if inspect.iscoroutine(result):
+                return await result
+            else:
+                return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
+    def verify_detailed(self, env, *args, **kwargs) -> "VerifiersExecuteResponse":
+        """Verify the task and return the full execute response model (sync version).
+
+        For sync environments, calls the sync verifier directly.
+        For async verifiers, automatically runs them with asyncio.run().
+        """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
+        if self.verifier:
+            import asyncio
+            import inspect
+
+            # Check if verifier has remote_with_response method (for decorated verifiers)
+            result = self.verifier.remote_with_response(env, *args, **kwargs)
+
+            # If the result is a coroutine, we need to run it
+            if inspect.iscoroutine(result):
+                # Check if we're already in an event loop
+                try:
+                    asyncio.get_running_loop()
+                    # We're in an async context, can't use asyncio.run()
+                    raise RuntimeError(
+                        "Cannot run async verifier in sync mode while event loop is running. "
+                        "Use await task.verify_detailed_async() instead."
+                    )
+                except RuntimeError:
+                    # No event loop running, safe to use asyncio.run()
+                    return asyncio.run(result)
+            else:
+                return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
     def _rebuild_verifier(self):
         """Rebuild the verifier from verifier_func string if it exists."""
         if self.verifier_func:
@@ -127,7 +189,7 @@ class Task(BaseModel):
                 sha256=self.verifier_sha or "",
             )
             self.verifier = verifier
-    
+
     async def make_env(self, region: Optional[str] = None):
         """Create an environment instance for this task's environment.
 

{fleet_python-0.2.46 → fleet_python-0.2.47}/fleet/_async/verifiers/verifier.py

@@ -16,6 +16,7 @@ from typing import Any, Callable, Dict, Optional, List, TypeVar, Tuple
 
 from .bundler import FunctionBundler
 from ..client import AsyncEnv
+from ...models import VerifiersExecuteResponse
 
 logger = logging.getLogger(__name__)
 
@@ -152,72 +153,15 @@ class AsyncVerifierFunction:
 
     async def remote(self, env: AsyncEnv, *args, **kwargs) -> float:
         """Remote execution of the verifier function with SHA-based bundle caching."""
-        # Async verifiers are now supported by the backend
-        # if self._is_async:
-        #     raise NotImplementedError(
-        #         f"Async verifier '{self.key}' cannot be executed remotely. "
-        #         "The remote execution environment only supports synchronous functions. "
-        #         "Please provide a synchronous version of your verifier."
-        #     )
+        response = await self.remote_with_response(env, *args, **kwargs)
 
-        args_array = list(args)
-        args_array.append({"env": env.instance_id})
-        args = tuple(args_array)
-
-        try:
-            # Check if bundle needs to be uploaded
-            bundle_sha, needs_upload = await self._check_bundle_status(env)
-
-            if needs_upload:
-                # Need to upload bundle to S3
-                logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
-                bundle_data, _ = self._get_or_create_bundle()
-
-                response = await env.execute_verifier_remote(
-                    bundle_data=bundle_data,
-                    bundle_sha=bundle_sha,
-                    key=self.key,
-                    function_name=self.func.__name__,
-                    args=args,
-                    args_array=args_array,
-                    kwargs=kwargs,
-                    needs_upload=True,
-                )
-
-                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
-
-            else:
-                # Bundle already available - execute without upload
-                logger.info(
-                    f"Executing cached bundle {bundle_sha[:8]}... for {self.key}"
-                )
-                bundle_data, _ = self._get_or_create_bundle()
-
-                response = await env.execute_verifier_remote(
-                    bundle_data=bundle_data or b"",  # Empty if using server-side bundle
-                    bundle_sha=bundle_sha,
-                    key=self.key,
-                    function_name=self.func.__name__,
-                    args=args,
-                    args_array=args_array,
-                    kwargs=kwargs,
-                    needs_upload=False,  # Don't upload, just execute
-                )
-
-            # Handle response
-            if response.stdout:
-                print(response.stdout)
-            if response.success:
-                return self._process_result(response.result)
-            else:
-                self._raise_remote_error(response.error)
-
-        except Exception as e:
-            logger.error(f"Remote execution failed for {self.key}: {e}")
-            # If it's an HTTP error, try to get more details
-            if hasattr(e, "response") and hasattr(e.response, "text"):
-                logger.error(f"Server response: {e.response.text}")
-            raise
+        # Handle response
+        if response.stdout:
+            print(response.stdout)
+        if response.success:
+            return self._process_result(response.result)
+        else:
+            self._raise_remote_error(response.error)
 
     def _process_result(self, result: Any) -> float:
         """Process remote execution result, handling different return types."""
@@ -257,7 +201,7 @@ Remote traceback:
         try:
             exception_class = getattr(__builtins__, error_type, RuntimeError)
             raise exception_class(full_message)
-        except:
+        except Exception:
             raise RuntimeError(full_message)
 
     def _get_env_id(self, env: AsyncEnv) -> str:
@@ -280,6 +224,74 @@ Remote traceback:
             or "not found" in error_msg
         )
 
+    async def remote_with_response(
+        self, env: "AsyncEnv", *args, **kwargs
+    ) -> "VerifiersExecuteResponse":
+        """Remote execution of the verifier function that returns the full response model."""
+        args_array = list(args)
+        args_array.append({"env": env.instance_id})
+        args = tuple(args_array)
+
+        try:
+            # Check if bundle needs to be uploaded
+            bundle_sha, needs_upload = await self._check_bundle_status(env)
+
+            if needs_upload:
+                # Need to upload bundle to S3
+                logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
+                bundle_data, _ = self._get_or_create_bundle()
+
+                response = await env.execute_verifier_remote(
+                    bundle_data=bundle_data,
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=True,
+                )
+
+                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
+
+            else:
+                # Bundle already available - execute without upload
+                logger.info(f"Bundle {bundle_sha[:8]}... already cached for {self.key}")
+                response = await env.execute_verifier_remote(
+                    bundle_data=b"",  # Empty bundle since it's cached
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=False,
+                )
+
+            return response
+
+        except Exception as e:
+            # Check if error indicates bundle not found and retry with upload
+            if self._is_bundle_not_found_error(e) and not needs_upload:
+                logger.info(
+                    f"Bundle {bundle_sha[:8]}... not found on server, uploading..."
+                )
+                bundle_data, _ = self._get_or_create_bundle()
+                response = await env.execute_verifier_remote(
+                    bundle_data=bundle_data,
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=True,
+                )
+                return response
+            else:
+                logger.error(f"Error in remote execution of {self.key}: {e}")
+                raise
+
 
 def verifier(
     key: Optional[str] = None,

{fleet_python-0.2.46 → fleet_python-0.2.47}/fleet/models.py

@@ -275,6 +275,12 @@ class VerifiersExecuteResponse(BaseModel):
     result: Optional[Any] = Field(
         None, description="The return value of the function", title="Result"
     )
+    verifier_id: Optional[str] = Field(
+        None, description="ID of the verifier", title="Verifier Id"
+    )
+    execution_id: Optional[str] = Field(
+        None, description="ID of the execution record", title="Execution Id"
+    )
     error: Optional[Dict[str, Any]] = Field(
         None, description="Error details if verification failed", title="Error"
     )

{fleet_python-0.2.46 → fleet_python-0.2.47}/fleet/tasks.py

@@ -4,13 +4,16 @@ from __future__ import annotations
 
 import asyncio
 from datetime import datetime
-from typing import Any, Dict, Optional, List
+from typing import Any, Dict, Optional, List, TYPE_CHECKING
 
 from pydantic import BaseModel, Field, validator
 
 # Import the shared VerifierFunction type that works for both async and sync
 from fleet.types import VerifierFunction
 
+if TYPE_CHECKING:
+    from fleet.models import VerifiersExecuteResponse
+
 
 class Task(BaseModel):
     """A task model representing a single task in the Fleet system."""
@@ -116,6 +119,57 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
+    def verify_detailed(self, env, *args, **kwargs) -> "VerifiersExecuteResponse":
+        """Verify the task and return the full execute response model.
+
+        For sync environments, calls the sync verifier directly.
+        For async verifiers, automatically runs them with asyncio.run().
+        """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
+        if self.verifier:
+            import inspect
+
+            # Check if verifier has remote_with_response method (for decorated verifiers)
+            result = self.verifier.remote_with_response(env, *args, **kwargs)
+
+            # If the result is a coroutine, we need to run it
+            if inspect.iscoroutine(result):
+                # Check if we're already in an event loop
+                try:
+                    asyncio.get_running_loop()
+                    # We're in an async context, can't use asyncio.run()
+                    raise RuntimeError(
+                        "Cannot run async verifier in sync mode while event loop is running. "
+                        "Use await task.verify_detailed_async() instead."
+                    )
+                except RuntimeError:
+                    # No event loop running, safe to use asyncio.run()
+                    return asyncio.run(result)
+            else:
+                return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
+    def verify_detailed_async(self, *args, **kwargs) -> "VerifiersExecuteResponse":
+        """Verify the task and return the full execute response model (async version).
+
+        For async environments, returns a coroutine that when awaited returns the response.
+        Works with both sync and async verifiers in async contexts.
+        """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
+        if self.verifier:
+            result = self.verifier.remote_with_response(*args, **kwargs)
+            # Return the result (could be a coroutine or a value)
+            return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
     def _rebuild_verifier(self):
         """Rebuild the verifier from verifier_func string if it exists."""
         if self.verifier_func:

{fleet_python-0.2.46 → fleet_python-0.2.47}/fleet/verifiers/verifier.py

@@ -27,6 +27,7 @@ from .bundler import FunctionBundler
 
 if TYPE_CHECKING:
     from ..client import SyncEnv
+    from ..models import VerifiersExecuteResponse
 
 logger = logging.getLogger(__name__)
 
@@ -163,72 +164,15 @@ class SyncVerifierFunction:
 
     def remote(self, env: "SyncEnv", *args, **kwargs) -> float:
         """Remote execution of the verifier function with SHA-based bundle caching."""
-        # Async verifiers are now supported by the backend
-        # if self._is_async:
-        #     raise NotImplementedError(
-        #         f"Async verifier '{self.key}' cannot be executed remotely. "
-        #         "The remote execution environment only supports synchronous functions. "
-        #         "Please provide a synchronous version of your verifier."
-        #     )
+        response = self.remote_with_response(env, *args, **kwargs)
 
-        args_array = list(args)
-        args_array.append({"env": env.instance_id})
-        args = tuple(args_array)
-
-        try:
-            # Check if bundle needs to be uploaded
-            bundle_sha, needs_upload = self._check_bundle_status(env)
-
-            if needs_upload:
-                # Need to upload bundle to S3
-                logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
-                bundle_data, _ = self._get_or_create_bundle()
-
-                response = env.execute_verifier_remote(
-                    bundle_data=bundle_data,
-                    bundle_sha=bundle_sha,
-                    key=self.key,
-                    function_name=self.func.__name__,
-                    args=args,
-                    args_array=args_array,
-                    kwargs=kwargs,
-                    needs_upload=True,
-                )
-
-                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
-
-            else:
-                # Bundle already available - execute without upload
-                logger.info(
-                    f"Executing cached bundle {bundle_sha[:8]}... for {self.key}"
-                )
-                bundle_data, _ = self._get_or_create_bundle()
-
-                response = env.execute_verifier_remote(
-                    bundle_data=bundle_data or b"",  # Empty if using server-side bundle
-                    bundle_sha=bundle_sha,
-                    key=self.key,
-                    function_name=self.func.__name__,
-                    args=args,
-                    args_array=args_array,
-                    kwargs=kwargs,
-                    needs_upload=False,  # Don't upload, just execute
-                )
-
-            # Handle response
-            if response.stdout:
-                print(response.stdout)
-            if response.success:
-                return self._process_result(response.result)
-            else:
-                self._raise_remote_error(response.error)
-
-        except Exception as e:
-            logger.error(f"Remote execution failed for {self.key}: {e}")
-            # If it's an HTTP error, try to get more details
-            if hasattr(e, "response") and hasattr(e.response, "text"):
-                logger.error(f"Server response: {e.response.text}")
-            raise
+        # Handle response
+        if response.stdout:
+            print(response.stdout)
+        if response.success:
+            return self._process_result(response.result)
+        else:
+            self._raise_remote_error(response.error)
 
     def _process_result(self, result: Any) -> float:
         """Process remote execution result, handling different return types."""
@@ -268,7 +212,7 @@ Remote traceback:
         try:
             exception_class = getattr(__builtins__, error_type, RuntimeError)
             raise exception_class(full_message)
-        except:
+        except Exception:
             raise RuntimeError(full_message)
 
     def _get_env_id(self, env: "SyncEnv") -> str:
@@ -291,6 +235,74 @@ Remote traceback:
             or "not found" in error_msg
         )
 
+    def remote_with_response(
+        self, env: "SyncEnv", *args, **kwargs
+    ) -> "VerifiersExecuteResponse":
+        """Remote execution of the verifier function that returns the full response model."""
+        args_array = list(args)
+        args_array.append({"env": env.instance_id})
+        args = tuple(args_array)
+
+        try:
+            # Check if bundle needs to be uploaded
+            bundle_sha, needs_upload = self._check_bundle_status(env)
+
+            if needs_upload:
+                # Need to upload bundle to S3
+                logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
+                bundle_data, _ = self._get_or_create_bundle()
+
+                response = env.execute_verifier_remote(
+                    bundle_data=bundle_data,
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=True,
+                )
+
+                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
+                return response
+
+            else:
+                # Bundle already available - execute without upload
+                logger.info(f"Bundle {bundle_sha[:8]}... already cached for {self.key}")
+                response = env.execute_verifier_remote(
+                    bundle_data=b"",  # Empty bundle since it's cached
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=False,
+                )
+                return response
+
+        except Exception as e:
+            # Check if error indicates bundle not found and retry with upload
+            if self._is_bundle_not_found_error(e) and not needs_upload:
+                logger.info(
+                    f"Bundle {bundle_sha[:8]}... not found on server, uploading..."
+                )
+                bundle_data, _ = self._get_or_create_bundle()
+                response = env.execute_verifier_remote(
+                    bundle_data=bundle_data,
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=True,
+                )
+                return response
+            else:
+                logger.error(f"Error in remote execution of {self.key}: {e}")
+                raise
+
 
 def verifier(
     key: Optional[str] = None,

{fleet_python-0.2.46 → fleet_python-0.2.47}/fleet_python.egg-info/PKG-INFO

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

{fleet_python-0.2.46 → fleet_python-0.2.47}/pyproject.toml

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