fleet-python 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

examples/query_builder_example.py

@@ -0,0 +1,117 @@
+import asyncio
+import fleet as flt
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+async def main():
+    # Create a new instance
+    print("Creating new Hubspot instance...")
+    env = await flt.env.make_async("hubspot:v1.2.7")
+    print(f"New Instance: {env.instance_id}")
+
+    try:
+        # Reset the instance
+        response = await env.reset(seed=42)
+        print(f"Reset response: {response}")
+
+        # Get the database resource
+        db = env.db()
+
+        # Example 1: Query with the builder pattern
+        print("\n=== Query Builder Examples ===")
+        
+        # Find all entries of type 'deal'
+        print("\n1. Finding all deals:")
+        deals = await db.table("entries").eq("type", "deal").all()
+        print(f"Found {len(deals)} deals")
+
+        # Count entries
+        print("\n2. Counting entries:")
+        entry_count = await db.table("entries").count()
+        print(f"Total entries: {entry_count}")
+
+        # Find a specific entry
+        print("\n3. Finding specific entry:")
+        entry = await db.table("entries").eq("id", 1).first()
+        if entry:
+            print(f"Found entry: {entry['name']} (type: {entry['type']})")
+
+        # Complex query with multiple conditions
+        print("\n4. Complex query with conditions:")
+        recent_deals = await (
+            db.table("entries")
+            .eq("type", "deal")
+            .not_null("name")
+            .select("id", "name", "type", "createdDate")
+            .sort("createdDate", desc=True)
+            .limit(5)
+            .all()
+        )
+        print(f"Recent deals: {len(recent_deals)}")
+        for deal in recent_deals:
+            print(f"  - {deal['name']} (id: {deal['id']})")
+
+        # Using assertions
+        print("\n5. Using assertions:")
+        try:
+            # This should succeed if there are entries
+            await db.table("entries").assert_exists()
+            print("✓ Entries table has records")
+        except AssertionError as e:
+            print(f"✗ Assertion failed: {e}")
+
+        # Check for non-existent record
+        try:
+            await db.table("entries").eq("id", 999999).assert_none()
+            print("✓ No entry with id 999999")
+        except AssertionError as e:
+            print(f"✗ Assertion failed: {e}")
+
+        # Insert a new entry and verify with query builder
+        print("\n6. Insert and verify with query builder:")
+        insert_query = """
+        INSERT INTO entries (id, name, type, owner_id, createdDate, lastModifiedDate, createdAt, updatedAt, properties)
+        VALUES (
+            99999,
+            'Test Deal via Query Builder',
+            'deal',
+            1,
+            datetime('now'),
+            datetime('now'),
+            datetime('now'),
+            datetime('now'),
+            '{}'
+        )
+        """
+        await db.exec(insert_query)
+        
+        # Verify insertion with query builder
+        new_deal = await db.table("entries").eq("id", 99999).first()
+        if new_deal:
+            print(f"✓ Successfully inserted: {new_deal['name']}")
+            
+            # Assert specific field value
+            await db.table("entries").eq("id", 99999).assert_eq("name", "Test Deal via Query Builder")
+            print("✓ Name assertion passed")
+
+        # Using IN clause
+        print("\n7. Using IN clause:")
+        specific_entries = await db.table("entries").in_("id", [1, 2, 3]).all()
+        print(f"Found {len(specific_entries)} entries with ids in [1, 2, 3]")
+
+        # Pattern matching with LIKE
+        print("\n8. Pattern matching:")
+        test_entries = await db.table("entries").ilike("name", "%test%").all()
+        print(f"Found {len(test_entries)} entries with 'test' in name")
+
+    finally:
+        # Delete the instance
+        print("\n\nDeleting instance...")
+        await env.close()
+        print("Instance deleted.")
+
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

fleet/__init__.py

@@ -23,60 +23,71 @@ from .exceptions import (
     FleetConfigurationError,
 )
 from .client import Fleet, Environment
