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

examples/example_mcp_anthropic.py

@@ -15,6 +15,8 @@ async def main():
     print("Created environment:", env.urls.app)
     print("MCP URL:", env.mcp.url)
 
+    asyncio.sleep(5)
+
     async with streamablehttp_client(url=env.mcp.url) as streams:
         async with ClientSession(
             read_stream=streams[0], write_stream=streams[1]

examples/example_tasks.py

@@ -5,26 +5,19 @@ load_dotenv()
 
 
 def main():
-    env = fleet.env.make("fira")
+    account = fleet.env.account()
+    print(account)
 
-    tasks = fleet.load_tasks(env_key="fira")
+    tasks = fleet.load_tasks(team_id="5ca40f9f-9899-4bee-b194-6974138a4f12")
     print(f"Loaded {len(tasks)} tasks")
 
-    for i, task in enumerate(tasks):
-        print(f"\nTask {i + 1}:")
-        print(f"  Key: {task.key}")
-        print(f"  Prompt: {task.prompt[:80]}...")
-        print(f"  Verifier: {task.verifier_func[:80]}...")
-
-        print(f"  Verifier: {task.verifier.key}")
-        print("  Running verifier...")
-        try:
-            score = task.verify(env)
-            print(f"  ✓ Score: {score}")
-        except Exception as e:
-            print(f"  ✗ Error: {type(e).__name__}: {e}")
-
-        print("-" * 60)
+    # Save tasks to JSON file
+    import json
+
+    with open(f"{account.team_id}.json", "w") as f:
+        json.dump([task.model_dump() for task in tasks], f, indent=2)
+
+    print(f"Saved {len(tasks)} tasks to saved_tasks.json")
 
 
 if __name__ == "__main__":

fleet/_async/client.py

@@ -210,6 +210,7 @@ class AsyncFleet:
         data_key: Optional[str] = None,
         region: Optional[str] = None,
         env_variables: Optional[Dict[str, Any]] = None,
+        image_type: Optional[str] = None,
     ) -> AsyncEnv:
         if ":" in env_key:
             env_key_part, env_version = env_key.split(":", 1)
@@ -242,6 +243,7 @@ class AsyncFleet:
             data_version=data_version,
             region=region,
             env_variables=env_variables,
+            image_type=image_type,
             created_from="sdk",
         )
 

fleet/_async/env/client.py

@@ -8,9 +8,14 @@ async def make_async(
     data_key: Optional[str] = None,
     region: Optional[str] = None,
     env_variables: Optional[Dict[str, Any]] = None,
+    image_type: Optional[str] = None,
 ) -> AsyncEnv:
     return await AsyncFleet().make(
-        env_key, data_key=data_key, region=region, env_variables=env_variables
+        env_key,
+        data_key=data_key,
+        region=region,
+        env_variables=env_variables,
+        image_type=image_type,
     )
 
 

fleet/_async/resources/sqlite.py

@@ -111,6 +111,21 @@ class AsyncSnapshotQueryBuilder:
         qb._conditions.append((column, "=", value))
         return qb
 
