fleet-python 0.1.0__py3-none-any.whl

fleet/facets/base.py

@@ -0,0 +1,223 @@
+"""Fleet SDK Base Facet Classes."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, TYPE_CHECKING
+from urllib.parse import urlparse
+
+if TYPE_CHECKING:
+    from ..env.base import Environment
+
+
+class Facet(ABC):
+    """Base class for all facets in Fleet environments."""
+    
+    def __init__(self, uri: str, environment: "Environment"):
+        self.uri = uri
+        self.environment = environment
+        self._parsed_uri = urlparse(uri)
+        self._scheme = self._parsed_uri.scheme
+        self._netloc = self._parsed_uri.netloc
+        self._path = self._parsed_uri.path
+        self._params = self._parsed_uri.params
+        self._query = self._parsed_uri.query
+        self._fragment = self._parsed_uri.fragment
+        
+    @property
+    def scheme(self) -> str:
+        """Get the URI scheme (e.g., 'sqlite', 'browser', 'file')."""
+        return self._scheme
+    
+    @property
+    def netloc(self) -> str:
+        """Get the URI network location."""
+        return self._netloc
+    
+    @property
+    def path(self) -> str:
+        """Get the URI path."""
+        return self._path
+    
+    @abstractmethod
+    async def initialize(self) -> None:
+        """Initialize the facet."""
+        pass
+    
+    @abstractmethod
+    async def close(self) -> None:
+        """Close the facet and clean up resources."""
+        pass
+    
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(uri='{self.uri}')"
+
+
+class DatabaseFacet(Facet):
+    """Base class for database facets."""
+    
+    @abstractmethod
+    async def exec(self, query: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Execute a database query.
+        
+        Args:
+            query: SQL query to execute
+            params: Query parameters
+            
+        Returns:
+            Query result
+        """
+        pass
+    
+    @abstractmethod
+    async def fetch(self, query: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Fetch results from a database query.
+        
+        Args:
+            query: SQL query to execute
+            params: Query parameters
+            
+        Returns:
+            Query results
+        """
+        pass
+
+
+class BrowserFacet(Facet):
+    """Base class for browser facets."""
+    
+    @abstractmethod
+    async def get_dom(self) -> Dict[str, Any]:
+        """Get the current DOM structure.
+        
+        Returns:
+            DOM structure as dictionary
+        """
+        pass
+    
+    @abstractmethod
+    async def get_element(self, selector: str) -> Optional[Dict[str, Any]]:
+        """Get an element by CSS selector.
+        
+        Args:
+            selector: CSS selector
+            
+        Returns:
+            Element data or None if not found
+        """
+        pass
+    
+    @abstractmethod
+    async def get_elements(self, selector: str) -> list[Dict[str, Any]]:
+        """Get elements by CSS selector.
+        
+        Args:
+            selector: CSS selector
+            
+        Returns:
+            List of element data
+        """
+        pass
+
+
+class FileFacet(Facet):
+    """Base class for file system facets."""
+    
+    @abstractmethod
+    async def read(self, path: str) -> bytes:
+        """Read file contents.
+        
+        Args:
+            path: File path
+            
+        Returns:
+            File contents as bytes
+        """
+        pass
+    
+    @abstractmethod
+    async def write(self, path: str, content: bytes) -> None:
+        """Write file contents.
+        
+        Args:
+            path: File path
+            content: Content to write
+        """
+        pass
+    
+    @abstractmethod
+    async def list_dir(self, path: str) -> list[str]:
+        """List directory contents.
+        
+        Args:
+            path: Directory path
+            
+        Returns:
+            List of file/directory names
+        """
+        pass
+    
+    @abstractmethod
+    async def exists(self, path: str) -> bool:
+        """Check if file or directory exists.
+        
+        Args:
+            path: File or directory path
+            
+        Returns:
+            True if exists, False otherwise
+        """
+        pass
+
+
+class APIFacet(Facet):
+    """Base class for API facets."""
+    
+    @abstractmethod
+    async def get(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a GET request.
+        
+        Args:
+            path: API endpoint path
+            params: Query parameters
+            
+        Returns:
+            API response
+        """
+        pass
+    
+    @abstractmethod
+    async def post(self, path: str, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a POST request.
+        
+        Args:
+            path: API endpoint path
+            data: Request data
+            
+        Returns:
+            API response
+        """
+        pass
+    
+    @abstractmethod
+    async def put(self, path: str, data: Optional[Dict[str, Any]] = None) -> Any:
+        """Make a PUT request.
+        
+        Args:
+            path: API endpoint path
+            data: Request data
+            
+        Returns:
+            API response
+        """
+        pass
+    
+    @abstractmethod
+    async def delete(self, path: str) -> Any:
+        """Make a DELETE request.
+        
+        Args:
+            path: API endpoint path
+            
+        Returns:
+            API response
+        """
+        pass 

fleet/facets/factory.py

@@ -0,0 +1,29 @@
+"""Fleet SDK Facet Factory."""
+
+from typing import TYPE_CHECKING
+from urllib.parse import urlparse
+
+from .base import Facet
+from ..exceptions import FleetFacetError
+
+if TYPE_CHECKING:
+    from ..env.base import Environment
+
+
+def create_facet(uri: str, environment: "Environment") -> Facet:
+    """Create a facet based on the URI scheme.
+    
+    Args:
+        uri: URI identifying the facet (e.g., 'sqlite://crm', 'browser://dom')
+        environment: Environment instance
+        
+    Returns:
+        Facet instance
+        
+    Raises:
+        NotImplementedError: Facet implementations are not yet available
+    """
+    parsed = urlparse(uri)
+    scheme = parsed.scheme.lower()
+    
+    raise NotImplementedError(f"Facet implementation for scheme '{scheme}' not yet available") 

fleet/manager_client.py

@@ -0,0 +1,177 @@
+# 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 Manager API Client for per-instance environment management."""
+
+import asyncio
+import logging
+from typing import Any, Dict, Optional
+import aiohttp
+from pydantic import BaseModel, Field
+
+from .exceptions import (
+    FleetAPIError,
+    FleetTimeoutError,
+    FleetError,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ManagerHealthResponse(BaseModel):
+    """Response model for manager health checks."""
+    
+    status: str = Field(..., description="Health status")
+    timestamp: str = Field(..., description="Timestamp")
+    service: str = Field(..., description="Service name")
+
+
+class TimestampResponse(BaseModel):
+    """Response model for timestamp endpoint."""
+    
+    timestamp: str = Field(..., description="Current timestamp")
+
+
+class FleetManagerClient:
+    """Client for interacting with Fleet Manager APIs on individual instances."""
+    
+    def __init__(self, base_url: str):
+        """Initialize the manager client.
+        
+        Args:
+            base_url: Base URL for the manager API (e.g., https://instanceid.fleetai.com)
+        """
+        self._base_url = base_url.rstrip('/')
+        self._session: Optional[aiohttp.ClientSession] = None
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self._ensure_session()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+    
+    async def _ensure_session(self):
+        """Ensure HTTP session is created."""
+        if self._session is None or self._session.closed:
+            timeout = aiohttp.ClientTimeout(total=30)
+            self._session = aiohttp.ClientSession(
+                timeout=timeout,
+                connector=aiohttp.TCPConnector(limit=10),
+            )
+    
+    async def close(self):
+        """Close the HTTP session."""
+        if self._session and not self._session.closed:
+            await self._session.close()
+            self._session = None
+    
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        data: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """Make an HTTP request to the Manager API.
+        
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            path: API endpoint path
+            data: Request body data
+            params: Query parameters
+            headers: Additional headers
+            timeout: Request timeout in seconds
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            FleetAPIError: If the API returns an error
+            FleetTimeoutError: If request times out
+        """
+        await self._ensure_session()
+        
+        url = f"{self._base_url}{path}"
+        request_headers = headers or {}
+        
+        try:
+            logger.debug(f"Making {method} request to {url}")
+            
+            async with self._session.request(
+                method=method,
+                url=url,
+                json=data,
+                params=params,
+                headers=request_headers,
+                timeout=aiohttp.ClientTimeout(total=timeout or 30),
+            ) as response:
+                response_data = await response.json() if response.content_type == "application/json" else {}
+                
+                if response.status == 200:
+                    logger.debug(f"Manager API request successful: {response.status}")
+                    return response_data
+                else:
+                    error_message = response_data.get("detail", f"Manager API request failed with status {response.status}")
+                    raise FleetAPIError(
+                        error_message,
+                        status_code=response.status,
+                        response_data=response_data,
+                    )
+                    
+        except asyncio.TimeoutError:
+            raise FleetTimeoutError(f"Request to {url} timed out")
+            
+        except aiohttp.ClientError as e:
+            raise FleetAPIError(f"HTTP client error: {e}")
+    
+    # Health check operations
+    async def health_check(self) -> ManagerHealthResponse:
+        """Check the health of the manager API.
+        
+        Returns:
+            ManagerHealthResponse object
+        """
+        response = await self._request("GET", "/health")
+        return ManagerHealthResponse(**response)
+    
+    async def get_timestamp(self) -> TimestampResponse:
+        """Get current timestamp from the manager.
+        
+        Returns:
+            TimestampResponse object
+        """
+        response = await self._request("GET", "/timestamp")
+        return TimestampResponse(**response)
+    
+    async def test_path(self) -> Dict[str, Any]:
+        """Test endpoint to verify path configuration.
+        
+        Returns:
+            Test response data
+        """
+        response = await self._request("GET", "/test-path")
+        return response
+    
+    # Future endpoints can be added here as needed:
+    # - log_action()
+    # - reset_database()
+    # - create_snapshots()
+    # - generate_diff()
+    # - execute_verifier_function()
+    # etc. 

fleet_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: fleet-python
+Version: 0.1.0
+Summary: Python SDK for Fleet environments
+Author-email: Fleet AI <nic@fleet.so>
+License: Apache-2.0
+Project-URL: Homepage, https://fleetai.com
+Project-URL: Documentation, https://docs.fleetai.com
+Project-URL: Repository, https://github.com/fleet-ai/fleet-sdk
+Project-URL: Issues, https://github.com/fleet-ai/fleet-sdk/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: isort>=5.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Fleet SDK
+
+The Fleet Python SDK provides programmatic access to Fleet's environment infrastructure.
+
+## Installation
+
+Install the Fleet SDK using pip:
+
+```bash
+pip install fleet-python
+```
+
+## API Key Setup
+
+Fleet requires an API key for authentication. You can obtain one from the [Fleet Platform](https://fleetai.com/dashboard/api-keys).
+
+Set your API key as an environment variable:
+
+```bash
+export FLEET_API_KEY="sk_your_key_here"
+```
+
+## Basic Usage
+
+```python
+import fleet as flt
+
+# Create environment by key
+env = await flt.env.make("fira")
+
+# Reset environment with seed and options
+await env.reset(
+    seed=42,
+    timestamp=datetime.now()
+)
+
+# Access environment state ('crm' is the resource id for a sqlite database)
+sql = env.state("sqlite://crm")
+await sql.exec("UPDATE customers SET status = 'active' WHERE id = 123")
+
+# Clean up
+await env.close()
+```
+
+## Environment Management
+
+### Creating Instances
+
+```python
+# Create environment instance with explicit version
+env = await flt.env.make("fira:v1.2.5")
+
+# Create environment instance with default (latest) version
+env = await flt.env.make("fira")
+
+```
+
+### Connecting to Existing Instances
+
+```python
+# Connect to a running instance
+env = await flt.env.get("env_instance_id")
+
+# List all running instances
+instances = await flt.env.list_instances()
+for instance in instances:
+    print(f"Instance: {instance.instance_id}")
+    print(f"Type: {instance.environment_type}")
+    print(f"Status: {instance.status}")
+
+# Filter instances by status (running, pending, stopped, error)
+running_instances = await flt.env.list_instances(status_filter="running")
+
+# List available environment types
+available_envs = await flt.env.list_envs()
+```

fleet_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+examples/quickstart.py,sha256=AnLlLQYRfrP7y2J69d1HZRlZsjJT-KeBu897MoNfqYM,4671
+fleet/__init__.py,sha256=WhanDP1kC_K84nrEe9ER1iyODW2344wghQ8Rgdi-JmA,1441
+fleet/client.py,sha256=nBjUV901oyR5uE0WAwHEE-xsgyntesGRiLVhVWf793o,12071
+fleet/config.py,sha256=xlKv-gr38oBcyltQiKjgLzxV-JSd3b4x5oxevOjioME,3768
+fleet/exceptions.py,sha256=yG3QWprCw1OnF-vdFBFJWE4m3ftBLBng31Dr__VbjI4,2249
+fleet/manager_client.py,sha256=o01MuTAoeXssI23SSIwsAHM8ck1G6VsOluD_emcpFnE,5900
+fleet/env/__init__.py,sha256=yKJ-35vAVU4VWWkZMDFeElF9uMzsahBm2K-IumOkciU,570
+fleet/env/base.py,sha256=Ry-1t2cyn2EMlpEtO3XJ89FzK7Q471tsZ8WaluIacK8,12046
+fleet/env/factory.py,sha256=BH6ILmc5WvyNanqSf6RqZXR6SgixMoDw5tOnR0PqVhM,13920
+fleet/facets/__init__.py,sha256=oXU7Tkcx1ETlto4mLUwrjj5-5EcsM-lqAqksJMpmDkE,84
+fleet/facets/base.py,sha256=mJAnRiboGWRn5eSjKM6QZTOPDGDiMrl2kwJbONZ3yq0,5400
+fleet/facets/factory.py,sha256=7OecnXJUafsM9mJcNPHXV5djUOUNg8I6p12sfXGCb4g,782
+fleet_python-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.1.0.dist-info/METADATA,sha256=I6IGquclMRBeM6IVAKs_uQY-8rC7McfSrE850zCcHfU,3040
+fleet_python-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.1.0.dist-info/top_level.txt,sha256=AOyXOrBXUjPcH4BumElz_D95kiWKNIpUbUPFP_9gCLk,15
+fleet_python-0.1.0.dist-info/RECORD,,

fleet_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+