fleet-python 0.2.46__py3-none-any.whl → 0.2.48__py3-none-any.whl

fleet/_async/client.py

@@ -379,6 +379,7 @@ class AsyncFleet:
         keys: Optional[List[str]] = None,
         version: Optional[str] = None,
         team_id: Optional[str] = None,
+        project_key: Optional[str] = None,
     ) -> List[Task]:
         """Load tasks for the authenticated team, with optional filtering.
 
@@ -398,6 +399,8 @@ class AsyncFleet:
             params["task_keys"] = keys
         if team_id is not None:
             params["team_id"] = team_id
+        if project_key is not None:
+            params["project_key"] = project_key
 
         response = await self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())

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/_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.
 
@@ -214,6 +276,7 @@ async def load_tasks(
     keys: Optional[List[str]] = None,
     version: Optional[str] = None,
     team_id: Optional[str] = None,
+    project_key: Optional[str] = None,
 ) -> List[Task]:
     """Convenience function to load tasks with optional filtering.
 
@@ -233,7 +296,7 @@ async def load_tasks(
 
     client = get_client()
     return await client.load_tasks(
-        env_key=env_key, keys=keys, version=version, team_id=team_id
+        env_key=env_key, keys=keys, version=version, team_id=team_id, project_key=project_key
     )
 
 

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/client.py

@@ -16,7 +16,6 @@
 
 import base64
 import cloudpickle
-import concurrent.futures
 import httpx
 import json
 import logging
@@ -291,7 +290,9 @@ class Fleet:
     def execute_verifier_remote(
         self, bundle_data: bytes, args: tuple, kwargs: dict, timeout: Optional[int] = 30
     ) -> VerifiersExecuteResponse:
-        return _execute_verifier_remote(self.client, bundle_data, args, kwargs, timeout)
+        return _execute_verifier_remote(
+            self.client, bundle_data, args, kwargs, timeout
+        )
 
     def delete(self, instance_id: str) -> InstanceResponse:
         return _delete_instance(self.client, instance_id)
@@ -377,6 +378,7 @@ class Fleet:
         keys: Optional[List[str]] = None,
         version: Optional[str] = None,
         team_id: Optional[str] = None,
+        project_key: Optional[str] = None,
     ) -> List[Task]:
         """Load tasks for the authenticated team, with optional filtering.
 
@@ -396,13 +398,16 @@ class Fleet:
             params["task_keys"] = keys
         if team_id is not None:
             params["team_id"] = team_id
+        if project_key is not None:
+            params["project_key"] = project_key
 
         response = self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
 
-        # Prepare verifier loading tasks
-        verifier_tasks = []
+        # Prepare verifier loading coroutines with concurrency limit
+        verifier_coroutines = []
         task_responses_with_indices = []
+        semaphore = asyncio.Semaphore(100)  # Limit to 10 concurrent operations
 
         for idx, task_response in enumerate(task_list_response.tasks):
             if task_response.verifier:
@@ -413,74 +418,61 @@ class Fleet:
 
                 def create_verifier_with_fallback(tr, emb_code, is_error):
                     """Create verifier with fallback logic."""
-                    if not is_error:
-                        # Try to create from embedded data
-                        try:
-                            return self._create_verifier_from_data(
-                                verifier_id=tr.verifier.verifier_id,
-                                verifier_key=tr.verifier.key,
-                                verifier_code=emb_code,
-                                verifier_sha=tr.verifier.sha256,
-                            )
-                        except Exception as e:
-                            logger.warning(
-                                f"Failed to create verifier {tr.verifier.key}: {e}"
-                            )
-                            return None
-                    else:
-                        # Fallback: try fetching by ID
-                        try:
-                            logger.warning(
-                                f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
-                                f"Attempting to refetch by id {tr.verifier.verifier_id}"
-                            )
-                            return self._load_verifier(tr.verifier.verifier_id)
-                        except Exception as e:
-                            logger.warning(
-                                f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
-                                "Leaving verifier unset."
-                            )
-                            return None
-
-                # Add the task for parallel execution
-                verifier_tasks.append(
-                    (
-                        create_verifier_with_fallback,
-                        task_response,
-                        embedded_code,
-                        is_embedded_error,
+                    with semaphore:  # Acquire semaphore before operation
+                        if not is_error:
+                            # Try to create from embedded data
+                            try:
+                                return self._create_verifier_from_data(
+                                    verifier_id=tr.verifier.verifier_id,
+                                    verifier_key=tr.verifier.key,
+                                    verifier_code=emb_code,
+                                    verifier_sha=tr.verifier.sha256,
+                                )
+                            except Exception as e:
+                                logger.warning(
+                                    f"Failed to create verifier {tr.verifier.key}: {e}"
+                                )
+                                return None
+                        else:
+                            # Fallback: try fetching by ID
+                            try:
+                                logger.warning(
+                                    f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
+                                    f"Attempting to refetch by id {tr.verifier.verifier_id}"
+                                )
+                                return self._load_verifier(
+                                    tr.verifier.verifier_id
+                                )
+                            except Exception as e:
+                                logger.warning(
+                                    f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
+                                    "Leaving verifier unset."
+                                )
+                                return None
+
+                # Add the coroutine for parallel execution
+                verifier_coroutines.append(
+                    create_verifier_with_fallback(
+                        task_response, embedded_code, is_embedded_error
                     )
                 )
                 task_responses_with_indices.append((idx, task_response))
             else:
                 # No verifier needed
-                verifier_tasks.append(None)
+                verifier_coroutines.append(None)
                 task_responses_with_indices.append((idx, task_response))
 
-        # Execute all verifier loading in parallel using ThreadPoolExecutor
-        verifier_results = []
-        if verifier_tasks:
-            with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
-                futures = []
-                for task in verifier_tasks:
-                    if task is not None:
-                        func, tr, emb_code, is_error = task
-                        future = executor.submit(func, tr, emb_code, is_error)
-                        futures.append(future)
-                    else:
-                        futures.append(None)
-
-                # Collect results
-                for future in futures:
-                    if future is None:
-                        verifier_results.append(None)
-                    else:
-                        try:
-                            result = future.result()
-                            verifier_results.append(result)
-                        except Exception as e:
-                            logger.warning(f"Verifier loading failed: {e}")
-                            verifier_results.append(None)
+        # Execute all verifier loading in parallel
+        if verifier_coroutines:
+            verifier_results = asyncio.gather(
+                *[
+                    coro if coro is not None else time.sleep(0)
+                    for coro in verifier_coroutines
+                ],
+                return_exceptions=True,
+            )
+        else:
+            verifier_results = []
 
         # Build tasks with results
         tasks = []
@@ -493,7 +485,11 @@ class Fleet:
 
             if task_response.verifier:
                 # Process verifier result
-                if verifier_result is not None:
+                if isinstance(verifier_result, Exception):
+                    logger.warning(
+                        f"Verifier loading failed for {task_response.key}: {verifier_result}"
+                    )
+                elif verifier_result is not None:
                     verifier = verifier_result
                     embedded_code = task_response.verifier.code or ""
                     is_embedded_error = embedded_code.strip().startswith(
@@ -579,8 +575,6 @@ class Fleet:
             task = Task(**task_data)
             tasks.append(task)
 
-        responses = []
-
         for task in tasks:
             payload = TaskRequest(
                 key=task.key,
@@ -594,13 +588,10 @@ class Fleet:
                 response = self.client.request(
                     "POST", "/v1/tasks", json=payload.model_dump()
                 )
-                responses.append(response)
             except Exception as e:
                 logger.error(f"Failed to import task {task.key}: {e}")
                 continue
 
-        return responses
-
     def account(self) -> AccountResponse:
         """Get account information including instance limits and usage.
 
