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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.47
+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.47 → 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.47 → fleet_python-0.2.48}/fleet/_async/tasks.py

@@ -276,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.
 
@@ -295,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.47 → 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.47 → 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.47 → 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")

{fleet_python-0.2.47 → 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)

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

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import asyncio
 from datetime import datetime
 from typing import Any, Dict, Optional, List, TYPE_CHECKING
 
@@ -12,7 +11,7 @@ from pydantic import BaseModel, Field, validator
 from fleet.types import VerifierFunction
 
 if TYPE_CHECKING:
-    from fleet.models import VerifiersExecuteResponse
+    from fleet._async.models import VerifiersExecuteResponse
 
 
 class Task(BaseModel):
@@ -30,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")
@@ -76,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
@@ -119,9 +117,33 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
-    def verify_detailed(self, env, *args, **kwargs) -> "VerifiersExecuteResponse":
+    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().
         """
@@ -153,23 +175,6 @@ 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 (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:
@@ -212,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
@@ -243,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:
@@ -266,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
 
@@ -279,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.
 
@@ -298,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
     )
 
 
@@ -316,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_python-0.2.47 → fleet_python-0.2.48}/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_python-0.2.47 → fleet_python-0.2.48}/fleet/verifiers/verifier.py

@@ -12,22 +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 ..models import VerifiersExecuteResponse
+from ..client import SyncEnv
+from ...models import VerifiersExecuteResponse
 
 logger = logging.getLogger(__name__)
 
@@ -109,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()
 
@@ -131,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:
@@ -162,7 +151,7 @@ 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."""
         response = self.remote_with_response(env, *args, **kwargs)
 
@@ -215,7 +204,7 @@ Remote traceback:
         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"):
@@ -264,7 +253,6 @@ Remote traceback:
                 )
 
                 logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
-                return response
 
             else:
                 # Bundle already available - execute without upload
@@ -279,7 +267,8 @@ Remote traceback:
                     kwargs=kwargs,
                     needs_upload=False,
                 )
-                return response
+
+            return response
 
         except Exception as e:
             # Check if error indicates bundle not found and retry with upload

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.47
+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.47 → fleet_python-0.2.48}/pyproject.toml

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