fleet-python 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

examples/dsl_example.py

@@ -65,7 +65,7 @@ def validate_new_deal_creation(
 async def main():
     # Create a new instance
     print("Creating new Hubspot instance...")
-    env = await flt.env.make("hubspot:v1.2.7")
+    env = await flt.env.make_async("hubspot:v1.2.7")
     print(f"New Instance: {env.instance_id}")
 
     try:
@@ -99,6 +99,7 @@ async def main():
         )
         """
 
+        print("RESOURCES", await env.resources())
         db = env.db()
         insert_result = await db.exec(insert_query)
         print(f"Insert result: {insert_result}")

examples/example.py

@@ -6,11 +6,11 @@ import fleet as flt
 
 
 async def main():
-    environments = await flt.env.list_envs()
+    environments = await flt.env.list_envs_async()
     print("Environments:", len(environments))
 
     # Create a new instance
-    env = await flt.env.make("hubspot:v1.2.7")
+    env = await flt.env.make_async("hubspot:v1.2.7")
     print("New Instance:", env.instance_id)
 
     response = await env.reset(seed=42)

examples/json_tasks_example.py

@@ -39,7 +39,7 @@ async def main():
     if not file_path.exists():
         raise FileNotFoundError(f"Error: File '{args.json_file}' not found")
 
-    env = await flt.env.make("fira:v1.2.7")
+    env = await flt.env.make_async("fira:v1.2.7")
     print(f"New Instance: {env.urls.app}")
 
     successes = 0

examples/nova_act_example.py

@@ -4,7 +4,7 @@ from nova_act import NovaAct, ActResult
 
 
 async def main():
-    instance = await flt.env.make("hubspot")
+    instance = await flt.env.make_async("hubspot:v1.2.7")
     cdp_url = await instance.browser().cdp_url()
 
     loop = asyncio.get_event_loop()

examples/openai_example.py

@@ -1,11 +1,10 @@
-import asyncio
-from openai import AsyncOpenAI
+from openai import OpenAI
 import fleet as flt
 import json
 from typing import Callable
 
 
-client = AsyncOpenAI()
+client = OpenAI()
 
 
 def sanitize_message(msg: dict) -> dict:
@@ -50,7 +49,7 @@ class Agent:
         if self.debug:
             print(*args)
 
-    async def handle_item(self, item):
+    def handle_item(self, item):
         """Handle each item; may cause a computer action + screenshot."""
         if self.debug:
             print(f"Handling item of type: {item.get('type')}")
@@ -66,7 +65,7 @@ class Agent:
 
             if hasattr(self.computer, name):  # if function exists on computer, call it
                 method = getattr(self.computer, name)
-                await method(**args)
+                method(**args)
             return [
                 {
                     "type": "function_call_output",
@@ -83,9 +82,9 @@ class Agent:
                 print(f"{action_type}({action_args})")
 
             method = getattr(self.computer, action_type)
-            await method(**action_args)
+            method(**action_args)
 
-            screenshot_base64 = await self.computer.screenshot()
+            screenshot_base64 = self.computer.screenshot()
 
             # if user doesn't ack all safety checks exit with error
             pending_checks = item.get("pending_safety_checks", [])
@@ -114,7 +113,7 @@ class Agent:
             return [call_output]
         return []
 
-    async def run_full_turn(
+    def run_full_turn(
         self, input_items, print_steps=True, debug=False, show_images=False
     ):
         self.print_steps = print_steps
@@ -134,7 +133,7 @@ class Agent:
 
             clean_input = [_clean_item(m) for m in (input_items + new_items)]
 
-            response = await client.responses.create(
+            response = client.responses.create(
                 model=self.model,
                 input=clean_input,
                 tools=self.tools,
@@ -173,7 +172,7 @@ class Agent:
                 new_items.append(item)
 
                 # Next, perform any local side-effects (browser actions, etc.).
-                handled_items = await self.handle_item(item)
+                handled_items = self.handle_item(item)
 
                 # If the handler generated additional items (e.g. computer_call_output)
                 # we append those *immediately* so the order remains:
@@ -187,19 +186,13 @@ class Agent:
 tools = []
 
 
-async def ainput(prompt: str = "") -> str:
-    """Async version of input()"""
-    loop = asyncio.get_event_loop()
-    return await loop.run_in_executor(None, input, prompt)
-
-
-async def main():
+def main():
     # Create a Fleet environment instance
-    instance = await flt.env.make("hubspot")
+    instance = flt.env.make("hubspot")
 
     # Create the Playwright wrapper
     browser = flt.FleetPlaywrightWrapper(instance)
-    await browser.start()
+    browser.start()
 
     try:
         agent = Agent(browser, model="computer-use-preview", tools=[])
@@ -212,9 +205,9 @@ async def main():
 
         while True:
             try:
-                user_input = await ainput("> ")
+                user_input = input("> ")
                 items.append({"role": "user", "content": user_input})
-                output_items = await agent.run_full_turn(
+                output_items = agent.run_full_turn(
                     items, show_images=False, debug=False
                 )
                 items += output_items
@@ -225,9 +218,9 @@ async def main():
                 print(f"Error during interaction: {e}")
                 # Continue the loop for other errors
     finally:
-        await browser.close()
-        await instance.close()
+        browser.close()
+        instance.close()
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()

examples/openai_simple_example.py

@@ -1,15 +1,14 @@
-import asyncio
-from openai import AsyncOpenAI
+from openai import OpenAI
 import fleet as flt
 
-client = AsyncOpenAI()
+client = OpenAI()
 
 
-async def main():
-    instance = await flt.env.make("hubspot")
+def main():
+    instance = flt.env.make("hubspot")
 
     browser = flt.FleetPlaywrightWrapper(instance)
-    await browser.start()
+    browser.start()
 
     try:
         width, height = browser.get_dimensions()
@@ -22,7 +21,7 @@ async def main():
             }
         ]
 
-        response = await client.responses.create(
+        response = client.responses.create(
             model="computer-use-preview",
             input=[
                 {
@@ -41,21 +40,21 @@ async def main():
             if response.output[0].type == "computer_call":
                 action = response.output[0].action
                 if action.type == "screenshot":
-                    screenshot_base64 = await browser.screenshot()
+                    screenshot_base64 = browser.screenshot()
                     result = {
                         "type": "input_image",
                         "image_url": f"data:image/png;base64,{screenshot_base64}",
                         "current_url": browser.get_current_url(),
                     }
                 else:
-                    result = await browser.execute_computer_action(action)
+                    result = browser.execute_computer_action(action)
 
                 print("Computer action result:")
                 print(result)
     finally:
-        await browser.close()
-        await instance.close()
+        browser.close()
+        instance.close()
 
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()

fleet/__init__.py

@@ -20,8 +20,11 @@ from .exceptions import (
     FleetTimeoutError,
     FleetConfigurationError,
 )
-from .client import Fleet, AsyncFleet, InstanceRequest
+from .client import Fleet, Environment
+from ._async.client import AsyncFleet, AsyncEnvironment
+from .models import InstanceRequest
 from .instance import (
+    InstanceClient,
     AsyncInstanceClient,
     ResetRequest,
     ResetResponse,
@@ -30,7 +33,12 @@ from .instance import (
     ChromeStartResponse,
     ChromeStatusResponse,
 )
-from .verifiers import *
+from .verifiers import (
+    DatabaseSnapshot,
+    IgnoreConfig,
+    SnapshotDiff,
+    TASK_SUCCESSFUL_SCORE,
+)
 from . import env
 
 # Optional playwright integration
@@ -49,7 +57,10 @@ __all__ = [
     "FleetTimeoutError",
     "FleetConfigurationError",
     "Fleet",
+    "Environment",
     "AsyncFleet",
+    "AsyncEnvironment",
+    "InstanceClient",
     "AsyncInstanceClient",
     "InstanceRequest",
     "ResetRequest",
@@ -58,8 +69,12 @@ __all__ = [
     "ChromeStartRequest",
     "ChromeStartResponse",
     "ChromeStatusResponse",
+    "DatabaseSnapshot",
+    "IgnoreConfig",
+    "SnapshotDiff",
+    "TASK_SUCCESSFUL_SCORE",
 ]
 
 # Add playwright wrapper to exports if available
 if _PLAYWRIGHT_AVAILABLE:
-    __all__.append("FleetPlaywrightWrapper")
+    __all__.append("FleetPlaywrightWrapper")

fleet/_async/base.py

@@ -0,0 +1,51 @@
+import httpx
+from typing import Dict, Any, Optional
+
+from .models import InstanceResponse
+
+
+class EnvironmentBase(InstanceResponse):
+    @property
+    def manager_url(self) -> str:
+        return f"{self.urls.manager.api}"
+
+
+class BaseWrapper:
+    def __init__(self, *, api_key: Optional[str], base_url: Optional[str]):
+        if api_key is None:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        if base_url is None:
+            base_url = "https://fleet.new"
+        self.base_url = base_url
+
+    def get_headers(self) -> Dict[str, str]:
+        headers: Dict[str, str] = {
+            "X-Fleet-SDK-Language": "Python",
+            "X-Fleet-SDK-Version": "1.0.0",
+        }
+        headers["Authorization"] = f"Bearer {self.api_key}"
+        return headers
+
+
+class AsyncWrapper(BaseWrapper):
+    def __init__(self, *, httpx_client: httpx.AsyncClient, **kwargs):
+        super().__init__(**kwargs)
+        self.httpx_client = httpx_client
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        return await self.httpx_client.request(
+            method,
+            f"{self.base_url}{url}",
+            headers=self.get_headers(),
+            params=params,
+            json=json,
+            **kwargs,
+        )

fleet/_async/client.py

@@ -0,0 +1,133 @@
+# Copyright 2025 Fleet AI
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Fleet API Client for making HTTP requests to Fleet services."""
+
+import os
+import httpx
+import logging
+from typing import Optional, List
+
+from .base import EnvironmentBase, AsyncWrapper
+from .models import InstanceRequest, InstanceRecord, Environment as EnvironmentModel
+
+from .instance import (
+    AsyncInstanceClient,
+    ResetRequest,
+    ResetResponse,
+    ValidatorType,
+    ExecuteFunctionResponse,
+)
+from .resources.base import Resource
+from .resources.sqlite import AsyncSQLiteResource
+from .resources.browser import AsyncBrowserResource
+
+logger = logging.getLogger(__name__)
+
+
+class AsyncEnvironment(EnvironmentBase):
+    def __init__(self, httpx_client: Optional[httpx.AsyncClient] = None, **kwargs):
+        super().__init__(**kwargs)
+        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=60.0)
+        self._instance: Optional[AsyncInstanceClient] = None
+
+    @property
+    def instance(self) -> AsyncInstanceClient:
+        if self._instance is None:
+            self._instance = AsyncInstanceClient(self.manager_url, self._httpx_client)
+        return self._instance
+
+    async def reset(
+        self, seed: Optional[int] = None, timestamp: Optional[int] = None
+    ) -> ResetResponse:
+        return await self.instance.reset(ResetRequest(seed=seed, timestamp=timestamp))
+
+    def db(self, name: str = "current") -> AsyncSQLiteResource:
+        return self.instance.db(name)
+
+    def browser(self, name: str = "cdp") -> AsyncBrowserResource:
+        return self.instance.browser(name)
+
+    def state(self, uri: str) -> Resource:
+        return self.instance.state(uri)
+
+    async def resources(self) -> List[Resource]:
+        return await self.instance.resources()
+
+    async def close(self) -> InstanceRecord:
+        return await AsyncFleet().delete(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
+    ) -> ExecuteFunctionResponse:
+        return await self.instance.verify_raw(function_code, function_name)
+
+
+class AsyncFleet:
+    def __init__(
+        self,
+        api_key: Optional[str] = os.getenv("FLEET_API_KEY"),
+        base_url: Optional[str] = None,
+        httpx_client: Optional[httpx.AsyncClient] = None,
+    ):
+        self._httpx_client = httpx_client or httpx.AsyncClient(timeout=60.0)
+        self.client = AsyncWrapper(
+            api_key=api_key,
+            base_url=base_url,
+            httpx_client=self._httpx_client,
+        )
+
+    async def list_envs(self) -> List[EnvironmentModel]:
+        response = await self.client.request("GET", "/v1/env/")
+        return [EnvironmentModel(**env_data) for env_data in response.json()]
+
+    async def environment(self, env_key: str) -> EnvironmentModel:
+        response = await self.client.request("GET", f"/v1/env/{env_key}")
+        return EnvironmentModel(**response.json())
+
+    async def make(self, env_key: str) -> AsyncEnvironment:
+        if ":" in env_key:
+            env_key_part, version = env_key.split(":", 1)
+            if not version.startswith("v"):
+                version = f"v{version}"
+        else:
+            env_key_part = env_key
+            version = None
+
+        request = InstanceRequest(env_key=env_key_part, version=version)
+        response = await self.client.request(
+            "POST", "/v1/env/instances", json=request.model_dump()
+        )
+        instance = AsyncEnvironment(**response.json())
+        await instance.instance.load()
+        return instance
+
+    async def instances(self, status: Optional[str] = None) -> List[AsyncEnvironment]:
+        params = {}
+        if status:
+            params["status"] = status
+
+        response = await self.client.request("GET", "/v1/env/instances", params=params)
+        return [AsyncEnvironment(**instance_data) for instance_data in response.json()]
+
+    async def instance(self, instance_id: str) -> AsyncEnvironment:
+        response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
+        return AsyncEnvironment(**response.json())
+
+    async def delete(self, instance_id: str) -> InstanceRecord:
+        response = await self.client.request("DELETE", f"/v1/env/instances/{instance_id}")
+        return InstanceRecord(**response.json())