+    def where(
+        self,
+        conditions: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> "AsyncSnapshotQueryBuilder":
+        qb = self._clone()
+        merged: Dict[str, Any] = {}
+        if conditions:
+            merged.update(conditions)
+        if kwargs:
+            merged.update(kwargs)
+        for column, value in merged.items():
+            qb._conditions.append((column, "=", value))
+        return qb
+
     def limit(self, n: int) -> "AsyncSnapshotQueryBuilder":
         qb = self._clone()
         qb._limit = n
@@ -304,6 +319,15 @@ class AsyncSnapshotDiff:
         self._cached = diff
         return diff
 
+    @property
+    def changes(self) -> Dict[str, Dict[str, Any]]:
+        """Expose cached changes; ensure callers awaited a diff-producing method first."""
+        if self._cached is None:
+            raise RuntimeError(
+                "Diff not collected yet; await an operation like expect_only() first."
+            )
+        return self._cached
+
     async def expect_only(self, allowed_changes: List[Dict[str, Any]]):
         """Ensure only specified changes occurred."""
         diff = await self._collect()
@@ -471,6 +495,21 @@ class AsyncQueryBuilder:
     def eq(self, column: str, value: Any) -> "AsyncQueryBuilder":
         return self._add_condition(column, "=", value)
 
+    def where(
+        self,
+        conditions: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> "AsyncQueryBuilder":
+        qb = self._clone()
+        merged: Dict[str, Any] = {}
+        if conditions:
+            merged.update(conditions)
+        if kwargs:
+            merged.update(kwargs)
+        for column, value in merged.items():
+            qb._conditions.append((column, "=", value))
+        return qb
+
     def neq(self, column: str, value: Any) -> "AsyncQueryBuilder":
         return self._add_condition(column, "!=", value)
 

fleet/_async/tasks.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from datetime import datetime
 from typing import Any, Dict, Optional, List, TYPE_CHECKING
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, validator, field_serializer
 
 # Import the shared VerifierFunction type that works for both async and sync
 from fleet.types import VerifierFunction
@@ -46,6 +46,11 @@ class Task(BaseModel):
         """Set created_at to current time if not provided."""
         return v or datetime.now()
 
+    @field_serializer("created_at")
+    def serialize_created_at(self, dt: Optional[datetime], _info):
+        """Serialize datetime to ISO format string."""
+        return dt.isoformat() if dt else None
+
     @property
     def env_key(self) -> str:
         """Get the environment key combining env_id and version."""
@@ -296,7 +301,11 @@ async def load_tasks(
 
     client = get_client()
     return await client.load_tasks(
-        env_key=env_key, keys=keys, version=version, team_id=team_id, project_key=project_key
+        env_key=env_key,
+        keys=keys,
+        version=version,
+        team_id=team_id,
+        project_key=project_key,
     )
 
 

fleet/client.py

@@ -16,6 +16,7 @@
 
 import base64
 import cloudpickle
+import concurrent.futures
 import httpx
 import json
 import logging
@@ -209,6 +210,7 @@ class Fleet:
         data_key: Optional[str] = None,
         region: Optional[str] = None,
         env_variables: Optional[Dict[str, Any]] = None,
+        image_type: Optional[str] = None,
     ) -> SyncEnv:
         if ":" in env_key:
             env_key_part, env_version = env_key.split(":", 1)
@@ -241,6 +243,7 @@ class Fleet:
             data_version=data_version,
             region=region,
             env_variables=env_variables,
+            image_type=image_type,
             created_from="sdk",
         )
 
@@ -290,9 +293,7 @@ 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)
@@ -404,10 +405,9 @@ class Fleet:
         response = self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
 
-        # Prepare verifier loading coroutines with concurrency limit
-        verifier_coroutines = []
+        # Prepare verifier loading tasks
+        verifier_tasks = []
         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:
@@ -418,61 +418,74 @@ class Fleet:
 
                 def create_verifier_with_fallback(tr, emb_code, is_error):
                     """Create verifier with fallback logic."""
-                    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
+                    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,
                     )
                 )
                 task_responses_with_indices.append((idx, task_response))
             else:
                 # No verifier needed
-                verifier_coroutines.append(None)
+                verifier_tasks.append(None)
                 task_responses_with_indices.append((idx, task_response))
 
-        # 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 = []
+        # 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)
 
         # Build tasks with results
         tasks = []
@@ -485,11 +498,7 @@ class Fleet:
 
             if task_response.verifier:
                 # Process verifier result
