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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.43
+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.43 → 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.43 → 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.43 → fleet_python-0.2.44}/fleet/_async/client.py

@@ -130,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)
 
@@ -304,12 +304,19 @@ class AsyncFleet:
 
         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 = await self.load_task_from_json(json_task)
             tasks.append(parsed_task)
@@ -321,25 +328,46 @@ class AsyncFleet:
 
     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"]:
+            if verifier_id and verifier_code:
                 verifier = await self._create_verifier_from_data(
-                    verifier_id=task_json["verifier_id"],
-                    verifier_key=task_json["key"],
-                    verifier_code=task_json["verifier_func"],
+                    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
         )
@@ -377,7 +405,7 @@ class AsyncFleet:
         # Prepare verifier loading coroutines with concurrency limit
         verifier_coroutines = []
         task_responses_with_indices = []
-        semaphore = asyncio.Semaphore(10)  # Limit to 10 concurrent operations
+        semaphore = asyncio.Semaphore(100)  # Limit to 10 concurrent operations
 
         for idx, task_response in enumerate(task_list_response.tasks):
             if task_response.verifier:
@@ -632,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.43 → 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)

{fleet_python-0.2.43 → fleet_python-0.2.44}/fleet/_async/resources/sqlite.py

@@ -1,4 +1,4 @@
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Dict, Tuple
 from ...instance.models import Resource as ResourceModel
 from ...instance.models import DescribeResponse, QueryRequest, QueryResponse
 from .base import Resource
@@ -25,12 +25,12 @@ from fleet.verifiers.db import (
 class AsyncDatabaseSnapshot:
     """Async database snapshot that fetches data through API and stores locally for diffing."""
 
-    def __init__(self, resource: "AsyncSQLiteResource", name: str | None = None):
+    def __init__(self, resource: "AsyncSQLiteResource", name: Optional[str] = None):
         self.resource = resource
         self.name = name or f"snapshot_{datetime.utcnow().isoformat()}"
         self.created_at = datetime.utcnow()
-        self._data: dict[str, list[dict[str, Any]]] = {}
-        self._schemas: dict[str, list[str]] = {}
+        self._data: Dict[str, List[Dict[str, Any]]] = {}
+        self._schemas: Dict[str, List[str]] = {}
         self._fetched = False
 
     async def _ensure_fetched(self):
@@ -69,7 +69,7 @@ class AsyncDatabaseSnapshot:
 
         self._fetched = True
 
-    async def tables(self) -> list[str]:
+    async def tables(self) -> List[str]:
         """Get list of all tables in the snapshot."""
         await self._ensure_fetched()
         return list(self._data.keys())
@@ -81,7 +81,7 @@ class AsyncDatabaseSnapshot:
     async def diff(
         self,
         other: "AsyncDatabaseSnapshot",
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ) -> "AsyncSnapshotDiff":
         """Compare this snapshot with another."""
         await self._ensure_fetched()
@@ -95,13 +95,13 @@ class AsyncSnapshotQueryBuilder:
     def __init__(self, snapshot: AsyncDatabaseSnapshot, table: str):
         self._snapshot = snapshot
         self._table = table
-        self._select_cols: list[str] = ["*"]
-        self._conditions: list[tuple[str, str, Any]] = []
-        self._limit: int | None = None
-        self._order_by: str | None = None
+        self._select_cols: List[str] = ["*"]
+        self._conditions: List[Tuple[str, str, Any]] = []
+        self._limit: Optional[int] = None
+        self._order_by: Optional[str] = None
         self._order_desc: bool = False
 
-    async def _get_data(self) -> list[dict[str, Any]]:
+    async def _get_data(self) -> List[Dict[str, Any]]:
         """Get table data from snapshot."""
         await self._snapshot._ensure_fetched()
         return self._snapshot._data.get(self._table, [])
@@ -122,11 +122,11 @@ class AsyncSnapshotQueryBuilder:
         qb._order_desc = desc
         return qb
 
-    async def first(self) -> dict[str, Any] | None:
+    async def first(self) -> Optional[Dict[str, Any]]:
         rows = await self.all()
         return rows[0] if rows else None
 
-    async def all(self) -> list[dict[str, Any]]:
+    async def all(self) -> List[Dict[str, Any]]:
         data = await self._get_data()
 
         # Apply filters
@@ -185,14 +185,14 @@ class AsyncSnapshotDiff:
         self,
         before: AsyncDatabaseSnapshot,
         after: AsyncDatabaseSnapshot,
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ):
         self.before = before
         self.after = after
         self.ignore_config = ignore_config or IgnoreConfig()
-        self._cached: dict[str, Any] | None = None
+        self._cached: Optional[Dict[str, Any]] = None
 