@@ -647,7 +638,6 @@ class Fleet:
             AsyncVerifierFunction created from the verifier code
         """
         from .tasks import verifier_from_string
-        from .verifiers import SyncVerifierFunction
 
         # Use verifier_from_string to create the verifier
         verifier_func = verifier_from_string(

fleet/instance/client.py

@@ -63,7 +63,9 @@ class InstanceClient:
     def load(self) -> None:
         self._load_resources()
 
-    def reset(self, reset_request: Optional[ResetRequest] = None) -> ResetResponse:
+    def reset(
+        self, reset_request: Optional[ResetRequest] = None
+    ) -> ResetResponse:
         response = self.client.request(
             "POST", "/reset", json=reset_request.model_dump() if reset_request else None
         )

fleet/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="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")
@@ -275,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/resources/sqlite.py

@@ -651,7 +651,9 @@ class SQLiteResource(Resource):
         )
         return DescribeResponse(**response.json())
 
-    def query(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
+    def query(
+        self, query: str, args: Optional[List[Any]] = None
+    ) -> QueryResponse:
         return self._query(query, args, read_only=True)
 
     def exec(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
@@ -693,8 +695,12 @@ class SQLiteResource(Resource):
             AsyncSnapshotDiff: Object containing the differences between the two databases
         """
         # Create snapshots of both databases
