fleet-python 0.2.41__py3-none-any.whl → 0.2.43__py3-none-any.whl

fleet/_async/client.py

@@ -14,6 +14,7 @@
 
 """Fleet API Client for making HTTP requests to Fleet services."""
 
+import asyncio
 import base64
 import cloudpickle
 import httpx
@@ -32,6 +33,8 @@ from ..models import (
     TaskListResponse,
     AccountResponse,
     TaskRequest,
+    TaskResponse,
+    TaskUpdateRequest,
 )
 from .tasks import Task
 
@@ -204,24 +207,39 @@ class AsyncFleet:
     async def make(
         self,
         env_key: str,
+        data_key: Optional[str] = None,
         region: Optional[str] = None,
         env_variables: Optional[Dict[str, Any]] = None,
     ) -> AsyncEnv:
         if ":" in env_key:
-            env_key_part, version = env_key.split(":", 1)
+            env_key_part, env_version = env_key.split(":", 1)
             if (
-                not version.startswith("v")
-                and len(version) != 0
-                and version[0].isdigit()
+                not env_version.startswith("v")
+                and len(env_version) != 0
+                and env_version[0].isdigit()
             ):
-                version = f"v{version}"
+                env_version = f"v{env_version}"
         else:
             env_key_part = env_key
-            version = None
+            env_version = None
+
+        if data_key is not None and ":" in data_key:
+            data_key_part, data_version = data_key.split(":", 1)
+            if (
+                not data_version.startswith("v")
+                and len(data_version) != 0
+                and data_version[0].isdigit()
+            ):
+                data_version = f"v{data_version}"
+        else:
+            data_key_part = data_key
+            data_version = None
 
         request = InstanceRequest(
             env_key=env_key_part,
-            version=version,
+            env_version=env_version,
+            data_key=data_key_part,
+            data_version=data_version,
             region=region,
             env_variables=env_variables,
             created_from="sdk",
@@ -284,7 +302,7 @@ class AsyncFleet:
         with open(filename, "r", encoding="utf-8") as f:
             tasks_data = f.read()
 
-        return self.load_task_array_from_string(tasks_data)
+        return await self.load_task_array_from_string(tasks_data)
 
     async def load_task_array_from_string(
         self, serialized_tasks: List[Dict]
@@ -293,18 +311,19 @@ class AsyncFleet:
 
         json_tasks = json.loads(serialized_tasks)
         for json_task in json_tasks:
-            parsed_task = self.load_task_from_json(json_task)
+            parsed_task = await self.load_task_from_json(json_task)
             tasks.append(parsed_task)
         return tasks
 
     async def load_task_from_string(self, task_string: str) -> Task:
         task_json = json.loads(task_string)
-        return self.load_task_from_json(task_json)
+        return await self.load_task_from_json(task_json)
 
     async def load_task_from_json(self, task_json: Dict) -> Task:
+        verifier = None
         try:
             if "verifier_id" in task_json and task_json["verifier_id"]:
-                verifier = self._create_verifier_from_data(
+                verifier = await self._create_verifier_from_data(
                     verifier_id=task_json["verifier_id"],
                     verifier_key=task_json["key"],
                     verifier_code=task_json["verifier_func"],
@@ -355,48 +374,99 @@ class AsyncFleet:
         response = await self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
 
-        # Transform TaskResponse objects to Task objects
-        tasks = []
-        for task_response in task_list_response.tasks:
-            # Create verifier function if verifier data is present
-            verifier = None
-            verifier_func = task_response.verifier_func
+        # Prepare verifier loading coroutines with concurrency limit
+        verifier_coroutines = []
+        task_responses_with_indices = []
+        semaphore = asyncio.Semaphore(10)  # Limit to 10 concurrent operations
 
+        for idx, task_response in enumerate(task_list_response.tasks):
             if task_response.verifier:
                 embedded_code = task_response.verifier.code or ""
                 is_embedded_error = embedded_code.strip().startswith(
                     "<error loading code:"
                 )
-                if not is_embedded_error:
-                    # Only override if the embedded code looks valid
-                    verifier_func = embedded_code
-                    # Create VerifierFunction from the embedded data
-                    try:
-                        verifier = await self._create_verifier_from_data(
-                            verifier_id=task_response.verifier.verifier_id,
-                            verifier_key=task_response.verifier.key,
-                            verifier_code=embedded_code,
-                            verifier_sha=task_response.verifier.sha256,
-                        )
-                    except Exception as e:
-                        logger.warning(
-                            f"Failed to create verifier {task_response.verifier.key}: {e}"
-                        )
-                else:
-                    # Fallback: try fetching by ID if embedded code failed to load
-                    try:
-                        logger.warning(
-                            f"Embedded verifier code missing for {task_response.verifier.key} (NoSuchKey). "
-                            f"Attempting to refetch by id {task_response.verifier.verifier_id}"
-                        )
-                        verifier = await self._load_verifier(
-                            task_response.verifier.verifier_id
-                        )
-                    except Exception as e:
-                        logger.warning(
-                            f"Refetch by verifier id failed for {task_response.verifier.key}: {e}. "
-                            "Leaving verifier unset."
-                        )
+
+                async def create_verifier_with_fallback(tr, emb_code, is_error):
+                    """Create verifier with fallback logic."""
+                    async with semaphore:  # Acquire semaphore before operation
+                        if not is_error:
+                            # Try to create from embedded data
+                            try:
+                                return await 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 await 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_coroutines.append(None)
+                task_responses_with_indices.append((idx, task_response))
+
+        # Execute all verifier loading in parallel
+        if verifier_coroutines:
+            verifier_results = await asyncio.gather(
+                *[
+                    coro if coro is not None else asyncio.sleep(0)
+                    for coro in verifier_coroutines
+                ],
+                return_exceptions=True,
+            )
+        else:
+            verifier_results = []
+
+        # Build tasks with results
+        tasks = []
+        for (idx, task_response), verifier_result in zip(
+            task_responses_with_indices, verifier_results
+        ):
+            # Handle verifier result
+            verifier = None
+            verifier_func = task_response.verifier_func
+
+            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:
+                    verifier = verifier_result
+                    embedded_code = task_response.verifier.code or ""
+                    is_embedded_error = embedded_code.strip().startswith(
+                        "<error loading code:"
+                    )
+                    if not is_embedded_error:
+                        verifier_func = embedded_code
 
             task = Task(
                 key=task_response.key,
@@ -501,6 +571,28 @@ class AsyncFleet:
         response = await self.client.request("GET", "/v1/account")
         return AccountResponse(**response.json())
 
+    async def update_task(
+        self,
+        task_key: str,
+        prompt: Optional[str] = None,
+        verifier_code: Optional[str] = None,
+    ) -> TaskResponse:
+        """Update an existing task.
+
+        Args:
+            task_key: The key of the task to update
+            prompt: New prompt text for the task (optional)
+            verifier_code: Python code for task verification (optional)
+
+        Returns:
+            TaskResponse containing the updated task details
+        """
+        payload = TaskUpdateRequest(prompt=prompt, verifier_code=verifier_code)
+        response = await self.client.request(
+            "PUT", f"/v1/tasks/{task_key}", json=payload.model_dump(exclude_none=True)
+        )
+        return TaskResponse(**response.json())
+
     async def _create_verifier_from_data(
         self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str
     ) -> "AsyncVerifierFunction":
@@ -515,8 +607,7 @@ class AsyncFleet:
         Returns:
             AsyncVerifierFunction created from the verifier code
         """
-        from ..tasks import verifier_from_string
-        from .verifiers.verifier import AsyncVerifierFunction
+        from .tasks import verifier_from_string
 
         # Use verifier_from_string to create the verifier
         verifier_func = verifier_from_string(

fleet/_async/env/client.py

@@ -3,8 +3,15 @@ from ...models import Environment as EnvironmentModel, AccountResponse
 from typing import List, Optional, Dict, Any
 
 
-async def make_async(env_key: str, region: Optional[str] = None, env_variables: Optional[Dict[str, Any]] = None) -> AsyncEnv:
-    return await AsyncFleet().make(env_key, region=region, env_variables=env_variables)
+async def make_async(
+    env_key: str,
+    data_key: Optional[str] = None,
+    region: Optional[str] = None,
+    env_variables: Optional[Dict[str, Any]] = None,
+) -> AsyncEnv:
+    return await AsyncFleet().make(
+        env_key, data_key=data_key, region=region, env_variables=env_variables
+    )
 
 
 async def make_for_task_async(task: Task) -> AsyncEnv:

fleet/_async/models.py

@@ -156,6 +156,11 @@ class TaskRequest(BaseModel):
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
 
 
+class TaskUpdateRequest(BaseModel):
+    prompt: Optional[str] = Field(None, title="Prompt")
+    verifier_code: Optional[str] = Field(None, title="Verifier Code")
+
+
 class VerifierData(BaseModel):
     verifier_id: str = Field(..., title="Verifier Id")
     key: str = Field(..., title="Key")

fleet/_async/tasks.py

@@ -2,10 +2,8 @@
 
 from __future__ import annotations
 
-import re
 from datetime import datetime
 from typing import Any, Dict, Optional, List
-from uuid import UUID
 
 from pydantic import BaseModel, Field, validator
 
@@ -46,7 +44,7 @@ class Task(BaseModel):
     @property
     def env_key(self) -> str:
         """Get the environment key combining env_id and version."""
-        if self.version:
+        if self.version and self.version != "None":
             return f"{self.env_id}:{self.version}"
         return self.env_id
 
@@ -75,7 +73,7 @@ class Task(BaseModel):
             if inspect.iscoroutine(result):
                 # Check if we're already in an event loop
                 try:
-                    loop = asyncio.get_running_loop()
+                    asyncio.get_running_loop()
                     # We're in an async context, can't use asyncio.run()
                     raise RuntimeError(
                         "Cannot run async verifier in sync mode while event loop is running. "
@@ -121,58 +119,57 @@ class Task(BaseModel):
 
 
 def verifier_from_string(
-    verifier_func: str,
-    verifier_id: str,
-    verifier_key: str,
-    sha256: str = ""
-) -> 'VerifierFunction':
+    verifier_func: str, verifier_id: str, verifier_key: str, sha256: str = ""
+) -> "VerifierFunction":
     """Create a verifier function from string code.
-    
+
     Args:
         verifier_func: The verifier function code as a string
         verifier_id: Unique identifier for the verifier
         verifier_key: Key/name for the verifier
         sha256: SHA256 hash of the verifier code
-        
+
     Returns:
         VerifierFunction instance that can be used to verify tasks
     """
     try:
         import inspect
-        from .verifiers import verifier, AsyncVerifierFunction
+        from .verifiers.verifier import AsyncVerifierFunction
         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 = {
-            'TASK_SUCCESSFUL_SCORE': TASK_SUCCESSFUL_SCORE,
-            'TASK_FAILED_SCORE': TASK_FAILED_SCORE,
-            'IgnoreConfig': IgnoreConfig,
-            'Environment': object  # Add Environment type if needed
+            "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, globals(), local_namespace)
-        
+
         # Find the function that was defined
         func_obj = None
         for name, obj in local_namespace.items():
             if inspect.isfunction(obj):
                 func_obj = obj
                 break
-        
+
         if func_obj is None:
             raise ValueError("No function found in verifier code")
-        
-        # Create an AsyncVerifierFunction instance
-        verifier_instance = AsyncVerifierFunction(func_obj, verifier_key, verifier_id)
-        
-        # Store additional metadata
-        verifier_instance._verifier_code = verifier_func
-        verifier_instance._sha256 = sha256
-        
+
+        # Create an AsyncVerifierFunction instance with raw code
+        verifier_instance = AsyncVerifierFunction(
+            func_obj,
+            verifier_key,
+            verifier_id=verifier_id,
+            sha256=sha256,
+            raw_code=verifier_func,
+        )
+
         return verifier_instance
-        
+
     except Exception as e:
         raise ValueError(f"Failed to create verifier from string: {e}")
 
@@ -181,7 +178,7 @@ async def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,
     version: Optional[str] = None,
-    team_id: Optional[str] = None
+    team_id: Optional[str] = None,
 ) -> List[Task]:
     """Convenience function to load tasks with optional filtering.
 
@@ -201,8 +198,30 @@ 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
+    )
+
+
+async def update_task(
+    task_key: str, prompt: Optional[str] = None, verifier_code: Optional[str] = None
+):
+    """Convenience function to update an existing task.
+
+    Args:
+        task_key: The key of the task to update
+        prompt: New prompt text for the task (optional)
+        verifier_code: Python code for task verification (optional)
+
+    Returns:
+        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")
+    """
+    from .global_client import get_client
+
+    client = get_client()
+    return await client.update_task(
+        task_key=task_key, prompt=prompt, verifier_code=verifier_code
     )

fleet/client.py

@@ -16,6 +16,7 @@
 
 import base64
 import cloudpickle
+import concurrent.futures
 import httpx
 import json
 import logging
@@ -32,6 +33,8 @@ from .models import (
     TaskListResponse,
     AccountResponse,
     TaskRequest,
+    TaskResponse,
+    TaskUpdateRequest,
 )
 from .tasks import Task
 
@@ -204,24 +207,39 @@ class Fleet:
     def make(
         self,
         env_key: str,
+        data_key: Optional[str] = None,
         region: Optional[str] = None,
         env_variables: Optional[Dict[str, Any]] = None,
     ) -> SyncEnv:
         if ":" in env_key:
-            env_key_part, version = env_key.split(":", 1)
+            env_key_part, env_version = env_key.split(":", 1)
             if (
-                not version.startswith("v")
-                and len(version) != 0
-                and version[0].isdigit()
+                not env_version.startswith("v")
+                and len(env_version) != 0
+                and env_version[0].isdigit()
             ):
-                version = f"v{version}"
+                env_version = f"v{env_version}"
         else:
             env_key_part = env_key
-            version = None
+            env_version = None
+
+        if data_key is not None and ":" in data_key:
+            data_key_part, data_version = data_key.split(":", 1)
+            if (
+                not data_version.startswith("v")
+                and len(data_version) != 0
+                and data_version[0].isdigit()
+            ):
+                data_version = f"v{data_version}"
+        else:
+            data_key_part = data_key
+            data_version = None
 
         request = InstanceRequest(
             env_key=env_key_part,
-            version=version,
+            env_version=env_version,
+            data_key=data_key_part,
+            data_version=data_version,
             region=region,
             env_variables=env_variables,
             created_from="sdk",
@@ -351,48 +369,107 @@ class Fleet:
         response = self.client.request("GET", "/v1/tasks", params=params)
         task_list_response = TaskListResponse(**response.json())
 
-        # Transform TaskResponse objects to Task objects
-        tasks = []
-        for task_response in task_list_response.tasks:
-            # Create verifier function if verifier data is present
-            verifier = None
-            verifier_func = task_response.verifier_func
+        # Prepare verifier loading tasks
+        verifier_tasks = []
+        task_responses_with_indices = []
 
+        for idx, task_response in enumerate(task_list_response.tasks):
             if task_response.verifier:
                 embedded_code = task_response.verifier.code or ""
                 is_embedded_error = embedded_code.strip().startswith(
                     "<error loading code:"
                 )
-                if not is_embedded_error:
-                    # Only override if the embedded code looks valid
-                    verifier_func = embedded_code
-                    # Create VerifierFunction from the embedded data
-                    try:
-                        verifier = self._create_verifier_from_data(
-                            verifier_id=task_response.verifier.verifier_id,
-                            verifier_key=task_response.verifier.key,
-                            verifier_code=embedded_code,
-                            verifier_sha=task_response.verifier.sha256,
-                        )
-                    except Exception as e:
-                        logger.warning(
-                            f"Failed to create verifier {task_response.verifier.key}: {e}"
-                        )
-                else:
-                    # Fallback: try fetching by ID if embedded code failed to load
-                    try:
-                        logger.warning(
-                            f"Embedded verifier code missing for {task_response.verifier.key} (NoSuchKey). "
-                            f"Attempting to refetch by id {task_response.verifier.verifier_id}"
-                        )
-                        verifier = self._load_verifier(
-                            task_response.verifier.verifier_id
-                        )
-                    except Exception as e:
-                        logger.warning(
-                            f"Refetch by verifier id failed for {task_response.verifier.key}: {e}. "
-                            "Leaving verifier unset."
-                        )
+
+                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,
+                    )
+                )
+                task_responses_with_indices.append((idx, task_response))
+            else:
+                # No verifier needed
+                verifier_tasks.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)
+
+        # Build tasks with results
+        tasks = []
+        for (idx, task_response), verifier_result in zip(
+            task_responses_with_indices, verifier_results
+        ):
+            # Handle verifier result
+            verifier = None
+            verifier_func = task_response.verifier_func
+
+            if task_response.verifier:
+                # Process verifier result
+                if verifier_result is not None:
+                    verifier = verifier_result
+                    embedded_code = task_response.verifier.code or ""
+                    is_embedded_error = embedded_code.strip().startswith(
+                        "<error loading code:"
+                    )
+                    if not is_embedded_error:
+                        verifier_func = embedded_code
 
             task = Task(
                 key=task_response.key,
@@ -497,6 +574,28 @@ class Fleet:
         response = self.client.request("GET", "/v1/account")
         return AccountResponse(**response.json())
 
+    def update_task(
+        self,
+        task_key: str,
+        prompt: Optional[str] = None,
+        verifier_code: Optional[str] = None,
+    ) -> TaskResponse:
+        """Update an existing task.
+
+        Args:
+            task_key: The key of the task to update
+            prompt: New prompt text for the task (optional)
+            verifier_code: Python code for task verification (optional)
+
+        Returns:
+            TaskResponse containing the updated task details
+        """
+        payload = TaskUpdateRequest(prompt=prompt, verifier_code=verifier_code)
+        response = self.client.request(
+            "PUT", f"/v1/tasks/{task_key}", json=payload.model_dump(exclude_none=True)
+        )
+        return TaskResponse(**response.json())
+
     def _create_verifier_from_data(
         self, verifier_id: str, verifier_key: str, verifier_code: str, verifier_sha: str
     ) -> "SyncVerifierFunction":

fleet/env/client.py

@@ -3,8 +3,15 @@ from ..models import Environment as EnvironmentModel, AccountResponse
 from typing import List, Optional, Dict, Any
 
 
-def make(env_key: str, region: Optional[str] = None, env_variables: Optional[Dict[str, Any]] = None) -> SyncEnv:
-    return Fleet().make(env_key, region=region, env_variables=env_variables)
+def make(
+    env_key: str,
+    data_key: Optional[str] = None,
+    region: Optional[str] = None,
+    env_variables: Optional[Dict[str, Any]] = None,
+) -> SyncEnv:
+    return Fleet().make(
+        env_key, data_key=data_key, region=region, env_variables=env_variables
+    )
 
 
 def make_for_task_async(task: Task) -> SyncEnv:

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="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")
@@ -156,6 +158,11 @@ class TaskRequest(BaseModel):
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
 
 
+class TaskUpdateRequest(BaseModel):
+    prompt: Optional[str] = Field(None, title="Prompt")
+    verifier_code: Optional[str] = Field(None, title="Verifier Code")
+
+
 class VerifierData(BaseModel):
     verifier_id: str = Field(..., title="Verifier Id")
     key: str = Field(..., title="Key")

fleet/tasks.py

@@ -47,7 +47,7 @@ class Task(BaseModel):
     @property
     def env_key(self) -> str:
         """Get the environment key combining env_id and version."""
-        if self.version:
+        if self.version and self.version != "None":
             return f"{self.env_id}:{self.version}"
         return self.env_id
 
@@ -70,7 +70,7 @@ class Task(BaseModel):
             import inspect
 
             # Check if verifier has remote method (for decorated verifiers)
-            if hasattr(self.verifier, 'remote'):
+            if hasattr(self.verifier, "remote"):
                 result = self.verifier.remote(env, *args, **kwargs)
             else:
                 # For verifiers created from string, call directly
@@ -126,19 +126,16 @@ class Task(BaseModel):
 
 
 def verifier_from_string(
-    verifier_func: str,
-    verifier_id: str,
-    verifier_key: str,
-    sha256: str = ""
-) -> 'VerifierFunction':
+    verifier_func: str, verifier_id: str, verifier_key: str, sha256: str = ""
+) -> "VerifierFunction":
     """Create a verifier function from string code.
-    
+
     Args:
         verifier_func: The verifier function code as a string
         verifier_id: Unique identifier for the verifier
         verifier_key: Key/name for the verifier
         sha256: SHA256 hash of the verifier code
-        
+
     Returns:
         VerifierFunction instance that can be used to verify tasks
     """
@@ -147,63 +144,72 @@ def verifier_from_string(
         from .verifiers import verifier, 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
-        })
-        
+        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 = {}
-        
+
         # Execute the verifier code in the namespace
         exec(verifier_func, exec_globals, local_namespace)
