fleet-python 0.2.42__tar.gz → 0.2.44__tar.gz

{fleet_python-0.2.42 → fleet_python-0.2.44}/PKG-INFO

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

{fleet_python-0.2.42 → fleet_python-0.2.44}/fleet/__init__.py

@@ -46,11 +46,15 @@ from ._async.verifiers import (
     AsyncVerifierFunction,
 )
 
-# Import async tasks (default tasks are async for modern usage)  
-from ._async.tasks import Task, load_tasks as load_tasks_async
+# Import async tasks (default tasks are async for modern usage)
+from ._async.tasks import (
+    Task,
+    load_tasks as load_tasks_async,
+    load_tasks_from_file as load_tasks_from_file_async,
+)
 
 # Import sync load_tasks function
-from .tasks import load_tasks
+from .tasks import load_tasks, load_tasks_from_file
 
 # Import shared types
 from .types import VerifierFunction
@@ -105,13 +109,11 @@ __all__ = [
 ]
 
 
-
-
 def configure(
     api_key: Optional[str] = None,
     base_url: Optional[str] = None,
-    max_retries: int | None = None,
-    timeout: float | None = None,
+    max_retries: Optional[int] = None,
+    timeout: Optional[float] = None,
 ):
     """Configure global clients (sync and async) once per process.
 

{fleet_python-0.2.42 → fleet_python-0.2.44}/fleet/_async/__init__.py

@@ -73,17 +73,17 @@ __all__ = [
     "reset_client",
     # Module-level functions
     "load_tasks",
-    "list_envs", 
+    "list_envs",
     "list_regions",
     "environment",
     "make",
     "make_for_task",
     "instances",
-    "instance", 
+    "instance",
     "delete",
     "load_tasks_from_file",
     "load_task_array_from_string",
-    "load_task_from_string", 
+    "load_task_from_string",
     "load_task_from_json",
     "export_tasks",
     "import_tasks",
@@ -108,9 +108,13 @@ async def environment(env_key: str) -> Environment:
     return await _async_global_client.get_client().environment(env_key)
 
 
-async def make(env_key: str, region: Optional[str] = None, env_variables: Optional[Dict[str, Any]] = None) -> AsyncEnv:
+async def make(
+    env_key: str,
+    region: Optional[str] = None,
+    env_variables: Optional[Dict[str, Any]] = None,
+) -> AsyncEnv:
     """Create a new environment instance.
-    
+
     Example:
         env = await fleet.make("fira")
         env_with_vars = await fleet.make("fira", env_variables={"LOGGED_IN_NAME": "Alice"})
@@ -123,7 +127,9 @@ async def make_for_task(task: Task) -> AsyncEnv:
     return await _async_global_client.get_client().make_for_task(task)
 
 
-async def instances(status: Optional[str] = None, region: Optional[str] = None) -> List[AsyncEnv]:
+async def instances(
+    status: Optional[str] = None, region: Optional[str] = None
+) -> List[AsyncEnv]:
     """List existing environment instances."""
     return await _async_global_client.get_client().instances(status, region)
 
@@ -140,7 +146,7 @@ async def delete(instance_id: str) -> InstanceResponse:
 
 async 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")
     """
@@ -149,16 +155,18 @@ async def load_tasks_from_file(filename: str) -> List[Task]:
 
 async def load_task_array_from_string(serialized_tasks: str) -> List[Task]:
     """Load tasks from a JSON string containing an array of tasks.
-    
+
     Example:
         tasks = await fleet.load_task_array_from_string(json_string)
     """
-    return await _async_global_client.get_client().load_task_array_from_string(serialized_tasks)
+    return await _async_global_client.get_client().load_task_array_from_string(
+        serialized_tasks
+    )
 
 
 async def load_task_from_string(task_string: str) -> Task:
     """Load a single task from a JSON string.
-    
+
     Example:
         task = await fleet.load_task_from_string(task_json_string)
     """
@@ -167,16 +175,18 @@ async def load_task_from_string(task_string: str) -> Task:
 
 async def load_task_from_json(task_json: dict) -> Task:
     """Load a single task from a dictionary.
-    
+
     Example:
         task = await fleet.load_task_from_json(task_dict)
     """
     return await _async_global_client.get_client().load_task_from_json(task_json)
 
 
-async def export_tasks(env_key: Optional[str] = None, filename: Optional[str] = None) -> Optional[str]:
+async def export_tasks(
+    env_key: Optional[str] = None, filename: Optional[str] = None
+) -> Optional[str]:
     """Export tasks to a JSON file.
-    
+
     Example:
         await fleet.export_tasks("fira", "fira_tasks.json")
     """
@@ -185,7 +195,7 @@ async def export_tasks(env_key: Optional[str] = None, filename: Optional[str] =
 
 async def import_tasks(filename: str):
     """Import tasks from a JSON file.
-    
+
     Example:
         await fleet.import_tasks("tasks.json")
     """
@@ -200,8 +210,8 @@ async def account() -> AccountResponse:
 def configure(
     api_key: Optional[str] = None,
     base_url: Optional[str] = None,
-    max_retries: int | None = None,
-    timeout: float | None = None,
+    max_retries: Optional[int] = None,
+    timeout: Optional[float] = None,
 ):
     """Configure global async client once per process.
 