fleet/_async/env/client.py

@@ -0,0 +1,15 @@
+from ..client import AsyncFleet, AsyncEnvironment
+from ..models import Environment as EnvironmentModel
+from typing import List
+
+
+async def make_async(env_key: str) -> AsyncEnvironment:
+    return await AsyncFleet().make(env_key)
+
+
+async def list_envs_async() -> List[EnvironmentModel]:
+    return await AsyncFleet().list_envs()
+
+
+async def get_async(instance_id: str) -> AsyncEnvironment:
+    return await AsyncFleet().instance(instance_id)

fleet/_async/exceptions.py

@@ -0,0 +1,73 @@
+"""Fleet SDK Exception Classes."""
+
+from typing import Any, Dict, Optional
+
+
+class FleetError(Exception):
+    """Base exception for all Fleet SDK errors."""
+    
+    def __init__(self, message: str, details: Optional[Dict[str, Any]] = None):
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+
+
+class FleetAPIError(FleetError):
+    """Exception raised when Fleet API returns an error."""
+    
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        response_data: Optional[Dict[str, Any]] = None,
+        details: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(message, details)
+        self.status_code = status_code
+        self.response_data = response_data or {}
+
+
+class FleetTimeoutError(FleetError):
+    """Exception raised when a Fleet operation times out."""
+    
+    def __init__(self, message: str, timeout_duration: Optional[float] = None):
+        super().__init__(message)
+        self.timeout_duration = timeout_duration
+
+
+class FleetAuthenticationError(FleetAPIError):
+    """Exception raised when authentication fails."""
+    
+    def __init__(self, message: str = "Authentication failed"):
+        super().__init__(message, status_code=401)
+
+
+class FleetRateLimitError(FleetAPIError):
+    """Exception raised when rate limit is exceeded."""
+    
+    def __init__(self, message: str = "Rate limit exceeded"):
+        super().__init__(message, status_code=429)
+
+
+class FleetEnvironmentError(FleetError):
+    """Exception raised when environment operations fail."""
+    
+    def __init__(self, message: str, environment_id: Optional[str] = None):
+        super().__init__(message)
+        self.environment_id = environment_id
+
+
+class FleetFacetError(FleetError):
+    """Exception raised when facet operations fail."""
+    
+    def __init__(self, message: str, facet_type: Optional[str] = None):
+        super().__init__(message)
+        self.facet_type = facet_type
+
+
+class FleetConfigurationError(FleetError):
+    """Exception raised when configuration is invalid."""
+    
+    def __init__(self, message: str, config_key: Optional[str] = None):
+        super().__init__(message)
+        self.config_key = config_key 