-from ._async.client import AsyncFleet, AsyncEnvironment
-from .models import InstanceRequest
-from .instance import (
-    InstanceClient,
-    ResetRequest,
-    ResetResponse,
-    CDPDescribeResponse,
-    ChromeStartRequest,
-    ChromeStartResponse,
-    ChromeStatusResponse,
-)
-from ._async.instance import AsyncInstanceClient
+from ._async.client import AsyncFleet, AsyncEnv
+from .models import InstanceRecord
+from .instance.models import Resource, ResetResponse
+
+# Import sync verifiers with explicit naming
 from .verifiers import (
+    verifier as verifier_sync,
+    SyncVerifierFunction,
     DatabaseSnapshot,
     IgnoreConfig,
     SnapshotDiff,
     TASK_SUCCESSFUL_SCORE,
 )
+
+# Import Playwright wrapper
+from .playwright import FleetPlaywrightWrapper
+
+# Import async verifiers (default verifier is async for modern usage)
+from ._async.verifiers import (
+    verifier,
+    AsyncVerifierFunction,
+)
+
+# Import async tasks (default tasks are async for modern usage)
+from ._async.tasks import Task
+
+# Import shared types
+from .types import VerifierFunction
+
+# Create a module-level env attribute for convenient access
 from . import env
 
-# Optional playwright integration
-try:
-    from .playwright import FleetPlaywrightWrapper
-    _PLAYWRIGHT_AVAILABLE = True
-except ImportError:
-    FleetPlaywrightWrapper = None
-    _PLAYWRIGHT_AVAILABLE = False
+__version__ = "0.1.0"
 
-__version__ = "0.1.1"
 __all__ = [
-    "env",
-    "FleetError",
-    "FleetAPIError",
-    "FleetTimeoutError",
-    "FleetConfigurationError",
+    # Core classes
     "Fleet",
     "Environment",
     "AsyncFleet",
-    "AsyncEnvironment",
-    "InstanceClient",
-    "AsyncInstanceClient",
-    "InstanceRequest",
-    "ResetRequest",
+    "AsyncEnv",
+    # Models
+    "InstanceRecord", 
+    "Resource",
     "ResetResponse",
-    "CDPDescribeResponse",
-    "ChromeStartRequest",
-    "ChromeStartResponse",
-    "ChromeStatusResponse",
+    # Task models
+    "Task",
+    "VerifierFunction",
+    # Exceptions
+    "FleetError",
+    "FleetAPIError", 
+    "FleetTimeoutError",
+    "FleetConfigurationError",
+    # Playwright wrapper
+    "FleetPlaywrightWrapper",
+    # Verifiers (async is default)
+    "verifier",
+    "verifier_sync", 
+    "AsyncVerifierFunction",
+    "SyncVerifierFunction",
     "DatabaseSnapshot",
-    "IgnoreConfig",
+    "IgnoreConfig", 
     "SnapshotDiff",
     "TASK_SUCCESSFUL_SCORE",
-]
-
-# Add playwright wrapper to exports if available
-if _PLAYWRIGHT_AVAILABLE:
-    __all__.append("FleetPlaywrightWrapper")
+    # Environment module
+    "env",
+    # Version
+    "__version__",
+]

fleet/_async/base.py

@@ -1,8 +1,10 @@
 import httpx
 from typing import Dict, Any, Optional
 import json
+import logging
 
 from ..models import InstanceResponse
