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

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/_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" and ":" not in self.env_id:
             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,67 +119,78 @@ 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}")
 
 
+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,
     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,17 +210,12 @@ 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
+    task_key: str, prompt: Optional[str] = None, verifier_code: Optional[str] = None
 ):
     """Convenience function to update an existing task.
 
@@ -228,11 +232,8 @@ async def update_task(
         response = await 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 await client.update_task(
-        task_key=task_key,
-        prompt=prompt,
-        verifier_code=verifier_code
+        task_key=task_key, prompt=prompt, verifier_code=verifier_code
     )

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