@@ -213,9 +223,11 @@ def configure(
     """
     if max_retries is None:
         from ..config import DEFAULT_MAX_RETRIES as _MR
+
         max_retries = _MR
     if timeout is None:
         from ..config import DEFAULT_TIMEOUT as _TO
+
         timeout = _TO
     _async_global_client.configure(
         api_key=api_key, base_url=base_url, max_retries=max_retries, timeout=timeout

{fleet_python-0.2.42 → fleet_python-0.2.44}/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
@@ -129,7 +130,7 @@ class AsyncEnv(EnvironmentBase):
         return await self.instance.verify(validator)
 
     async def verify_raw(
-        self, function_code: str, function_name: str | None = None
+        self, function_code: str, function_name: Optional[str] = None
     ) -> ExecuteFunctionResponse:
         return await self.instance.verify_raw(function_code, function_name)
 
@@ -206,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",
@@ -286,43 +302,72 @@ 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]
-    ) -> List[Task]:
+    async def load_task_array_from_string(self, serialized_tasks: str) -> List[Task]:
         tasks = []
 
-        json_tasks = json.loads(serialized_tasks)
+        parsed_data = json.loads(serialized_tasks)
+        if isinstance(parsed_data, list):
+            json_tasks = parsed_data
+        elif isinstance(parsed_data, dict) and "tasks" in parsed_data:
+            json_tasks = parsed_data["tasks"]
+        else:
+            raise ValueError(
+                "Invalid JSON structure: expected array or object with 'tasks' key"
+            )
+
         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
+        verifier_code = task_json.get("verifier_func") or task_json.get("verifier_code")
+
+        # Try to find verifier_id in multiple locations
+        verifier_id = task_json.get("verifier_id")
+        if (
+            not verifier_id
+            and "metadata" in task_json
+            and isinstance(task_json["metadata"], dict)
+        ):
+            verifier_metadata = task_json["metadata"].get("verifier", {})
+            if isinstance(verifier_metadata, dict):
+                verifier_id = verifier_metadata.get("verifier_id")
+
+        # If no verifier_id found, use the task key/id as fallback
+        if not verifier_id:
+            verifier_id = task_json.get("key", task_json.get("id"))
+
         try:
-            if "verifier_id" in task_json and task_json["verifier_id"]:
-                verifier = self._create_verifier_from_data(
-                    verifier_id=task_json["verifier_id"],
-                    verifier_key=task_json["key"],
-                    verifier_code=task_json["verifier_func"],
+            if verifier_id and verifier_code:
+                verifier = await self._create_verifier_from_data(
+                    verifier_id=verifier_id,
+                    verifier_key=task_json.get("key", task_json.get("id")),
+                    verifier_code=verifier_code,
                     verifier_sha=task_json.get("verifier_sha", ""),
                 )
         except Exception as e:
-            logger.warning(f"Failed to create verifier {task_json['key']}: {e}")
+            logger.warning(
+                f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
+            )
 
         task = Task(
-            key=task_json["key"],
+            key=task_json.get("key", task_json.get("id")),
             prompt=task_json["prompt"],
-            env_id=task_json["env_id"],  # Use env_id from the data
-            created_at=task_json["created_at"],
+            env_id=task_json.get(
+                "env_id", task_json.get("env_key")
+            ),  # Use env_id or fallback to env_key
+            created_at=task_json.get("created_at"),
             version=task_json.get("version"),
             env_variables=task_json.get("env_variables", {}),
-            verifier_func=task_json.get("verifier_func"),  # Set verifier code
+            verifier_func=verifier_code,  # Set verifier code
             verifier=verifier,  # Use created verifier or None
             metadata=task_json.get("metadata", {}),  # Default empty metadata
         )
@@ -357,48 +402,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(100)  # 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,
@@ -507,7 +603,7 @@ class AsyncFleet:
         self,
         task_key: str,
         prompt: Optional[str] = None,
-        verifier_code: Optional[str] = None
+        verifier_code: Optional[str] = None,
     ) -> TaskResponse:
         """Update an existing task.
 
@@ -519,10 +615,7 @@ class AsyncFleet:
         Returns:
             TaskResponse containing the updated task details
         """
-        payload = TaskUpdateRequest(
-            prompt=prompt,
-            verifier_code=verifier_code
-        )
+        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)
         )
@@ -542,8 +635,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(
@@ -568,7 +660,7 @@ class AsyncFleet:
             AsyncVerifierFunction created from the verifier code
         """
         # Fetch verifier from API
-        response = await self.client.request("GET", f"/v1/verifier/{verifier_id}")
+        response = await self.client.request("GET", f"/v1/verifiers/{verifier_id}")
         verifier_data = response.json()
 
         # Use the common method to create verifier

{fleet_python-0.2.42 → fleet_python-0.2.44}/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_python-0.2.42 → fleet_python-0.2.44}/fleet/_async/instance/client.py

@@ -108,7 +108,7 @@ class AsyncInstanceClient:
         return await self.verify_raw(function_code, function_name)
 
     async def verify_raw(
-        self, function_code: str, function_name: str | None = None
+        self, function_code: str, function_name: Optional[str] = None
     ) -> ExecuteFunctionResponse:
         try:
             function_code = convert_verifier_string(function_code)