+from ..config import GLOBAL_BASE_URL
 from .exceptions import (
     FleetAPIError,
     FleetAuthenticationError,
@@ -18,6 +20,8 @@ from .exceptions import (
     FleetPermissionError,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class EnvironmentBase(InstanceResponse):
     @property
@@ -31,7 +35,7 @@ class BaseWrapper:
             raise ValueError("api_key is required")
         self.api_key = api_key
         if base_url is None:
-            base_url = "https://orchestrator.fleetai.com"
+            base_url = GLOBAL_BASE_URL
         self.base_url = base_url
 
     def get_headers(self) -> Dict[str, str]:
@@ -40,6 +44,10 @@ class BaseWrapper:
             "X-Fleet-SDK-Version": "1.0.0",
         }
         headers["Authorization"] = f"Bearer {self.api_key}"
+        # Debug log
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.debug(f"Headers being sent: {headers}")
         return headers
 
 
@@ -81,6 +89,11 @@ class AsyncWrapper(BaseWrapper):
     def _handle_error_response(self, response: httpx.Response) -> None:
         """Handle HTTP error responses and convert to appropriate Fleet exceptions."""
         status_code = response.status_code
+        
+        # Debug log 500 errors
+        if status_code == 500:
+            logger.error(f"Got 500 error from {response.url}")
+            logger.error(f"Response text: {response.text}")
 
         # Try to parse error response as JSON
         try:

fleet/_async/client.py

@@ -14,23 +14,32 @@
 
 """Fleet API Client for making HTTP requests to Fleet services."""
 
-import os
+import base64
+import cloudpickle
 import httpx
 import logging
-from typing import Optional, List
+import os
+from typing import List, Optional
 
 from .base import EnvironmentBase, AsyncWrapper
-from ..models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
+from ..models import (
+    InstanceRequest,
+    InstanceRecord,
+    Environment as EnvironmentModel,
+    VerifiersCheckResponse,
+    VerificationResponse,
+    VerifiersExecuteResponse,
+)
 
 from .instance import (
     AsyncInstanceClient,
     ResetRequest,
     ResetResponse,
-    ValidatorType,
     ExecuteFunctionResponse,
 )
 from ..config import DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT, REGION_BASE_URL
 from .instance.base import default_httpx_client
+from .instance.client import ValidatorType
 from .resources.base import Resource
 from .resources.sqlite import AsyncSQLiteResource
 from .resources.browser import AsyncBrowserResource
@@ -38,13 +47,8 @@ from .resources.browser import AsyncBrowserResource
 logger = logging.getLogger(__name__)
 
 
-async def _delete_instance(client: AsyncWrapper, instance_id: str) -> InstanceRecord:
-    response = await client.request("DELETE", f"/v1/env/instances/{instance_id}")
-    return InstanceRecord(**response.json())
-
-
-class AsyncEnvironment(EnvironmentBase):
-    def __init__(self, client: AsyncWrapper, **kwargs):
+class AsyncEnv(EnvironmentBase):
+    def __init__(self, client: Optional[AsyncWrapper], **kwargs):
         super().__init__(**kwargs)
         self._client = client
         self._instance: Optional[AsyncInstanceClient] = None
@@ -53,10 +57,16 @@ class AsyncEnvironment(EnvironmentBase):
     def instance(self) -> AsyncInstanceClient:
         if self._instance is None:
             self._instance = AsyncInstanceClient(
-                self.manager_url, self._client.httpx_client
+                self.manager_url, self._client.httpx_client if self._client else None
             )
         return self._instance
 
+    @property
+    def _load_client(self) -> AsyncWrapper:
+        if self._client is None:
+            raise ValueError("Client not initialized")
+        return self._client
+
     async def reset(
         self, seed: Optional[int] = None, timestamp: Optional[int] = None
     ) -> ResetResponse:
@@ -75,7 +85,7 @@ class AsyncEnvironment(EnvironmentBase):
         return await self.instance.resources()
 
     async def close(self) -> InstanceRecord:
-        return await _delete_instance(self._client, self.instance_id)
+        return await _delete_instance(self._load_client, self.instance_id)
 
     async def verify(self, validator: ValidatorType) -> ExecuteFunctionResponse:
         return await self.instance.verify(validator)
@@ -85,6 +95,41 @@ class AsyncEnvironment(EnvironmentBase):
     ) -> ExecuteFunctionResponse:
         return await self.instance.verify_raw(function_code, function_name)
 