-    async def _get_primary_key_columns(self, table: str) -> list[str]:
+    async def _get_primary_key_columns(self, table: str) -> List[str]:
         """Get primary key columns for a table."""
         # Try to get from schema
         schema_response = await self.after.resource.query(f"PRAGMA table_info({table})")
@@ -222,7 +222,7 @@ class AsyncSnapshotDiff:
             return self._cached
 
         all_tables = set(await self.before.tables()) | set(await self.after.tables())
-        diff: dict[str, dict[str, Any]] = {}
+        diff: Dict[str, Dict[str, Any]] = {}
 
         for tbl in all_tables:
             if self.ignore_config.should_ignore_table(tbl):
@@ -236,7 +236,7 @@ class AsyncSnapshotDiff:
             after_data = self.after._data.get(tbl, [])
 
             # Create indexes by primary key
-            def make_key(row: dict, pk_cols: list[str]) -> Any:
+            def make_key(row: dict, pk_cols: List[str]) -> Any:
                 if len(pk_cols) == 1:
                     return row.get(pk_cols[0])
                 return tuple(row.get(col) for col in pk_cols)
@@ -304,12 +304,12 @@ class AsyncSnapshotDiff:
         self._cached = diff
         return diff
 
-    async def expect_only(self, allowed_changes: list[dict[str, Any]]):
+    async def expect_only(self, allowed_changes: List[Dict[str, Any]]):
         """Ensure only specified changes occurred."""
         diff = await self._collect()
 
         def _is_change_allowed(
-            table: str, row_id: Any, field: str | None, after_value: Any
+            table: str, row_id: Any, field: Optional[str], after_value: Any
         ) -> bool:
             """Check if a change is in the allowed list using semantic comparison."""
             for allowed in allowed_changes:
@@ -440,11 +440,11 @@ class AsyncQueryBuilder:
     def __init__(self, resource: "AsyncSQLiteResource", table: str):
         self._resource = resource
         self._table = table
-        self._select_cols: list[str] = ["*"]
-        self._conditions: list[tuple[str, str, Any]] = []
-        self._joins: list[tuple[str, dict[str, str]]] = []
-        self._limit: int | None = None
-        self._order_by: str | None = None
+        self._select_cols: List[str] = ["*"]
+        self._conditions: List[Tuple[str, str, Any]] = []
+        self._joins: List[Tuple[str, Dict[str, str]]] = []
+        self._limit: Optional[int] = None
+        self._order_by: Optional[str] = None
 
     # Column projection / limiting / ordering
     def select(self, *columns: str) -> "AsyncQueryBuilder":
@@ -486,12 +486,12 @@ class AsyncQueryBuilder:
     def lte(self, column: str, value: Any) -> "AsyncQueryBuilder":
         return self._add_condition(column, "<=", value)
 
-    def in_(self, column: str, values: list[Any]) -> "AsyncQueryBuilder":
+    def in_(self, column: str, values: List[Any]) -> "AsyncQueryBuilder":
         qb = self._clone()
         qb._conditions.append((column, "IN", tuple(values)))
         return qb
 
-    def not_in(self, column: str, values: list[Any]) -> "AsyncQueryBuilder":
+    def not_in(self, column: str, values: List[Any]) -> "AsyncQueryBuilder":
         qb = self._clone()
         qb._conditions.append((column, "NOT IN", tuple(values)))
         return qb
@@ -508,16 +508,16 @@ class AsyncQueryBuilder:
         return qb
 
     # JOIN
-    def join(self, other_table: str, on: dict[str, str]) -> "AsyncQueryBuilder":
+    def join(self, other_table: str, on: Dict[str, str]) -> "AsyncQueryBuilder":
         qb = self._clone()
         qb._joins.append((other_table, on))
         return qb
 
     # Compile to SQL
-    def _compile(self) -> tuple[str, list[Any]]:
+    def _compile(self) -> Tuple[str, List[Any]]:
         cols = ", ".join(self._select_cols)
         sql = [f"SELECT {cols} FROM {self._table}"]
-        params: list[Any] = []
+        params: List[Any] = []
 
         # Joins
         for tbl, onmap in self._joins:
@@ -558,11 +558,11 @@ class AsyncQueryBuilder:
             return row_dict.get("__cnt__", 0)
         return 0
 
-    async def first(self) -> dict[str, Any] | None:
+    async def first(self) -> Optional[Dict[str, Any]]:
         rows = await self.limit(1).all()
         return rows[0] if rows else None
 
-    async def all(self) -> list[dict[str, Any]]:
+    async def all(self) -> List[Dict[str, Any]]:
         sql, params = self._compile()
         response = await self._resource.query(sql, params)
         if not response.rows:
@@ -674,7 +674,7 @@ class AsyncSQLiteResource(Resource):
         """Create a query builder for the specified table."""
         return AsyncQueryBuilder(self, table_name)
 
-    async def snapshot(self, name: str | None = None) -> AsyncDatabaseSnapshot:
+    async def snapshot(self, name: Optional[str] = None) -> AsyncDatabaseSnapshot:
         """Create a snapshot of the current database state."""
         snapshot = AsyncDatabaseSnapshot(self, name)
         await snapshot._ensure_fetched()
@@ -683,7 +683,7 @@ class AsyncSQLiteResource(Resource):
     async def diff(
         self,
         other: "AsyncSQLiteResource",
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ) -> AsyncSnapshotDiff:
         """Compare this database with another AsyncSQLiteResource.
 

{fleet_python-0.2.43 → fleet_python-0.2.44}/fleet/_async/tasks.py

@@ -44,7 +44,7 @@ class Task(BaseModel):
     @property
     def env_key(self) -> str:
         """Get the environment key combining env_id and version."""
-        if self.version and self.version != "None":
+        if self.version and self.version != "None" and ":" not in self.env_id:
             return f"{self.env_id}:{self.version}"
         return self.env_id
 
@@ -174,6 +174,18 @@ def verifier_from_string(
         raise ValueError(f"Failed to create verifier from string: {e}")
 
 
+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")
+    """
+    from .global_client import get_client
+
+    client = get_client()
+    return await client.load_tasks_from_file(filename)
+
+
 async def load_tasks(
     env_key: Optional[str] = None,
     keys: Optional[List[str]] = None,

{fleet_python-0.2.43 → fleet_python-0.2.44}/fleet/_async/verifiers/verifier.py

@@ -12,7 +12,7 @@ import uuid
 import logging
 import hashlib
 import asyncio
-from typing import Any, Callable, Dict, Optional, List, TypeVar, Set
+from typing import Any, Callable, Dict, Optional, List, TypeVar, Set, Tuple
 
 from .bundler import FunctionBundler
 from ..client import AsyncEnv
@@ -56,7 +56,7 @@ class AsyncVerifierFunction:
         # Copy function metadata
         functools.update_wrapper(self, func)
 
-    def _get_or_create_bundle(self) -> tuple[bytes, str]:
+    def _get_or_create_bundle(self) -> Tuple[bytes, str]:
         """Get or create bundle data and return (bundle_data, sha)."""
         if self._bundle_data is None or self._bundle_sha is None:
             # If we have raw code, create a bundle from it
@@ -98,7 +98,7 @@ class AsyncVerifierFunction:
 
         return self._bundle_data, self._bundle_sha
 
-    async def _check_bundle_status(self, env: AsyncEnv) -> tuple[str, bool]:
+    async def _check_bundle_status(self, env: AsyncEnv) -> Tuple[str, bool]:
         """Check if bundle needs to be uploaded and return (sha, needs_upload)."""
         bundle_data, bundle_sha = self._get_or_create_bundle()
 

{fleet_python-0.2.43 → fleet_python-0.2.44}/fleet/client.py

@@ -130,7 +130,7 @@ class SyncEnv(EnvironmentBase):
         return self.instance.verify(validator)
 
     def verify_raw(
-        self, function_code: str, function_name: str | None = None
+        self, function_code: str, function_name: Optional[str] = None
     ) -> ExecuteFunctionResponse:
         return self.instance.verify_raw(function_code, function_name)
 
@@ -302,10 +302,19 @@ class Fleet:
 
         return self.load_task_array_from_string(tasks_data)
 
-    def load_task_array_from_string(self, serialized_tasks: List[Dict]) -> List[Task]:
+    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)
             tasks.append(parsed_task)
@@ -316,25 +325,47 @@ class Fleet:
         return self.load_task_from_json(task_json)
 
     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"]:
+            if verifier_id and verifier_code:
                 verifier = self._create_verifier_from_data(
-                    verifier_id=task_json["verifier_id"],
-                    verifier_key=task_json["key"],
-                    verifier_code=task_json["verifier_func"],
+                    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
         )
@@ -636,7 +667,7 @@ class Fleet:
             AsyncVerifierFunction created from the verifier code
         """
         # Fetch verifier from API
-        response = self.client.request("GET", f"/v1/verifier/{verifier_id}")
+        response = self.client.request("GET", f"/v1/verifiers/{verifier_id}")
         verifier_data = response.json()
 
         # Use the common method to create verifier

{fleet_python-0.2.43 → fleet_python-0.2.44}/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
         )
@@ -108,7 +106,7 @@ class InstanceClient:
         return self.verify_raw(function_code, function_name)
 
     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)