fleet/_async/instance/__init__.py

@@ -0,0 +1,24 @@
+"""Fleet SDK Environment Module."""
+
+from .client import AsyncInstanceClient, ValidatorType
+from .models import (
+    ResetRequest,
+    ResetResponse,
+    CDPDescribeResponse,
+    ChromeStartRequest,
+    ChromeStartResponse,
+    ChromeStatusResponse,
+    ExecuteFunctionResponse,
+)
+
+__all__ = [
+    "ValidatorType",
+    "AsyncInstanceClient",
+    "ResetRequest",
+    "ResetResponse",
+    "CDPDescribeResponse",
+    "ChromeStartRequest",
+    "ChromeStartResponse",
+    "ChromeStatusResponse",
+    "ExecuteFunctionResponse"
+]

fleet/_async/instance/base.py

@@ -0,0 +1,37 @@
+import httpx
+from typing import Dict, Any, Optional
+
+
+class BaseWrapper:
+    def __init__(self, *, url: str):
+        self.url = url
+
+    def get_headers(self) -> Dict[str, str]:
+        headers: Dict[str, str] = {
+            "X-Fleet-SDK-Language": "Python",
+            "X-Fleet-SDK-Version": "1.0.0",
+        }
+        return headers
+
+
+class AsyncWrapper(BaseWrapper):
+    def __init__(self, *, httpx_client: httpx.AsyncClient, **kwargs):
+        super().__init__(**kwargs)
+        self.httpx_client = httpx_client
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Any] = None,
+        **kwargs,
+    ) -> httpx.Response:
+        return await self.httpx_client.request(
+            method,
+            f"{self.url}{path}",
+            headers=self.get_headers(),
+            params=params,
+            json=json,
+            **kwargs,
+        )