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

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

@@ -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 → fleet_python-0.2.50}/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]

fleet_python-0.2.50/examples/example_tasks.py

@@ -0,0 +1,24 @@
+import fleet
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def main():
+    account = fleet.env.account()
+    print(account)
+
+    tasks = fleet.load_tasks(team_id="5ca40f9f-9899-4bee-b194-6974138a4f12")
+    print(f"Loaded {len(tasks)} tasks")
+
+    # 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__":
+    main()

{fleet_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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_python-0.2.48 → fleet_python-0.2.50}/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 → fleet_python-0.2.50}/fleet_python.egg-info/PKG-INFO

@@ -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 → fleet_python-0.2.50}/pyproject.toml

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

fleet_python-0.2.48/examples/example_tasks.py

@@ -1,31 +0,0 @@
-import fleet
-from dotenv import load_dotenv
-
-load_dotenv()
-
-
-def main():
-    env = fleet.env.make("fira")
-
-    tasks = fleet.load_tasks(env_key="fira")
-    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)
-
-
-if __name__ == "__main__":
-    main()