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

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

@@ -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 → fleet_python-0.2.48}/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_python-0.2.46 → fleet_python-0.2.48}/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.48}/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_python-0.2.46 → fleet_python-0.2.48}/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.48}/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_python-0.2.46 → fleet_python-0.2.48}/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_python-0.2.46 → fleet_python-0.2.48}/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_python-0.2.46 → fleet_python-0.2.48}/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)