-        
+
         # Find the function that was defined
         func_obj = None
         for name, obj in local_namespace.items():
             if inspect.isfunction(obj):
                 func_obj = obj
                 break
-        
+
         if func_obj is None:
             raise ValueError("No function found in verifier code")
-        
+
         # Create a wrapper function that provides the necessary globals
         def wrapped_verifier(env, *args, **kwargs):
             # Set up globals for the function execution
-            func_globals = func_obj.__globals__.copy() if hasattr(func_obj, '__globals__') else {}
-            func_globals.update({
-                'TASK_SUCCESSFUL_SCORE': TASK_SUCCESSFUL_SCORE,
-                'TASK_FAILED_SCORE': TASK_FAILED_SCORE,
-                'IgnoreConfig': IgnoreConfig
-            })
-            
+            func_globals = (
+                func_obj.__globals__.copy() if hasattr(func_obj, "__globals__") else {}
+            )
+            func_globals.update(
+                {
+                    "TASK_SUCCESSFUL_SCORE": TASK_SUCCESSFUL_SCORE,
+                    "TASK_FAILED_SCORE": TASK_FAILED_SCORE,
+                    "IgnoreConfig": IgnoreConfig,
+                }
+            )
+
             # Create a new function with the updated globals
             import types
+
             new_func = types.FunctionType(
                 func_obj.__code__,
                 func_globals,
                 func_obj.__name__,
                 func_obj.__defaults__,
-                func_obj.__closure__
+                func_obj.__closure__,
             )