-        before_snapshot = self.snapshot(name=f"before_{datetime.utcnow().isoformat()}")
-        after_snapshot = other.snapshot(name=f"after_{datetime.utcnow().isoformat()}")
+        before_snapshot = self.snapshot(
+            name=f"before_{datetime.utcnow().isoformat()}"
+        )
+        after_snapshot = other.snapshot(
+            name=f"after_{datetime.utcnow().isoformat()}"
+        )
 
         # Return the diff between the snapshots
         return before_snapshot.diff(after_snapshot, ignore_config)

fleet/tasks.py

@@ -2,15 +2,17 @@
 
 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._async.models import VerifiersExecuteResponse
+
 
 class Task(BaseModel):
     """A task model representing a single task in the Fleet system."""
@@ -27,7 +29,7 @@ class Task(BaseModel):
     verifier: Optional[Any] = Field(
         None,
         description="Verifier function with decorator (async or sync)",
-        exclude=True,
+        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")
@@ -73,7 +75,6 @@ class Task(BaseModel):
         if self.verifier:
             import inspect
 
-            # Check if verifier has remote method (for decorated verifiers)
             result = self.verifier.remote(env, *args, **kwargs)
 
             # If the result is a coroutine, we need to run it
@@ -116,6 +117,64 @@ class Task(BaseModel):
         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.
+
+        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 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 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:
@@ -158,26 +217,20 @@ def verifier_from_string(
     """
     try:
         import inspect
-        from .verifiers import SyncVerifierFunction
-        from .verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
-        from .verifiers.db import IgnoreConfig
-
-        # Create a globals namespace with all required imports
-        exec_globals = globals().copy()
-        exec_globals.update(
-            {
-                "TASK_SUCCESSFUL_SCORE": TASK_SUCCESSFUL_SCORE,
-                "TASK_FAILED_SCORE": TASK_FAILED_SCORE,
-                "IgnoreConfig": IgnoreConfig,
-                "Environment": object,  # Add Environment type if needed
-            }
-        )
+        from .verifiers.verifier import SyncVerifierFunction
+        from fleet.verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
+        from fleet.verifiers.db import IgnoreConfig
 
         # Create a local namespace for executing the code
-        local_namespace = {}
+        local_namespace = {
+            "TASK_SUCCESSFUL_SCORE": TASK_SUCCESSFUL_SCORE,
+            "TASK_FAILED_SCORE": TASK_FAILED_SCORE,
+            "IgnoreConfig": IgnoreConfig,
+            "Environment": object,  # Add Environment type if needed
+        }
 
         # Execute the verifier code in the namespace
-        exec(verifier_func, exec_globals, local_namespace)
+        exec(verifier_func, globals(), local_namespace)
 
         # Find the function that was defined
         func_obj = None
@@ -189,19 +242,15 @@ def verifier_from_string(
         if func_obj is None:
             raise ValueError("No function found in verifier code")
 
-        # Create an SyncVerifierFunction instance with raw code
+        # Create an AsyncVerifierFunction instance with raw code
         verifier_instance = SyncVerifierFunction(
-            func=func_obj,
-            key=verifier_key,
+            func_obj,
+            verifier_key,
             verifier_id=verifier_id,
             sha256=sha256,
             raw_code=verifier_func,
         )
 
-        # Store additional metadata
-        verifier_instance._verifier_code = verifier_func
-        verifier_instance._sha256 = sha256
-
         return verifier_instance
 
     except Exception as e:
@@ -212,7 +261,7 @@ def load_tasks_from_file(filename: str) -> List[Task]:
     """Load tasks from a JSON file.
 
     Example:
-        tasks = fleet.load_tasks_from_file("my_tasks.json")
+        tasks = await fleet.load_tasks_from_file("my_tasks.json")
     """
     from .global_client import get_client
 
@@ -225,6 +274,7 @@ def load_tasks(
     keys: Optional[List[str]] = None,
     version: Optional[str] = None,
     team_id: Optional[str] = None,
+    project_key: Optional[str] = None,
 ) -> List[Task]:
     """Convenience function to load tasks with optional filtering.
 
@@ -244,7 +294,7 @@ def load_tasks(
 
     client = get_client()
     return client.load_tasks(
-        env_key=env_key, keys=keys, version=version, team_id=team_id
+        env_key=env_key, keys=keys, version=version, team_id=team_id, project_key=project_key
     )
 
 
@@ -262,8 +312,8 @@ def update_task(
         TaskResponse containing the updated task details
 
     Examples:
-        response = fleet.update_task("my-task", prompt="New prompt text")
-        response = fleet.update_task("my-task", verifier_code="def verify(env): return True")
+        response = await fleet.update_task("my-task", prompt="New prompt text")
+        response = await fleet.update_task("my-task", verifier_code="def verify(env): return True")
     """
     from .global_client import get_client
 

fleet/verifiers/parse.py

@@ -67,7 +67,7 @@ def convert_verifier_string(verifier_str: str) -> str:
 
         if not match:
             raise ValueError(
-                "Could not parse verifier function. Expected format: def function_name(env: Environment, final_answer: str | None = None) -> float/int:"
+                "Could not parse verifier function. Expected format: def function_name(env: Environment, final_answer: Optional[str] = None) -> float/int:"
             )
 
     func_name = match.group(1)
@@ -82,7 +82,7 @@ def convert_verifier_string(verifier_str: str) -> str:
 
     # Build the new function
     new_func = f"""def {func_name}(
-    before: DatabaseSnapshot, after: DatabaseSnapshot, transcript: str | None = None
+    before: DatabaseSnapshot, after: DatabaseSnapshot, transcript: Optional[str] = None
 ) -> int:
     class Environment:
         def db(self, name: str) -> DatabaseSnapshot:"""
@@ -128,7 +128,7 @@ def convert_verifier_string(verifier_str: str) -> str:
         def load(self):
             pass
 
-    def verifier(env: Environment, final_answer: str | None = None) -> float:"""
+    def verifier(env: Environment, final_answer: Optional[str] = None) -> float:"""
 
     if docstring:
         new_func += f"\n        {docstring}"

fleet/verifiers/verifier.py

@@ -12,21 +12,11 @@ import uuid
 import logging
 import hashlib
 import inspect
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Optional,
-    List,
-    TypeVar,
-    TYPE_CHECKING,
-    Tuple,
-)
+from typing import Any, Callable, Dict, Optional, List, TypeVar, Tuple
 
 from .bundler import FunctionBundler
-
-if TYPE_CHECKING:
-    from ..client import SyncEnv
+from ..client import SyncEnv
+from ...models import VerifiersExecuteResponse
 
 logger = logging.getLogger(__name__)
 
@@ -108,7 +98,7 @@ class SyncVerifierFunction:
 
         return self._bundle_data, self._bundle_sha
 
-    def _check_bundle_status(self, env: "SyncEnv") -> Tuple[str, bool]:
+    def _check_bundle_status(self, env: SyncEnv) -> Tuple[str, bool]:
         """Check if bundle needs to be uploaded and return (sha, needs_upload)."""
         bundle_data, bundle_sha = self._get_or_create_bundle()
 
@@ -130,7 +120,7 @@ class SyncVerifierFunction:
         logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
         return bundle_sha, True  # Upload needed
 
-    def __call__(self, env: "SyncEnv", *args, **kwargs) -> float:
+    def __call__(self, env: SyncEnv, *args, **kwargs) -> float:
         """Local execution of the verifier function with env as first parameter."""
         try:
             if self._is_async:
@@ -161,74 +151,17 @@ class SyncVerifierFunction:
             # Return error score 0
             return 0.0
 
-    def remote(self, env: "SyncEnv", *args, **kwargs) -> float:
+    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."
-        #     )
-
-        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,
-                )
+        response = self.remote_with_response(env, *args, **kwargs)
 
-                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,10 +201,10 @@ 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:
+    def _get_env_id(self, env: SyncEnv) -> str:
         """Generate a unique identifier for the environment."""
         # Use instance base URL or similar unique identifier
         if hasattr(env, "instance") and hasattr(env.instance, "base_url"):
@@ -291,6 +224,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")
+
+            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.dist-info → fleet_python-0.2.48.dist-info}/METADATA

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

{fleet_python-0.2.46.dist-info → fleet_python-0.2.48.dist-info}/RECORD

@@ -21,20 +21,20 @@ examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
 fleet/__init__.py,sha256=Mkdeh45N47lnSv73Eehj92cGU-AImUitvDWJLFhEp0Y,3844
 fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
-fleet/client.py,sha256=Nk7XQS1-sVMkRWh99ZziHVEQ3ta67901oQd6tNZGi8I,27131
+fleet/client.py,sha256=gpmDMDzP_n6kNhrg3hnza3ccuOz40rs1N1HxLDcWryQ,26913
 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=WAiRXa68aXSVbCqmQMn36n9cSlls6YsicV6BbyoeiYQ,12750
-fleet/tasks.py,sha256=3VKk3g1gXXhy-N9QnDq2eTdNK9rJENn_N6_TKZU-uvY,9634
+fleet/models.py,sha256=GX-sRciZDenW2O7Qx9w_ftOkJyE4ph1-92WMq6lynHE,12856
+fleet/tasks.py,sha256=2idoe2FHMyNWufrL-yEqyj_vQIEJ4iVUParwGER32Xg,11832
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
 fleet/_async/__init__.py,sha256=7C_JaEHoqZ4cddsCmlJ4z-UaU6Kr2CBZSgwx5B6fqnc,6765
 fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
-fleet/_async/client.py,sha256=ub6YGR8tBIEob3z5u8F0x0fktUYiVet87RN8iqJiY2I,27306
+fleet/_async/client.py,sha256=SUJSi25SfhMn3N2qiZ_lfzuY9WQLUR2iKhh2_mnOay4,27433
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
-fleet/_async/models.py,sha256=li5Cii7ASUHCFMFeJIMklyicYczqPez768RxO0Q0F2o,12618
-fleet/_async/tasks.py,sha256=TAS7IkSsS8rTW34blTaEPuWzuBqe8NezLpz1ozjP82M,9416
+fleet/_async/models.py,sha256=GX-sRciZDenW2O7Qx9w_ftOkJyE4ph1-92WMq6lynHE,12856
+fleet/_async/tasks.py,sha256=YyFdZkdDJ0uXKGhk0OhRRI4gSnOnOp3EEHs8_UYjrO4,11970
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=8dS42VvSgdqfuh96l6cyiLZlKElilmfTeRSZ4LZnFuE,1143
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
@@ -47,30 +47,30 @@ fleet/_async/resources/mcp.py,sha256=TLEsLiFhfVfZFs0Fu_uDPm-h4FPdvqgQblYqs-PTHhc
 fleet/_async/resources/sqlite.py,sha256=0B6mI8Ad4-pxITMxlBST5RFcG6kqAqwnHW9PPAcpVLk,26185
 fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
 fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
-fleet/_async/verifiers/verifier.py,sha256=wtbZuiAcz3bGSVaaNDA2EHn50MyDeLEV4BAr_4Eh5U0,13742
+fleet/_async/verifiers/verifier.py,sha256=IiHX028s6ux0kb2FR0Z5zJangl_IDh6cemXsUN2ktUU,14152
 fleet/env/__init__.py,sha256=cS9zCYobM5jypppDMZIQMYd6hOg5f4sgqRXEQ67pckk,676
 fleet/env/client.py,sha256=imF47xJG4JeihcZw4Y-_fXz4XxS-OgIkzUK-TLjpeJY,977
 fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
 fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
-fleet/instance/client.py,sha256=XM_Qmd7pUzC3-dCMTh6orTEsGeWJXbKueBlvcWcSUuI,5897
+fleet/instance/client.py,sha256=_5Up_DuCwTsMxRK1b99MNbtFj3olUWLrojOpUZ6bTr8,5911
 fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/resources/base.py,sha256=AXZzT0_yWHkT497q3yekfr0xsD4cPGMCC6y7C43TIkk,663
 fleet/resources/browser.py,sha256=hRNM0YMsVQUAraZGNi_B-KXxLpuddy4ntoEDFSw7czU,1295
 fleet/resources/mcp.py,sha256=c6O4vVJnXANuHMGMe4IPxgp4zBEbFaGm6_d9e6j8Myc,1695
-fleet/resources/sqlite.py,sha256=MIceexu6NlDJ-M74ravpUnB8HzlsxgZx9nZvD16t0Jo,25757
+fleet/resources/sqlite.py,sha256=IqI00g7OeQ_m8xDSN6brd_0yiwJ4AMVEs2lBLK4rQ5w,25815
 fleet/verifiers/__init__.py,sha256=GntS8qc3xv8mm-cku1t3xjvOll5jcc5FuiVqQgR4Y6Q,458
 fleet/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
 fleet/verifiers/code.py,sha256=A1i_UabZspbyj1awzKVQ_HRxgMO3fU7NbkxYyTrp7So,48
 fleet/verifiers/db.py,sha256=LAh1HambBInH_D9q9E2Z41YNkCOI9JJfpWPFqztjpfQ,27922
 fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,3260
-fleet/verifiers/parse.py,sha256=IaROVGmtmilsHQp2sMoJUJcB7tATLLsoHdF0TTWcoC0,8541
+fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
-fleet/verifiers/verifier.py,sha256=kUripDbJVSAHLvjzetmCXg0CKD6IcRAT0Z4d9VSdEfI,13768
-fleet_python-0.2.46.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet/verifiers/verifier.py,sha256=_NtcaZVseKcl9qwajMBVuF6aEHid9uyblFFvHjaelfQ,14076
+fleet_python-0.2.48.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.46.dist-info/METADATA,sha256=fApokwntmryYETxlzkt51ouH2-raee_qFdmx8brQV0s,3304
-fleet_python-0.2.46.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.46.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.46.dist-info/RECORD,,
+fleet_python-0.2.48.dist-info/METADATA,sha256=BBjvolztXtaP0bGAsNv5i23QzxU1iSU8T3k1bsJTYf0,3304
+fleet_python-0.2.48.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.48.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.48.dist-info/RECORD,,