fleet-python 0.2.20__py3-none-any.whl → 0.2.22__py3-none-any.whl

examples/dsl_example.py

@@ -68,7 +68,7 @@ def validate_new_deal_creation(
 async def main():
     # Create a new instance
     print("Creating new Hubspot instance...")
-    env = await flt.env.make_async("hubspot:v1.2.7")
+    env = await flt.env.make_async("hubspot")
     print(f"New Instance: {env.instance_id}")
 
     try:
@@ -85,6 +85,7 @@ async def main():
         print(f"Message: {response.message}")
 
         # Get the database resource
+        await env.instance.load()
         db = env.db()
         
         # Take a snapshot before insertion

fleet/__init__.py

@@ -24,7 +24,7 @@ from .exceptions import (
 )
 from .client import Fleet, Environment
 from ._async.client import AsyncFleet, AsyncEnv
-from .models import InstanceRecord
+from .models import InstanceResponse
 from .instance.models import Resource, ResetResponse
 
 # Import sync verifiers with explicit naming
@@ -34,6 +34,7 @@ from .verifiers import (
     DatabaseSnapshot,
     IgnoreConfig,
     SnapshotDiff,
+    TASK_FAILED_SCORE,
     TASK_SUCCESSFUL_SCORE,
 )
 
@@ -80,6 +81,7 @@ __all__ = [
     "DatabaseSnapshot",
     "IgnoreConfig", 
     "SnapshotDiff",
+    "TASK_FAILED_SCORE",
     "TASK_SUCCESSFUL_SCORE",
     # Environment module
     "env",

fleet/_async/client.py

@@ -24,12 +24,13 @@ from typing import List, Optional, Dict
 from .base import EnvironmentBase, AsyncWrapper
 from ..models import (
     InstanceRequest,
-    InstanceRecord,
+    InstanceResponse,
     Environment as EnvironmentModel,
     VerifiersCheckResponse,
-    VerificationResponse,
     VerifiersExecuteResponse,
+    TaskListResponse,
 )
+from .tasks import Task
 
 from .instance import (
     AsyncInstanceClient,
@@ -102,14 +103,14 @@ class AsyncEnv(EnvironmentBase):
     async def resources(self) -> List[Resource]:
         return await self.instance.resources()
 
-    async def close(self) -> InstanceRecord:
+    async def close(self) -> InstanceResponse:
         return await _delete_instance(self._load_client, self.instance_id)
 
     async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return await self.instance.verify(validator)
 
     async def verify_raw(
-        self, function_code: str, function_name: str
+        self, function_code: str, function_name: str | None = None
     ) -> ExecuteFunctionResponse:
         return await self.instance.verify_raw(function_code, function_name)
 
@@ -152,12 +153,14 @@ class AsyncEnv(EnvironmentBase):
 class AsyncFleet:
     def __init__(
         self,
-        api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
+        api_key: Optional[str] = None,
         base_url: Optional[str] = None,
         httpx_client: Optional[httpx.AsyncClient] = None,
         max_retries: int = DEFAULT_MAX_RETRIES,
         timeout: float = DEFAULT_TIMEOUT,
     ):
+        if api_key is None:
+            api_key = os.getenv("FLEET_API_KEY")
         self._httpx_client = httpx_client or default_httpx_client(max_retries, timeout)
         self.client = AsyncWrapper(
             api_key=api_key,
@@ -182,13 +185,13 @@ class AsyncFleet:
     ) -> AsyncEnv:
         if ":" in env_key:
             env_key_part, version = env_key.split(":", 1)
-            if not version.startswith("v"):
+            if not version.startswith("v") and len(version) != 0 and version[0].isdigit():
                 version = f"v{version}"
         else:
             env_key_part = env_key
             version = None
 
-        request = InstanceRequest(env_key=env_key_part, version=version, region=region)
+        request = InstanceRequest(env_key=env_key_part, version=version, region=region, created_from="sdk")
         region_base_url = REGION_BASE_URL.get(region)
         response = await self.client.request(
             "POST",
@@ -231,14 +234,45 @@ class AsyncFleet:
             self.client, bundle_data, args, kwargs, timeout
         )
 
-    async def delete(self, instance_id: str) -> InstanceRecord:
+    async def delete(self, instance_id: str) -> InstanceResponse:
         return await _delete_instance(self.client, instance_id)
 
+    async def load_tasks(self, env_key: Optional[str] = None) -> List[Task]:
+        """Load tasks for the authenticated team, optionally filtered by environment.
+        
+        Args:
+            env_key: Optional environment key to filter tasks by
+            
+        Returns:
+            List[Task] containing Task objects
+        """
+        params = {}
+        if env_key is not None:
+            params["env_key"] = env_key
+            
+        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:
+            task = Task(
+                key=task_response.key,
+                prompt=task_response.prompt,
+                env_id=task_response.environment_id,  # Map environment_id -> env_id
+                created_at=task_response.created_at,
+                verifier=None,  # Keep blank for now as requested
+                metadata={}  # Default empty metadata
+            )
+            tasks.append(task)
+        
+        return tasks
+
 
 # Shared
-async def _delete_instance(client: AsyncWrapper, instance_id: str) -> InstanceRecord:
+async def _delete_instance(client: AsyncWrapper, instance_id: str) -> InstanceResponse:
     response = await client.request("DELETE", f"/v1/env/instances/{instance_id}")
-    return InstanceRecord(**response.json())
+    return InstanceResponse(**response.json())
 
 
 async def _check_bundle_exists(
@@ -258,7 +292,7 @@ async def _execute_verifier_remote(
     kwargs: dict,
     timeout: Optional[int] = 30,
     needs_upload: bool = True,
-) -> VerificationResponse:
+) -> VerifiersExecuteResponse:
     # Pickle args and kwargs together
     # The first arg should be None as a placeholder for env
     args_with_none = (None,) + args

fleet/_async/instance/client.py

@@ -12,6 +12,7 @@ from ..resources.browser import AsyncBrowserResource
 from ..resources.base import Resource
 
 from fleet.verifiers import DatabaseSnapshot
+from fleet.verifiers.parse import convert_verifier_string, extract_function_name
 
 from ..exceptions import FleetEnvironmentError
 from ...config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT
@@ -107,8 +108,16 @@ class AsyncInstanceClient:
         return await self.verify_raw(function_code, function_name)
 
     async def verify_raw(
-        self, function_code: str, function_name: str
+        self, function_code: str, function_name: str | None = None
     ) -> ExecuteFunctionResponse:
+        try:
+            function_code = convert_verifier_string(function_code)
+        except:
+            pass
+
+        if function_name is None:
+            function_name = extract_function_name(function_code)
+
         response = await self.client.request(
             "POST",
             "/execute_verifier_function",

fleet/_async/models.py

@@ -0,0 +1,321 @@
+# generated by datamodel-codegen:
+#   filename:  https://orchestrator.fleetai.com/openapi.json
+#   timestamp: 2025-08-03T22:47:20+00:00
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, Field, conint
+
+
+class CDPDescribeResponse(BaseModel):
+    success: bool = Field(..., title='Success')
+    url: str = Field(..., title='Url')
+    devtools_url: str = Field(..., title='Devtools Url')
+
+
+class ChromeStartRequest(BaseModel):
+    start_page: Optional[str] = Field('about:blank', title='Start Page')
+    resolution: Optional[str] = Field('1920x1080', title='Resolution')
+
+
+class ChromeStartResponse(BaseModel):
+    success: bool = Field(..., title='Success')
+    message: str = Field(..., title='Message')
+
+
+class ChromeStatusResponse(BaseModel):
+    running: bool = Field(..., title='Running')
+    message: str = Field(..., title='Message')
+
+
+class Environment(BaseModel):
+    env_key: str = Field(..., title='Env Key')
+    name: str = Field(..., title='Name')
+    description: Optional[str] = Field(..., title='Description')
+    default_version: Optional[str] = Field(..., title='Default Version')
+    versions: Dict[str, str] = Field(..., title='Versions')
+
+
+class Instance(BaseModel):
+    instance_id: str = Field(..., title='Instance Id')
+    env_key: str = Field(..., title='Env Key')
+    version: str = Field(..., title='Version')
+    status: str = Field(..., title='Status')
+    subdomain: str = Field(..., title='Subdomain')
+    created_at: str = Field(..., title='Created At')
+    updated_at: str = Field(..., title='Updated At')
+    terminated_at: Optional[str] = Field(None, title='Terminated At')
+    team_id: str = Field(..., title='Team Id')
+    region: str = Field(..., title='Region')
+    env_variables: Optional[Dict[str, Any]] = Field(None, title='Env Variables')
+
+
+class InstanceRequest(BaseModel):
+    env_key: str = Field(..., title='Env Key')
+    version: Optional[str] = Field(None, title='Version')
+    region: Optional[str] = Field('us-west-1', title='Region')
+    seed: Optional[int] = Field(None, title='Seed')
+    timestamp: Optional[int] = Field(None, title='Timestamp')
+    p_error: Optional[float] = Field(None, title='P Error')
+    avg_latency: Optional[float] = Field(None, title='Avg Latency')
+    run_id: Optional[str] = Field(None, title='Run Id')
+    task_id: Optional[str] = Field(None, title='Task Id')
+    force_pull: Optional[bool] = Field(None, title='Force Pull')
+    env_variables: Optional[Dict[str, Any]] = Field(None, title='Env Variables')
+    created_from: Optional[str] = Field(None, title='Created From')
+
+
+class InstanceStatus(Enum):
+    pending = 'pending'
+    running = 'running'
+    stopped = 'stopped'
+    error = 'error'
+
+
+class ManagerURLs(BaseModel):
+    api: str = Field(..., title='Api')
+    docs: str = Field(..., title='Docs')
+    reset: str = Field(..., title='Reset')
+    diff: str = Field(..., title='Diff')
+    snapshot: str = Field(..., title='Snapshot')
+    execute_verifier_function: str = Field(..., title='Execute Verifier Function')
+    execute_verifier_function_with_upload: str = Field(
+        ..., title='Execute Verifier Function With Upload'
+    )
+
+
+class QueryRequest(BaseModel):
+    query: str = Field(..., title='Query')
+    args: Optional[List] = Field(None, title='Args')
+    read_only: Optional[bool] = Field(True, title='Read Only')
+
+
+class QueryResponse(BaseModel):
+    success: bool = Field(..., title='Success')
+    columns: Optional[List[str]] = Field(None, title='Columns')
+    rows: Optional[List[List]] = Field(None, title='Rows')
+    rows_affected: Optional[int] = Field(None, title='Rows Affected')
+    last_insert_id: Optional[int] = Field(None, title='Last Insert Id')
+    error: Optional[str] = Field(None, title='Error')
+    message: str = Field(..., title='Message')
+
+
+class RecreateResponse(BaseModel):
+    success: bool = Field(..., title='Success')
+    instance_id: str = Field(..., title='Instance Id')
+    env_key: str = Field(..., title='Env Key')
+    version: str = Field(..., title='Version')
+    recreated_at: str = Field(..., title='Recreated At')
+
+
+class ResourceMode(Enum):
+    ro = 'ro'
+    rw = 'rw'
+
+
+class ResourceType(Enum):
+    sqlite = 'sqlite'
+    cdp = 'cdp'
+
+
+class RestoreRequest(BaseModel):
+    backup_id: Optional[str] = Field(None, title='Backup Id')
+
+
+class RestoreResponse(BaseModel):
+    success: bool = Field(..., title='Success')
+    backup_id: str = Field(..., title='Backup Id')
+    source_instance_id: str = Field(..., title='Source Instance Id')
+    target_instance_id: str = Field(..., title='Target Instance Id')
+    restored_at: str = Field(..., title='Restored At')
+
+
+class SnapshotResponse(BaseModel):
+    success: bool = Field(..., title='Success')
+    backup_id: str = Field(..., title='Backup Id')
+    instance_id: str = Field(..., title='Instance Id')
+    s3_key: str = Field(..., title='S3 Key')
+    created_at: str = Field(..., title='Created At')
+
+
+class TableSchema(BaseModel):
+    name: str = Field(..., title='Name')
+    sql: str = Field(..., title='Sql')
+    columns: List[Dict[str, Any]] = Field(..., title='Columns')
+
+
+class TaskRequest(BaseModel):
+    key: str = Field(..., title='Key')
+    prompt: str = Field(..., title='Prompt')
+    environment_id: str = Field(..., title='Environment Id')
+    verifier_id: Optional[str] = Field(None, title='Verifier Id')
+
+
+class TaskResponse(BaseModel):
+    key: str = Field(..., title='Key')
+    prompt: str = Field(..., title='Prompt')
+    team_id: str = Field(..., title='Team Id')
+    environment_id: str = Field(..., title='Environment Id')
+    created_at: str = Field(..., title='Created At')
+    verifier_id: Optional[str] = Field(None, title='Verifier Id')
+
+
+class ValidationError(BaseModel):
+    loc: List[Union[str, int]] = Field(..., title='Location')
+    msg: str = Field(..., title='Message')
+    type: str = Field(..., title='Error Type')
+
+
+class VerifiersCheckResponse(BaseModel):
+    key: Optional[str] = Field(
+        None, description='Key of the verifier artifact', title='Key'
+    )
+    version: Optional[int] = Field(
+        None, description='Version of the verifier artifact', title='Version'
+    )
+    display_src: Optional[str] = Field(
+        None, description='Display source code of the verifier', title='Display Src'
+    )
+    created_at: Optional[str] = Field(
+        None, description='Creation timestamp', title='Created At'
+    )
+    comment: Optional[str] = Field(
+        None, description='Comment about the verifier', title='Comment'
+    )
+    success: bool = Field(
+        ..., description='Whether the verification was successful', title='Success'
+    )
+
+
+class VerifiersExecuteRequest(BaseModel):
+    key: Optional[str] = Field(
+        None, description='Key of the verifier artifact', title='Key'
+    )
+    sha256: Optional[str] = Field(
+        None,
+        description='SHA256 hash of the function (auto-generated if bundle is provided)',
+        title='Sha256',
+    )
+    bundle: Optional[str] = Field(
+        None, description='Base64 encoded bundle data', title='Bundle'
+    )
+    args: Optional[str] = Field(
+        None, description='Base64 encoded cloudpickled args', title='Args'
+    )
+    args_array: Optional[List] = Field(
+        None,
+        description='Array of argument values to pass to the function',
+        title='Args Array',
+    )
+    function_name: Optional[str] = Field(
+        'verify', description='Name of the function to execute', title='Function Name'
+    )
+    timeout: Optional[conint(ge=1, le=300)] = Field(
+        60, description='Execution timeout in seconds', title='Timeout'
+    )
+    region: Optional[str] = Field(
+        None, description='AWS region for execution', title='Region'
+    )
+    metadata: Optional[Dict[str, Any]] = Field(
+        None, description='Additional metadata', title='Metadata'
+    )
+    comment: Optional[str] = Field(
+        None, description='Comment about the function', title='Comment'
+    )
+    display_src: Optional[str] = Field(
+        None, description='Display source code', title='Display Src'
+    )
+
+
+class VerifiersExecuteResponse(BaseModel):
+    key: Optional[str] = Field(
+        None, description='Key of the verifier artifact', title='Key'
+    )
+    version: Optional[int] = Field(
+        None, description='Version of the verifier artifact', title='Version'
+    )
+    display_src: Optional[str] = Field(
+        None, description='Display source code of the verifier', title='Display Src'
+    )
+    created_at: Optional[str] = Field(
+        None, description='Creation timestamp', title='Created At'
+    )
+    comment: Optional[str] = Field(
+        None, description='Comment about the verifier', title='Comment'
+    )
+    success: bool = Field(
+        ..., description='Whether the verification was successful', title='Success'
+    )
+    result: Optional[Any] = Field(
+        None, description='The return value of the function', title='Result'
+    )
+    error: Optional[Dict[str, Any]] = Field(
+        None, description='Error details if verification failed', title='Error'
+    )
+    execution_time_ms: int = Field(
+        ..., description='Execution time in milliseconds', title='Execution Time Ms'
+    )
+    bundle_cache_hit: Optional[bool] = Field(
+        False,
+        description='Whether the bundle was already cached',
+        title='Bundle Cache Hit',
+    )
+    stdout: Optional[str] = Field(
+        None, description='Captured stdout from execution', title='Stdout'
+    )
+
+
+class DescribeResponse(BaseModel):
+    success: bool = Field(..., title='Success')
+    resource_name: str = Field(..., title='Resource Name')
+    tables: Optional[List[TableSchema]] = Field(None, title='Tables')
+    error: Optional[str] = Field(None, title='Error')
+    message: str = Field(..., title='Message')
+
+
+class HTTPValidationError(BaseModel):
+    detail: Optional[List[ValidationError]] = Field(None, title='Detail')
+
+
+class InstanceURLs(BaseModel):
+    root: str = Field(..., title='Root')
+    app: List[str] = Field(..., title='App')
+    api: Optional[str] = Field(None, title='Api')
+    health: Optional[str] = Field(None, title='Health')
+    api_docs: Optional[str] = Field(None, title='Api Docs')
+    manager: ManagerURLs
+
+
+class Resource(BaseModel):
+    name: str = Field(..., title='Name')
+    type: ResourceType
+    mode: ResourceMode
+    label: Optional[str] = Field(None, title='Label')
+
+
+class ResourcesResponse(BaseModel):
+    resources: List[Resource] = Field(..., title='Resources')
+
+
+class TaskListResponse(BaseModel):
+    tasks: List[TaskResponse] = Field(..., title='Tasks')
+    total: int = Field(..., title='Total')
+
+
+class InstanceResponse(BaseModel):
+    instance_id: str = Field(..., title='Instance Id')
+    env_key: str = Field(..., title='Env Key')
+    version: str = Field(..., title='Version')
+    status: str = Field(..., title='Status')
+    subdomain: str = Field(..., title='Subdomain')
+    created_at: str = Field(..., title='Created At')
+    updated_at: str = Field(..., title='Updated At')
+    terminated_at: Optional[str] = Field(None, title='Terminated At')
+    team_id: str = Field(..., title='Team Id')
+    region: str = Field(..., title='Region')
+    env_variables: Optional[Dict[str, Any]] = Field(None, title='Env Variables')
+    urls: InstanceURLs
+    health: Optional[bool] = Field(None, title='Health')

fleet/_async/resources/sqlite.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 
 
 # Import types from verifiers module
-from ...verifiers.db import IgnoreConfig, _get_row_identifier, _format_row_for_error, _values_equivalent
+from fleet.verifiers.db import IgnoreConfig, _get_row_identifier, _format_row_for_error, _values_equivalent
 
 
 class AsyncDatabaseSnapshot:

fleet/_async/verifiers/verifier.py

@@ -12,8 +12,7 @@ import uuid
 import logging
 import hashlib
 import asyncio
-import inspect
-from typing import Any, Callable, Dict, Optional, List, TypeVar, Set, Union
+from typing import Any, Callable, Dict, Optional, List, TypeVar, Set
 
 from .bundler import FunctionBundler
 from ..client import AsyncEnv
@@ -44,7 +43,6 @@ class AsyncVerifierFunction:
     ):
         self.func = func
         self.key = key
-        self.name = key  # Keep name for backward compatibility
         self.verifier_id = verifier_id or str(uuid.uuid4())
         self.extra_requirements = extra_requirements or []
         self._bundler = FunctionBundler()
@@ -65,7 +63,7 @@ class AsyncVerifierFunction:
                 self.verifier_id
             )
             self._bundle_sha = _get_bundle_sha(self._bundle_data)
-            logger.debug(f"Created bundle for {self.name} with SHA: {self._bundle_sha}")
+            logger.debug(f"Created bundle for {self.key} with SHA: {self._bundle_sha}")
         
         return self._bundle_data, self._bundle_sha
     
@@ -118,7 +116,7 @@ class AsyncVerifierFunction:
                     raise ValueError(f"Verifier function must return a score (number). Got {type(result)}")
                     
         except Exception as e:
-            logger.error(f"Error in verifier {self.name}: {e}")
+            logger.error(f"Error in verifier {self.key}: {e}")
             # Return error score 0
             return 0.0
     
@@ -126,7 +124,7 @@ class AsyncVerifierFunction:
         """Remote execution of the verifier function with SHA-based bundle caching."""
         if self._is_async:
             raise NotImplementedError(
-                f"Async verifier '{self.name}' cannot be executed remotely. "
+                f"Async verifier '{self.key}' cannot be executed remotely. "
                 "The remote execution environment only supports synchronous functions. "
                 "Please provide a synchronous version of your verifier."
             )