fleet-python 0.2.42__py3-none-any.whl → 0.2.44__py3-none-any.whl

fleet/client.py

@@ -16,6 +16,7 @@
 
 import base64
 import cloudpickle
+import concurrent.futures
 import httpx
 import json
 import logging
@@ -129,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)
 
@@ -206,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",
@@ -286,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)
@@ -300,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
         )
@@ -353,48 +400,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,
@@ -503,7 +609,7 @@ class Fleet:
         self,
         task_key: str,
         prompt: Optional[str] = None,
-        verifier_code: Optional[str] = None
+        verifier_code: Optional[str] = None,
     ) -> TaskResponse:
         """Update an existing task.
 
@@ -515,10 +621,7 @@ class Fleet:
         Returns:
             TaskResponse containing the updated task details
         """
-        payload = TaskUpdateRequest(
-            prompt=prompt,
-            verifier_code=verifier_code
-        )
+        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)
         )
@@ -564,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/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/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)

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")

fleet/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 SyncDatabaseSnapshot:
     """Async database snapshot that fetches data through API and stores locally for diffing."""
 
-    def __init__(self, resource: "SQLiteResource", name: str | None = None):
+    def __init__(self, resource: "SQLiteResource", 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
 
     def _ensure_fetched(self):
@@ -69,7 +69,7 @@ class SyncDatabaseSnapshot:
 
         self._fetched = True
 
-    def tables(self) -> list[str]:
+    def tables(self) -> List[str]:
         """Get list of all tables in the snapshot."""
         self._ensure_fetched()
         return list(self._data.keys())
@@ -81,7 +81,7 @@ class SyncDatabaseSnapshot:
     def diff(
         self,
         other: "SyncDatabaseSnapshot",
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ) -> "SyncSnapshotDiff":
         """Compare this snapshot with another."""
         self._ensure_fetched()
@@ -95,13 +95,13 @@ class SyncSnapshotQueryBuilder:
     def __init__(self, snapshot: SyncDatabaseSnapshot, 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
 
-    def _get_data(self) -> list[dict[str, Any]]:
+    def _get_data(self) -> List[Dict[str, Any]]:
         """Get table data from snapshot."""
         self._snapshot._ensure_fetched()
         return self._snapshot._data.get(self._table, [])
@@ -122,11 +122,11 @@ class SyncSnapshotQueryBuilder:
         qb._order_desc = desc
         return qb
 
-    def first(self) -> dict[str, Any] | None:
+    def first(self) -> Optional[Dict[str, Any]]:
         rows = self.all()
         return rows[0] if rows else None
 
-    def all(self) -> list[dict[str, Any]]:
+    def all(self) -> List[Dict[str, Any]]:
         data = self._get_data()
 
         # Apply filters
@@ -185,14 +185,14 @@ class SyncSnapshotDiff:
         self,
         before: SyncDatabaseSnapshot,
         after: SyncDatabaseSnapshot,
-        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
 
-    def _get_primary_key_columns(self, table: str) -> list[str]:
+    def _get_primary_key_columns(self, table: str) -> List[str]:
         """Get primary key columns for a table."""
         # Try to get from schema
         schema_response = self.after.resource.query(f"PRAGMA table_info({table})")
@@ -222,7 +222,7 @@ class SyncSnapshotDiff:
             return self._cached
 
         all_tables = set(self.before.tables()) | set(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 SyncSnapshotDiff:
             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 SyncSnapshotDiff:
         self._cached = diff
         return diff
 
-    def expect_only(self, allowed_changes: list[dict[str, Any]]):
+    def expect_only(self, allowed_changes: List[Dict[str, Any]]):
         """Ensure only specified changes occurred."""
         diff = 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 SyncQueryBuilder:
     def __init__(self, resource: "SQLiteResource", 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) -> "SyncQueryBuilder":
@@ -486,12 +486,12 @@ class SyncQueryBuilder:
     def lte(self, column: str, value: Any) -> "SyncQueryBuilder":
         return self._add_condition(column, "<=", value)
 
-    def in_(self, column: str, values: list[Any]) -> "SyncQueryBuilder":
+    def in_(self, column: str, values: List[Any]) -> "SyncQueryBuilder":
         qb = self._clone()
         qb._conditions.append((column, "IN", tuple(values)))
         return qb
 
-    def not_in(self, column: str, values: list[Any]) -> "SyncQueryBuilder":
+    def not_in(self, column: str, values: List[Any]) -> "SyncQueryBuilder":
         qb = self._clone()
         qb._conditions.append((column, "NOT IN", tuple(values)))
         return qb
@@ -508,16 +508,16 @@ class SyncQueryBuilder:
         return qb
 
     # JOIN
-    def join(self, other_table: str, on: dict[str, str]) -> "SyncQueryBuilder":
+    def join(self, other_table: str, on: Dict[str, str]) -> "SyncQueryBuilder":
         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 SyncQueryBuilder:
             return row_dict.get("__cnt__", 0)
         return 0
 
-    def first(self) -> dict[str, Any] | None:
+    def first(self) -> Optional[Dict[str, Any]]:
         rows = self.limit(1).all()
         return rows[0] if rows else None
 
-    def all(self) -> list[dict[str, Any]]:
+    def all(self) -> List[Dict[str, Any]]:
         sql, params = self._compile()
         response = self._resource.query(sql, params)
         if not response.rows:
@@ -651,9 +651,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:
@@ -674,7 +672,7 @@ class SQLiteResource(Resource):
         """Create a query builder for the specified table."""
         return SyncQueryBuilder(self, table_name)
 
-    def snapshot(self, name: str | None = None) -> SyncDatabaseSnapshot:
+    def snapshot(self, name: Optional[str] = None) -> SyncDatabaseSnapshot:
         """Create a snapshot of the current database state."""
         snapshot = SyncDatabaseSnapshot(self, name)
         snapshot._ensure_fetched()
@@ -683,7 +681,7 @@ class SQLiteResource(Resource):
     def diff(
         self,
         other: "SQLiteResource",
-        ignore_config: IgnoreConfig | None = None,
+        ignore_config: Optional[IgnoreConfig] = None,
     ) -> SyncSnapshotDiff:
         """Compare this database with another AsyncSQLiteResource.
 
@@ -695,12 +693,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)