-                if isinstance(verifier_result, Exception):
-                    logger.warning(
-                        f"Verifier loading failed for {task_response.key}: {verifier_result}"
-                    )
-                elif verifier_result is not None:
+                if verifier_result is not None:
                     verifier = verifier_result
                     embedded_code = task_response.verifier.code or ""
                     is_embedded_error = embedded_code.strip().startswith(
@@ -575,6 +584,8 @@ class Fleet:
             task = Task(**task_data)
             tasks.append(task)
 
+        responses = []
+
         for task in tasks:
             payload = TaskRequest(
                 key=task.key,
@@ -588,10 +599,13 @@ 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.
 
@@ -638,6 +652,7 @@ 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/env/client.py

@@ -8,9 +8,14 @@ def make(
     data_key: Optional[str] = None,
     region: Optional[str] = None,
     env_variables: Optional[Dict[str, Any]] = None,
+    image_type: Optional[str] = None,
 ) -> SyncEnv:
     return Fleet().make(
-        env_key, data_key=data_key, region=region, env_variables=env_variables
+        env_key,
+        data_key=data_key,
+        region=region,
+        env_variables=env_variables,
+        image_type=image_type,
     )
 
 

fleet/instance/client.py

@@ -63,9 +63,7 @@ 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,7 +55,9 @@ class Instance(BaseModel):
 
 class InstanceRequest(BaseModel):
     env_key: str = Field(..., title="Env Key")
-    version: Optional[str] = Field(None, title="Version")
+    env_version: Optional[str] = Field(None, title="Env Version")
+    data_key: Optional[str] = Field(None, title="Data Key")
+    data_version: Optional[str] = Field(None, title="Data Version")
     region: Optional[str] = Field("us-west-1", title="Region")
     seed: Optional[int] = Field(None, title="Seed")
     timestamp: Optional[int] = Field(None, title="Timestamp")
@@ -65,6 +67,7 @@ class InstanceRequest(BaseModel):
     task_id: Optional[str] = Field(None, title="Task Id")
     force_pull: Optional[bool] = Field(None, title="Force Pull")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    image_type: Optional[str] = Field(None, title="Image Type")
     created_from: Optional[str] = Field(None, title="Created From")
 
 

fleet/resources/sqlite.py

@@ -111,6 +111,21 @@ class SyncSnapshotQueryBuilder:
         qb._conditions.append((column, "=", value))
         return qb
 
+    def where(
+        self,
+        conditions: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> "SyncSnapshotQueryBuilder":
+        qb = self._clone()
+        merged: Dict[str, Any] = {}
+        if conditions:
+            merged.update(conditions)
+        if kwargs:
+            merged.update(kwargs)
+        for column, value in merged.items():
+            qb._conditions.append((column, "=", value))
+        return qb
+
     def limit(self, n: int) -> "SyncSnapshotQueryBuilder":
         qb = self._clone()
         qb._limit = n
@@ -304,6 +319,11 @@ class SyncSnapshotDiff:
         self._cached = diff
         return diff
 
+    @property
+    def changes(self) -> Dict[str, Dict[str, Any]]:
+        """Expose the computed diff so callers can introspect like the legacy API."""
+        return self._collect()
+
     def expect_only(self, allowed_changes: List[Dict[str, Any]]):
         """Ensure only specified changes occurred."""
         diff = self._collect()
@@ -471,6 +491,21 @@ class SyncQueryBuilder:
     def eq(self, column: str, value: Any) -> "SyncQueryBuilder":
         return self._add_condition(column, "=", value)
 
+    def where(
+        self,
+        conditions: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> "SyncQueryBuilder":
+        qb = self._clone()
+        merged: Dict[str, Any] = {}
+        if conditions:
+            merged.update(conditions)
+        if kwargs:
+            merged.update(kwargs)
+        for column, value in merged.items():
+            qb._conditions.append((column, "=", value))
+        return qb
+
     def neq(self, column: str, value: Any) -> "SyncQueryBuilder":
         return self._add_condition(column, "!=", value)
 
@@ -651,9 +686,7 @@ 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:
@@ -695,12 +728,8 @@ 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,16 +2,17 @@
 
 from __future__ import annotations
 
+import asyncio
 from datetime import datetime
 from typing import Any, Dict, Optional, List, TYPE_CHECKING
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, validator, field_serializer
 
 # 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
+    from fleet.models import VerifiersExecuteResponse
 
 
 class Task(BaseModel):
@@ -29,7 +30,7 @@ class Task(BaseModel):
     verifier: Optional[Any] = Field(
         None,
         description="Verifier function with decorator (async or sync)",
-        exclude=True,  # Exclude from JSON serialization
+        exclude=True,
     )
     verifier_id: Optional[str] = Field(None, description="Verifier identifier")
     verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
@@ -46,6 +47,11 @@ class Task(BaseModel):
         """Set created_at to current time if not provided."""
         return v or datetime.now()
 
+    @field_serializer("created_at")
+    def serialize_created_at(self, dt: Optional[datetime], _info):
+        """Serialize datetime to ISO format string."""
+        return dt.isoformat() if dt else None
+
     @property
     def env_key(self) -> str:
         """Get the environment key combining env_id and version."""
@@ -75,6 +81,7 @@ 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
@@ -117,32 +124,8 @@ 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).
+        """Verify the task and return the full execute response model.
 
         For sync environments, calls the sync verifier directly.
         For async verifiers, automatically runs them with asyncio.run().
@@ -175,6 +158,23 @@ 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:
@@ -217,20 +217,26 @@ def verifier_from_string(
     """
     try:
         import inspect
-        from .verifiers.verifier import SyncVerifierFunction
-        from fleet.verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
-        from fleet.verifiers.db import IgnoreConfig
+        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
+            }
+        )
 
         # Create a local namespace for executing the code
-        local_namespace = {
-            "TASK_SUCCESSFUL_SCORE": TASK_SUCCESSFUL_SCORE,
-            "TASK_FAILED_SCORE": TASK_FAILED_SCORE,
-            "IgnoreConfig": IgnoreConfig,
-            "Environment": object,  # Add Environment type if needed
-        }
+        local_namespace = {}
 
         # Execute the verifier code in the namespace
-        exec(verifier_func, globals(), local_namespace)
+        exec(verifier_func, exec_globals, local_namespace)
 
         # Find the function that was defined
         func_obj = None
@@ -242,15 +248,19 @@ def verifier_from_string(
         if func_obj is None:
             raise ValueError("No function found in verifier code")
 
-        # Create an AsyncVerifierFunction instance with raw code
+        # Create an SyncVerifierFunction instance with raw code
         verifier_instance = SyncVerifierFunction(
-            func_obj,
-            verifier_key,
+            func=func_obj,
+            key=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:
@@ -261,7 +271,7 @@ def load_tasks_from_file(filename: str) -> List[Task]:
     """Load tasks from a JSON file.
 
     Example:
-        tasks = await fleet.load_tasks_from_file("my_tasks.json")
+        tasks = fleet.load_tasks_from_file("my_tasks.json")
     """
     from .global_client import get_client
 
@@ -294,7 +304,11 @@ def load_tasks(
 
     client = get_client()
     return client.load_tasks(
-        env_key=env_key, keys=keys, version=version, team_id=team_id, project_key=project_key
+        env_key=env_key,
+        keys=keys,
+        version=version,
+        team_id=team_id,
+        project_key=project_key,
     )
 
 
@@ -312,8 +326,8 @@ def update_task(
         TaskResponse containing the updated task details
 
     Examples:
-        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")
+        response = fleet.update_task("my-task", prompt="New prompt text")
+        response = fleet.update_task("my-task", verifier_code="def verify(env): return True")
     """
     from .global_client import get_client
 

fleet/verifiers/verifier.py

@@ -12,11 +12,22 @@ import uuid
 import logging
 import hashlib
 import inspect
-from typing import Any, Callable, Dict, Optional, List, TypeVar, Tuple
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Optional,
+    List,
+    TypeVar,
+    TYPE_CHECKING,
+    Tuple,
+)
 
 from .bundler import FunctionBundler
-from ..client import SyncEnv
-from ...models import VerifiersExecuteResponse
+
+if TYPE_CHECKING:
+    from ..client import SyncEnv
+    from ..models import VerifiersExecuteResponse
 
 logger = logging.getLogger(__name__)
 
@@ -98,7 +109,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()
 
@@ -120,7 +131,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:
@@ -151,7 +162,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)
 
@@ -204,7 +215,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"):
@@ -253,6 +264,7 @@ Remote traceback:
                 )
 
                 logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
+                return response
 
             else:
                 # Bundle already available - execute without upload
@@ -267,8 +279,7 @@ 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.48.dist-info → fleet_python-0.2.50.dist-info}/METADATA

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

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

@@ -5,11 +5,11 @@ examples/exampleResume.py,sha256=hzdL9QfYtwlje5geWS2cgWgjcnLX4UtXSAd-92F66Lw,704
 examples/example_account.py,sha256=t5_Tnr7DcLYfNpEAbuBySQIqsqiQQGySuiItIghCjAM,225
 examples/example_action_log.py,sha256=pwvLro_Fkrw4DII002bHGuWfoZ6QRvUMDD9BnMqJgLQ,622
 examples/example_client.py,sha256=M9Mfi1FcD2LtSDVk89R_-tgG98swvDYy4qx2zVayJ-0,1025
-examples/example_mcp_anthropic.py,sha256=2ouLWAojhdnxhJc6yxkgo8e3TnNjC48yz8zpaPQm3Jw,2597
+examples/example_mcp_anthropic.py,sha256=WzQipN6ryPYuiGcvYmaTget4Hn421ijMS6xDYWwrVyE,2619
 examples/example_mcp_openai.py,sha256=xhqJd2-mnQs4-ZmydGrX7pPs7_X5i-YFqkO1cr3L-5g,480
 examples/example_sync.py,sha256=EkuWmUzB1ZsBJQk6ZRflB793rKsuRHeSg5HJZHVhBB0,975
 examples/example_task.py,sha256=dhG6STAkNsTdHs9cO1RFH9WfuvRmq5bRC211hTeFrk8,7088
-examples/example_tasks.py,sha256=Af57KbxpDxWWAVnjVC6IC0Rbxr_Z6kTEQk-XcDe4vTo,747
+examples/example_tasks.py,sha256=xTL8UWVAuolSX6swskfrAcmDrLIzn45dJ7YPWCwoEBU,514
 examples/example_verifier.py,sha256=0vwNITIG3m4CkSPwIxNXcGx9TqrxEsCGqK2A8keKZMM,2392
 examples/gemini_example.py,sha256=qj9WDazQTYNiRHNeUg9Tjkp33lJMwbx8gDfpFe1sDQo,16180
 examples/json_tasks_example.py,sha256=CYPESGGtOo0fmsDdLidujTfsE4QlJHw7rOhyVqPJ_Ls,5329
@@ -21,22 +21,22 @@ 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=gpmDMDzP_n6kNhrg3hnza3ccuOz40rs1N1HxLDcWryQ,26913
+fleet/client.py,sha256=iRyPUvEsOzP4gksWZ8ETcPQ6arQA2HFBZRLaTps7758,27335
 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=GX-sRciZDenW2O7Qx9w_ftOkJyE4ph1-92WMq6lynHE,12856
-fleet/tasks.py,sha256=2idoe2FHMyNWufrL-yEqyj_vQIEJ4iVUParwGER32Xg,11832
+fleet/models.py,sha256=d9eish0KO3t4VCNu8h8Q_6K1Xj-crYo5Fejtle0Ur28,13056
+fleet/tasks.py,sha256=uR94wq7SG4ymJYLq24F2iYn0el58C2Czb2oK-8rIs8s,12344
 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=SUJSi25SfhMn3N2qiZ_lfzuY9WQLUR2iKhh2_mnOay4,27433
+fleet/_async/client.py,sha256=cFR0CcXmPtKc5HxyDnnsNXRbx-ICwegHPRbUvVQ95CE,27510
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
 fleet/_async/models.py,sha256=GX-sRciZDenW2O7Qx9w_ftOkJyE4ph1-92WMq6lynHE,12856
-fleet/_async/tasks.py,sha256=YyFdZkdDJ0uXKGhk0OhRRI4gSnOnOp3EEHs8_UYjrO4,11970
+fleet/_async/tasks.py,sha256=hrtvKlqepQOFnlJv6h5S06UWNWtn2hQlgSp3eYj5m30,12226
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=8dS42VvSgdqfuh96l6cyiLZlKElilmfTeRSZ4LZnFuE,1143
+fleet/_async/env/client.py,sha256=C5WG5Ir_McXaFPZNdkQjj0w4V7xMIcw3QyVP5g-3kVk,1237
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
 fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
 fleet/_async/instance/client.py,sha256=kcrmLZciQxvPSfTtbEq5LIbhscwDHg6WIiNcPyM4L9w,6085
@@ -44,21 +44,21 @@ fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 fleet/_async/resources/base.py,sha256=UfrenxUqcpL8SgYGOo8o8HgRvv2-ZO5G2Cdo91ofEdg,664
 fleet/_async/resources/browser.py,sha256=oldoSiymJ1lJkADhpUG81ViOBDNyppX1jSoEwe9-W94,1369
 fleet/_async/resources/mcp.py,sha256=TLEsLiFhfVfZFs0Fu_uDPm-h4FPdvqgQblYqs-PTHhc,1720
-fleet/_async/resources/sqlite.py,sha256=0B6mI8Ad4-pxITMxlBST5RFcG6kqAqwnHW9PPAcpVLk,26185
+fleet/_async/resources/sqlite.py,sha256=up_umepfyX9PDFsnmEMJLjsj7bLa6a3wizZOgMGkK1Q,27409
 fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
 fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
 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/env/client.py,sha256=WD2ONQ7d8qwaTuzE0GaQY-G9Wx1H_nTHIvm7PLZS-bg,1071
 fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
 fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
-fleet/instance/client.py,sha256=_5Up_DuCwTsMxRK1b99MNbtFj3olUWLrojOpUZ6bTr8,5911
+fleet/instance/client.py,sha256=XM_Qmd7pUzC3-dCMTh6orTEsGeWJXbKueBlvcWcSUuI,5897
 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=IqI00g7OeQ_m8xDSN6brd_0yiwJ4AMVEs2lBLK4rQ5w,25815
+fleet/resources/sqlite.py,sha256=bR6d1zYQ4cMAlmZIJ7jqmY9-N-GokXaDhUyGKTWHsfY,26811
 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
@@ -66,11 +66,11 @@ fleet/verifiers/db.py,sha256=LAh1HambBInH_D9q9E2Z41YNkCOI9JJfpWPFqztjpfQ,27922
 fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,3260
 fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
-fleet/verifiers/verifier.py,sha256=_NtcaZVseKcl9qwajMBVuF6aEHid9uyblFFvHjaelfQ,14076
-fleet_python-0.2.48.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet/verifiers/verifier.py,sha256=_lcxXVm8e0xRrK2gNJy9up7pW1zOkPRY5n5lQ85S8jg,14197
+fleet_python-0.2.50.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.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,,
+fleet_python-0.2.50.dist-info/METADATA,sha256=M_PLPe_XZpORLf-usjGttI8DVjdVhBuoVZbYqye52f8,3304
+fleet_python-0.2.50.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.50.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.50.dist-info/RECORD,,