+    async def check_bundle_exists(self, bundle_hash: str) -> VerifiersCheckResponse:
+        return await _check_bundle_exists(self._load_client, bundle_hash)
+
+    async def execute_verifier_remote(
+        self, 
+        bundle_data: bytes, 
+        bundle_sha: str,
+        key: str,
+        function_name: str,
+        args: tuple, 
+        kwargs: dict, 
+        timeout: Optional[int] = 30,
+        needs_upload: bool = True,
+    ) -> VerifiersExecuteResponse:
+        return await _execute_verifier_remote(
+            self._load_client, 
+            bundle_data, 
+            bundle_sha,
+            key,
+            function_name,
+            args, 
+            kwargs, 
+            timeout,
+            needs_upload
+        )
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop("_client", None)
+        state.pop("_instance", None)
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
 
 class AsyncFleet:
     def __init__(
@@ -116,7 +161,7 @@ class AsyncFleet:
 
     async def make(
         self, env_key: str, region: Optional[str] = None
-    ) -> AsyncEnvironment:
+    ) -> AsyncEnv:
         if ":" in env_key:
             env_key_part, version = env_key.split(":", 1)
             if not version.startswith("v"):
@@ -133,13 +178,13 @@ class AsyncFleet:
             json=request.model_dump(),
             base_url=region_base_url,
         )
-        instance = AsyncEnvironment(client=self.client, **response.json())
+        instance = AsyncEnv(client=self.client, **response.json())
         await instance.instance.load()
         return instance
 
     async def instances(
         self, status: Optional[str] = None, region: Optional[str] = None
-    ) -> List[AsyncEnvironment]:
+    ) -> List[AsyncEnv]:
         params = {}
         if status:
             params["status"] = status
@@ -148,15 +193,88 @@ class AsyncFleet:
 
         response = await self.client.request("GET", "/v1/env/instances", params=params)
         return [
-            AsyncEnvironment(client=self.client, **instance_data)
+            AsyncEnv(client=self.client, **instance_data)
             for instance_data in response.json()
         ]
 
-    async def instance(self, instance_id: str) -> AsyncEnvironment:
+    async def instance(self, instance_id: str) -> AsyncEnv:
         response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = AsyncEnvironment(client=self.client, **response.json())
+        instance = AsyncEnv(client=self.client, **response.json())
         await instance.instance.load()
         return instance
 
+    async def check_bundle_exists(self, bundle_hash: str) -> VerifiersCheckResponse:
+        return await _check_bundle_exists(self.client, bundle_hash)
+
+    async def execute_verifier_remote(
+        self, bundle_data: bytes, args: tuple, kwargs: dict, timeout: Optional[int] = 30
+    ) -> VerifiersExecuteResponse:
+        return await _execute_verifier_remote(
+            self.client, bundle_data, args, kwargs, timeout
+        )
+
     async def delete(self, instance_id: str) -> InstanceRecord:
         return await _delete_instance(self.client, instance_id)
+
+
+# Shared
+async def _delete_instance(client: AsyncWrapper, instance_id: str) -> InstanceRecord:
+    response = await client.request("DELETE", f"/v1/env/instances/{instance_id}")
+    return InstanceRecord(**response.json())
+
+
+async def _check_bundle_exists(
+    client: AsyncWrapper, bundle_hash: str
+) -> VerifiersCheckResponse:
+    response = await client.request("GET", f"/v1/verifiers/check?sha256={bundle_hash}")
+    return VerifiersCheckResponse(**response.json())
+
+
+async def _execute_verifier_remote(
+    client: AsyncWrapper,
+    bundle_data: bytes,
+    bundle_sha: str,
+    key: str,
+    function_name: str,
+    args: tuple,
+    kwargs: dict,
+    timeout: Optional[int] = 30,
+    needs_upload: bool = True,
+) -> VerificationResponse:
+    # Pickle args and kwargs together
+    # The first arg should be None as a placeholder for env
+    args_with_none = (None,) + args
+    args_kwargs_pickled = cloudpickle.dumps({"args": args_with_none, "kwargs": kwargs})
+    args_kwargs_b64 = base64.b64encode(args_kwargs_pickled).decode("utf-8")
+
+    # Build request data
+    request_data = {
+        "key": key,
+        "sha256": bundle_sha,
+        "args": args_kwargs_b64,
+        "function_name": function_name,
+        "timeout": timeout,
+        "region": "us-west-1",  # TODO: make configurable
+    }
+    
+    # Add bundle data only if upload is needed
+    if needs_upload:
+        bundle_b64 = base64.b64encode(bundle_data).decode("utf-8")
+        request_data["bundle"] = bundle_b64
+    
+    # Debug logging
+    logger.debug(f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}")
+    logger.debug(f"Request has bundle: {needs_upload}")
+    logger.debug(f"Using client with base_url: {client.base_url}")
+    logger.debug(f"Request data keys: {list(request_data.keys())}")
+    logger.debug(f"Bundle size: {len(request_data.get('bundle', ''))} chars" if 'bundle' in request_data else "No bundle")
+
+    # Note: This should be called on the instance URL, not the orchestrator
+    # The instance has manager URLs for verifier execution
+    response = await client.request("POST", "/v1/verifiers/execute", json=request_data)
+    
+    # Debug the response
+    response_json = response.json()
+    logger.debug(f"Verifier execute response: {response_json}")
+
+    return VerifiersExecuteResponse(**response_json)