-            
+
             return new_func(env, *args, **kwargs)
-        
+
         # Create an AsyncVerifierFunction instance with the wrapped function
-        verifier_instance = SyncVerifierFunction(wrapped_verifier, verifier_key, verifier_id)
-        
+        verifier_instance = SyncVerifierFunction(
+            wrapped_verifier, verifier_key, verifier_id
+        )
+
         # Store additional metadata
         verifier_instance._verifier_code = verifier_func
         verifier_instance._sha256 = sha256
-        
+
         return verifier_instance
-        
+
     except Exception as e:
         raise ValueError(f"Failed to create verifier from string: {e}")
 
@@ -212,7 +218,7 @@ def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,
     version: Optional[str] = None,
-    team_id: Optional[str] = None
+    team_id: Optional[str] = None,
 ) -> List[Task]:
     """Convenience function to load tasks with optional filtering.
 
@@ -232,8 +238,31 @@ 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
+    )
+
+
+def update_task(
+    task_key: str, prompt: Optional[str] = None, verifier_code: Optional[str] = None
+):
+    """Convenience function to update an existing task.
+
+    Args:
+        task_key: The key of the task to update
+        prompt: New prompt text for the task (optional)
+        verifier_code: Python code for task verification (optional)
+
+    Returns:
+        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")
+    """
+    from .global_client import get_client
+    from .models import TaskResponse
+
+    client = get_client()
+    return client.update_task(
+        task_key=task_key, prompt=prompt, verifier_code=verifier_code
     )

{fleet_python-0.2.41.dist-info → fleet_python-0.2.43.dist-info}/METADATA

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

{fleet_python-0.2.41.dist-info → fleet_python-0.2.43.dist-info}/RECORD

@@ -21,22 +21,22 @@ examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
 fleet/__init__.py,sha256=oxI2XvaiRMn15AZpoDHOvX26WlXALHXvqSRP0KkBpAY,3751
 fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
-fleet/client.py,sha256=OKc68xmt819OxBQ-RfNslfDTHJtX0pPLxdGVdH1WAh8,22102
+fleet/client.py,sha256=d-sGsC8a68czfuaSSm8_Vrkzo-lvamDdwWiCYT2QttE,25865
 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=9tDjgcgKPMnf-R_MDh-Ocp_UMbyJ8tJyjb15XqU0N94,12454
-fleet/tasks.py,sha256=9ass6zLyuMKC_2gTphZClhVR9RdJml-yeH_GbCu6WOE,8733
+fleet/models.py,sha256=WAiRXa68aXSVbCqmQMn36n9cSlls6YsicV6BbyoeiYQ,12750
+fleet/tasks.py,sha256=P-qcbLZLMVGdJ02Rb8Q2kGIINdnZ_CNIu_FeCVcihcg,9573
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
 fleet/_async/__init__.py,sha256=lrnDD6N9p0Oqpi_djxTnxh8I5F7nA7KNn0khciGmgpg,6747
 fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
-fleet/_async/client.py,sha256=fTzc5wtPntihAdydE_g-XIJYojcrfDvvmcOJUgR557k,22597
+fleet/_async/client.py,sha256=4nwpX933fIutctwictasU8oJODwP63vRT0FJxd1b_Do,26170
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
-fleet/_async/models.py,sha256=9tDjgcgKPMnf-R_MDh-Ocp_UMbyJ8tJyjb15XqU0N94,12454
-fleet/_async/tasks.py,sha256=M1jueEdqzr_q02YrOKgjNLf3C1wRWK5rsPp0bcoxkME,7450
+fleet/_async/models.py,sha256=li5Cii7ASUHCFMFeJIMklyicYczqPez768RxO0Q0F2o,12618
+fleet/_async/tasks.py,sha256=QZFQNW4_Iq2VbGZiPXzKDFXmNrxe4mn-ROGvpGhN7pw,8131
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=9GOSkEWNncwTtiZNaJ2vNGrFCPutyan9lBNhD87dAzQ,1059
+fleet/_async/env/client.py,sha256=8dS42VvSgdqfuh96l6cyiLZlKElilmfTeRSZ4LZnFuE,1143
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
 fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
 fleet/_async/instance/client.py,sha256=z9q_-dIBwPc1X6VlQOi_aV2v6KOKueJGg8NMyP5iFQM,6082
@@ -49,7 +49,7 @@ fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMT
 fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
 fleet/_async/verifiers/verifier.py,sha256=lwVIV5ZpWJhM87tXShtjwN5KP7n5XDcPq0XX7AjV6_E,14343
 fleet/env/__init__.py,sha256=cS9zCYobM5jypppDMZIQMYd6hOg5f4sgqRXEQ67pckk,676
-fleet/env/client.py,sha256=wvZbmHdftkuhAgpzOGiA4Yl_Th9BUIHFR_6JUYg6Nc8,893
+fleet/env/client.py,sha256=imF47xJG4JeihcZw4Y-_fXz4XxS-OgIkzUK-TLjpeJY,977
 fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
 fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
 fleet/instance/client.py,sha256=O6B0A2Z0b5SxOLs4TipZ9Ol8yG-b-LG15vVOKMmd6BQ,5908
@@ -67,10 +67,10 @@ fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,
 fleet/verifiers/parse.py,sha256=0bAbj9VvT__yU4ZVREUK-Tn9dukh9LCpmfVsgj1DfP4,8508
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
 fleet/verifiers/verifier.py,sha256=53oBWAf0yy3bZmZx9eH9AWIf65H7OP2UUm0YwWCL6Mc,14286
-fleet_python-0.2.41.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.43.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.41.dist-info/METADATA,sha256=kgKHMZOtj-gOUUcMJQPqp-2f-QYWLfZZwyMkjKd0Mzg,3304
-fleet_python-0.2.41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.41.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.41.dist-info/RECORD,,
+fleet_python-0.2.43.dist-info/METADATA,sha256=fgD6_tIyLKKOXNT_qoyf98t12w3ITDd1vAyCYFh7_KU,3304
+fleet_python-0.2.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.43.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.43.dist-info/RECORD,,