fleet/_async/env/client.py

@@ -1,9 +1,9 @@
-from ..client import AsyncFleet, AsyncEnvironment
+from ..client import AsyncFleet, AsyncEnv
 from ...models import Environment as EnvironmentModel
 from typing import List, Optional
 
 
-async def make_async(env_key: str, region: Optional[str] = None) -> AsyncEnvironment:
+async def make_async(env_key: str, region: Optional[str] = None) -> AsyncEnv:
     return await AsyncFleet().make(env_key, region=region)
 
 
@@ -17,9 +17,9 @@ async def list_regions_async() -> List[str]:
 
 async def list_instances_async(
     status: Optional[str] = None, region: Optional[str] = None
-) -> List[AsyncEnvironment]:
+) -> List[AsyncEnv]:
     return await AsyncFleet().instances(status=status, region=region)
 
 
-async def get_async(instance_id: str) -> AsyncEnvironment:
+async def get_async(instance_id: str) -> AsyncEnv:
     return await AsyncFleet().instance(instance_id)

fleet/_async/instance/__init__.py

@@ -12,7 +12,6 @@ from ...instance.models import (
 )
 
 __all__ = [
-    "ValidatorType",
     "AsyncInstanceClient",
     "ResetRequest",
     "ResetResponse",
@@ -20,5 +19,5 @@ __all__ = [
     "ChromeStartRequest",
     "ChromeStartResponse",
     "ChromeStatusResponse",
-    "ExecuteFunctionResponse"
+    "ExecuteFunctionResponse",
 ]

fleet/_async/instance/client.py

@@ -51,7 +51,8 @@ class AsyncInstanceClient:
         self.base_url = url
         self.client = AsyncWrapper(
             url=self.base_url,
-            httpx_client=httpx_client or default_httpx_client(DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT),
+            httpx_client=httpx_client
+            or default_httpx_client(DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT),
         )
         self._resources: Optional[List[ResourceModel]] = None
         self._resources_state: Dict[str, Dict[str, Resource]] = {
@@ -136,7 +137,7 @@ class AsyncInstanceClient:
 
             self._resources = [ResourceModel(**resource) for resource in resources_list]
             for resource in self._resources:
-                if resource.type not in self._resources_state:
+                if resource.type.value not in self._resources_state:
                     self._resources_state[resource.type.value] = {}
                 self._resources_state[resource.type.value][resource.name] = (
                     RESOURCE_TYPES[resource.type](resource, self.client)

fleet/_async/playwright.py

@@ -1,7 +1,7 @@
 import base64
 from typing import List, Dict, Any
 from playwright.async_api import async_playwright, Browser, Page
-from .client import AsyncEnvironment
+from .client import AsyncEnv
 
 
 # Key mapping for computer use actions
@@ -65,7 +65,7 @@ class AsyncFleetPlaywrightWrapper:
 
     def __init__(
         self,
-        env: AsyncEnvironment,
+        env: AsyncEnv,
         display_width: int = 1920,
         display_height: int = 1080,
     ):