fleet-python 0.2.71__tar.gz → 0.2.72__tar.gz

{fleet_python-0.2.71/fleet_python.egg-info → fleet_python-0.2.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.71
+Version: 0.2.72
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.71 → fleet_python-0.2.72}/fleet/_async/client.py

@@ -21,7 +21,7 @@ import httpx
 import json
 import logging
 import os
-from typing import List, Optional, Dict, Any, TYPE_CHECKING
+from typing import List, Optional, Dict, Any, TYPE_CHECKING, Union
 
 from .base import EnvironmentBase, AsyncWrapper
 from ..models import (
@@ -49,6 +49,11 @@ from .instance import (
     ResetResponse,
     ExecuteFunctionResponse,
 )
+from ..instance.models import (
+    Resource as ResourceModel,
+    ResourceType,
+    ResourceMode,
+)
 from ..config import (
     DEFAULT_MAX_RETRIES,
     DEFAULT_TIMEOUT,
@@ -310,11 +315,163 @@ class AsyncFleet:
             for instance_data in response.json()
         ]
 
-    async def instance(self, instance_id: str) -> AsyncEnv:
-        response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = AsyncEnv(client=self.client, **response.json())
-        await instance.instance.load()
-        return instance
+    async def instance(self, instance_id: Union[str, Dict[str, str]]) -> AsyncEnv:
+        """Create or connect to an environment instance.
+
+        Supports three modes based on input type:
+        1. dict: Local filesystem mode - {"current": "./data.db", "seed": "./seed.db"}
+        2. str starting with http:// or https://: Localhost/URL mode
+        3. str (other): Remote cloud instance mode
+
+        Args:
+            instance_id: Instance identifier (str), URL (str starting with http://),
+                        or local db mapping (dict)
+
+        Returns:
+            AsyncEnv: Environment instance
+        """
+        # Local filesystem mode - dict of resource names to file paths
+        if isinstance(instance_id, dict):
+            return self._create_local_instance(instance_id)
+
+        # Localhost/direct URL mode - string starting with http:// or https://
+        elif isinstance(instance_id, str) and instance_id.startswith(("http://", "https://")):
+            return self._create_url_instance(instance_id)
+
+        # Remote mode - existing behavior
+        else:
+            response = await self.client.request("GET", f"/v1/env/instances/{instance_id}")
+            instance = AsyncEnv(client=self.client, **response.json())
+            await instance.instance.load()
+            return instance
+
+    def _create_url_instance(self, base_url: str) -> AsyncEnv:
+        """Create instance connected to a direct URL (localhost or custom).
+
+        Args:
+            base_url: URL of the instance manager API
+
+        Returns:
+            AsyncEnv: Environment instance configured for URL mode
+        """
+        instance_client = AsyncInstanceClient(url=base_url, httpx_client=self._httpx_client)
+
+        # Create a minimal environment for URL mode
+        env = AsyncEnv(
+            client=self.client,
+            instance_id=base_url,
+            env_key="localhost",
+            version="",
+            status="running",
+            subdomain="localhost",
+            created_at="",
+            updated_at="",
+            terminated_at=None,
+            team_id="",
+            region="localhost",
+            env_variables=None,
+            data_key=None,
+            data_version=None,
+            urls=None,
+            health=None,
+        )
+        env._instance = instance_client
+        return env
+
+    @staticmethod
+    def _normalize_db_path(path: str) -> tuple[str, bool]:
+        """Normalize database path and detect if it's in-memory.
+
+        Args:
+            path: Database path - can be:
+                  - File path: "./data.db"
+                  - Plain memory: ":memory:"
+                  - Named memory: ":memory:namespace"
+                  - URI: "file:name?mode=memory&cache=shared"
+
+        Returns:
+            Tuple of (normalized_path, is_memory)
+        """
+        import uuid
+        import sqlite3
+
+        if path == ":memory:":
+            # Plain :memory: - create unique namespace
+            name = f"mem_{uuid.uuid4().hex[:8]}"
+            return f"file:{name}?mode=memory&cache=shared", True
+        elif path.startswith(":memory:"):
+            # Named memory: :memory:current -> file:current?mode=memory&cache=shared
+            namespace = path[8:]  # Remove ":memory:" prefix
+            return f"file:{namespace}?mode=memory&cache=shared", True
+        elif "mode=memory" in path:
+            # Already a proper memory URI
+            return path, True
+        else:
+            # Regular file path
+            return path, False
+
+    def _create_local_instance(self, dbs: Dict[str, str]) -> AsyncEnv:
+        """Create instance with local file-based or in-memory SQLite resources.
+
+        Args:
+            dbs: Map of resource names to paths (e.g., {"current": "./data.db"} or
+                 {"current": ":memory:current"})
+
+        Returns:
+            AsyncEnv: Environment instance configured for local mode
+        """
+        import sqlite3
+
+        instance_client = AsyncInstanceClient(url="local://", httpx_client=None)
+        instance_client._resources = []  # Mark as loaded
+        instance_client._memory_anchors = {}  # Store anchor connections for in-memory DBs
+
+        # Store creation parameters for local AsyncSQLiteResources
+        # This allows db() to create new instances each time (matching HTTP mode behavior)
+        for name, path in dbs.items():
+            # Normalize path and detect if it's in-memory
+            normalized_path, is_memory = self._normalize_db_path(path)
+
+            # Create anchor connection for in-memory databases
+            # This keeps the database alive as long as the env exists
+            if is_memory:
+                anchor_conn = sqlite3.connect(normalized_path, uri=True)
+                instance_client._memory_anchors[name] = anchor_conn
+
+            resource_model = ResourceModel(
+                name=name,
+                type=ResourceType.db,
+                mode=ResourceMode.rw,
+                label=f"Local: {path}",
+            )
+            instance_client._resources_state[ResourceType.db.value][name] = {
+                'type': 'local',
+                'resource_model': resource_model,
+                'db_path': normalized_path,
+                'is_memory': is_memory
+            }
+
+        # Create a minimal environment for local mode
+        env = AsyncEnv(
+            client=self.client,
+            instance_id="local",
+            env_key="local",
+            version="",
+            status="running",
+            subdomain="local",
+            created_at="",
+            updated_at="",
+            terminated_at=None,
+            team_id="",
+            region="local",
+            env_variables=None,
+            data_key=None,
+            data_version=None,
+            urls=None,
+            health=None,
+        )
+        env._instance = instance_client
+        return env
 
     async def check_bundle_exists(self, bundle_hash: str) -> VerifiersCheckResponse:
         return await _check_bundle_exists(self.client, bundle_hash)

{fleet_python-0.2.71 → fleet_python-0.2.72}/fleet/_async/instance/client.py

@@ -85,9 +85,17 @@ class AsyncInstanceClient:
         Returns:
             An SQLite database resource for the given database name
         """
-        return AsyncSQLiteResource(
-            self._resources_state[ResourceType.db.value][name], self.client
-        )
+        resource_info = self._resources_state[ResourceType.db.value][name]
+        # Local mode - resource_info is a dict with creation parameters
+        if isinstance(resource_info, dict) and resource_info.get('type') == 'local':
+            # Create new instance each time (matching HTTP mode behavior)
+            return AsyncSQLiteResource(
+                resource_info['resource_model'],
+                client=None,
+                db_path=resource_info['db_path']
+            )
+        # HTTP mode - resource_info is a ResourceModel, create new wrapper
+        return AsyncSQLiteResource(resource_info, self.client)
 
     def browser(self, name: str) -> AsyncBrowserResource:
         return AsyncBrowserResource(
@@ -177,10 +185,17 @@ class AsyncInstanceClient:
         response = await self.client.request("GET", "/health")
         return HealthResponse(**response.json())
 
+    def close(self):
+        """Close anchor connections for in-memory databases."""
+        if hasattr(self, '_memory_anchors'):
+            for conn in self._memory_anchors.values():
+                conn.close()
+            self._memory_anchors.clear()
+
     async def __aenter__(self):
         """Async context manager entry."""
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
-        await self.close()
+        self.close()

{fleet_python-0.2.71 → fleet_python-0.2.72}/fleet/_async/resources/sqlite.py

@@ -6,6 +6,7 @@ from datetime import datetime
 import tempfile
 import sqlite3
 import os
+import asyncio
 
 from typing import TYPE_CHECKING
 
@@ -679,17 +680,100 @@ class AsyncQueryBuilder:
 
 
 class AsyncSQLiteResource(Resource):
-    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
+    def __init__(
+        self,
+        resource: ResourceModel,
+        client: Optional["AsyncWrapper"] = None,
+        db_path: Optional[str] = None,
+    ):
         super().__init__(resource)
         self.client = client
+        self.db_path = db_path
+        self._mode = "direct" if db_path else "http"
+
+    @property
+    def mode(self) -> str:
+        """Return the mode of this resource: 'direct' (local file) or 'http' (remote API)."""
+        return self._mode
 
     async def describe(self) -> DescribeResponse:
         """Describe the SQLite database schema."""
+        if self._mode == "direct":
+            return await self._describe_direct()
+        else:
+            return await self._describe_http()
+
+    async def _describe_http(self) -> DescribeResponse:
+        """Describe database schema via HTTP API."""
         response = await self.client.request(
             "GET", f"/resources/sqlite/{self.resource.name}/describe"
         )
         return DescribeResponse(**response.json())
 
+    async def _describe_direct(self) -> DescribeResponse:
+        """Describe database schema from local file or in-memory database."""
+        def _sync_describe():
+            try:
+                # Check if we need URI mode (for shared memory databases)
+                use_uri = 'mode=memory' in self.db_path
+                conn = sqlite3.connect(self.db_path, uri=use_uri)
+                cursor = conn.cursor()
+
+                # Get all tables
+                cursor.execute(
+                    "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+                )
+                table_names = [row[0] for row in cursor.fetchall()]
+
+                tables = []
+                for table_name in table_names:
+                    # Get table info
+                    cursor.execute(f"PRAGMA table_info({table_name})")
+                    columns = cursor.fetchall()
+
+                    # Get CREATE TABLE SQL
+                    cursor.execute(
+                        f"SELECT sql FROM sqlite_master WHERE type='table' AND name=?",
+                        (table_name,)
+                    )
+                    sql_row = cursor.fetchone()
+                    create_sql = sql_row[0] if sql_row else ""
+
+                    table_schema = {
+                        "name": table_name,
+                        "sql": create_sql,
+                        "columns": [
+                            {
+                                "name": col[1],
+                                "type": col[2],
+                                "notnull": bool(col[3]),
+                                "default_value": col[4],
+                                "primary_key": col[5] > 0,
+                            }
+                            for col in columns
+                        ],
+                    }
+                    tables.append(table_schema)
+
+                conn.close()
+
+                return DescribeResponse(
+                    success=True,
+                    resource_name=self.resource.name,
+                    tables=tables,
+                    message="Schema retrieved from local file",
+                )
+            except Exception as e:
+                return DescribeResponse(
+                    success=False,
+                    resource_name=self.resource.name,
+                    tables=None,
+                    error=str(e),
+                    message=f"Failed to describe database: {str(e)}",
+                )
+
+        return await asyncio.to_thread(_sync_describe)
+
     async def query(
         self, query: str, args: Optional[List[Any]] = None
     ) -> QueryResponse:
@@ -701,6 +785,15 @@ class AsyncSQLiteResource(Resource):
     async def _query(
         self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
     ) -> QueryResponse:
+        if self._mode == "direct":
+            return await self._query_direct(query, args, read_only)
+        else:
+            return await self._query_http(query, args, read_only)
+
+    async def _query_http(
+        self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
+    ) -> QueryResponse:
+        """Execute query via HTTP API."""
         request = QueryRequest(query=query, args=args, read_only=read_only)
         response = await self.client.request(
             "POST",
@@ -709,6 +802,62 @@ class AsyncSQLiteResource(Resource):
         )
         return QueryResponse(**response.json())
 
+    async def _query_direct(
+        self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
+    ) -> QueryResponse:
+        """Execute query directly on local SQLite file or in-memory database."""
+        def _sync_query():
+            try:
+                # Check if we need URI mode (for shared memory databases)
+                use_uri = 'mode=memory' in self.db_path
+                conn = sqlite3.connect(self.db_path, uri=use_uri)
+                cursor = conn.cursor()
+
+                # Execute the query
+                if args:
+                    cursor.execute(query, args)
+                else:
+                    cursor.execute(query)
+
+                # For write operations, commit the transaction
+                if not read_only:
+                    conn.commit()
+
+                # Get column names if available
+                columns = [desc[0] for desc in cursor.description] if cursor.description else []
+
+                # Fetch results for SELECT queries
+                rows = []
+                rows_affected = 0
+                last_insert_id = None
+
+                if cursor.description:  # SELECT query
+                    rows = cursor.fetchall()
+                else:  # INSERT/UPDATE/DELETE
+                    rows_affected = cursor.rowcount
+                    last_insert_id = cursor.lastrowid if cursor.lastrowid else None
+
+                conn.close()
+
+                return QueryResponse(
+                    success=True,
+                    columns=columns if columns else None,
+                    rows=rows if rows else None,
+                    rows_affected=rows_affected if rows_affected > 0 else None,
+                    last_insert_id=last_insert_id,
+                    message="Query executed successfully",
+                )
+            except Exception as e:
+                return QueryResponse(
+                    success=False,
+                    columns=None,
+                    rows=None,
+                    error=str(e),
+                    message=f"Query failed: {str(e)}",
+                )
+
+        return await asyncio.to_thread(_sync_query)
+
     def table(self, table_name: str) -> AsyncQueryBuilder:
         """Create a query builder for the specified table."""
         return AsyncQueryBuilder(self, table_name)

{fleet_python-0.2.71 → fleet_python-0.2.72}/fleet/_async/tasks.py

@@ -306,8 +306,11 @@ def verifier_from_string(
         # Remove lines like: @verifier(key="...")
         cleaned_code = re.sub(r"@verifier\([^)]*\)\s*\n", "", verifier_func)
         # Also remove the verifier import if present
-        cleaned_code = re.sub(r"from fleet import.*verifier.*\n", "", cleaned_code)
-        cleaned_code = re.sub(r"import.*verifier.*\n", "", cleaned_code)
+        # Use MULTILINE flag to match beginning of lines with ^
+        cleaned_code = re.sub(r"^from fleet\.verifiers.*import.*verifier.*$\n?", "", cleaned_code, flags=re.MULTILINE)
+        cleaned_code = re.sub(r"^from fleet import verifier.*$\n?", "", cleaned_code, flags=re.MULTILINE)
+        cleaned_code = re.sub(r"^import fleet\.verifiers.*$\n?", "", cleaned_code, flags=re.MULTILINE)
+        cleaned_code = re.sub(r"^import fleet$\n?", "", cleaned_code, flags=re.MULTILINE)
 
         # Define helper functions for verifier execution
         _TRANSLATOR = str.maketrans(string.punctuation, " " * len(string.punctuation))

{fleet_python-0.2.71 → fleet_python-0.2.72}/fleet/client.py

@@ -21,7 +21,8 @@ import httpx
 import json
 import logging
 import os
-from typing import List, Optional, Dict, Any, TYPE_CHECKING
+from typing import List, Optional, Dict, Any, TYPE_CHECKING, Union
+from urllib.parse import urlparse
 
 from .base import EnvironmentBase, SyncWrapper
 from .models import (
@@ -49,6 +50,11 @@ from .instance import (
     ResetResponse,
     ExecuteFunctionResponse,
 )
+from .instance.models import (
+    Resource as ResourceModel,
+    ResourceType,
+    ResourceMode,
+)
 from .config import (
     DEFAULT_MAX_RETRIES,
     DEFAULT_TIMEOUT,
@@ -71,6 +77,14 @@ class SyncEnv(EnvironmentBase):
         self._client = client
         self._apps: Dict[str, InstanceClient] = {}
         self._instance: Optional[InstanceClient] = None
+        self._manager_url_override: Optional[str] = None  # For URL mode
+
+    @property
+    def manager_url(self) -> str:
+        """Override to support URL mode where urls is None."""
+        if self._manager_url_override is not None:
+            return self._manager_url_override
+        return super().manager_url
 
     @property
     def instance(self) -> InstanceClient:
@@ -82,17 +96,17 @@ class SyncEnv(EnvironmentBase):
 
     def app(self, name: str) -> InstanceClient:
         if name not in self._apps:
-            # Extract base URL by removing the current app path (e.g., /sentry/api/v1/env)
-            # manager_url looks like: https://xxx.fleetai.com/sentry/api/v1/env
-            base_url = self.manager_url.split("/api/v1/env")[0]
-            # Remove the current app name (e.g., /sentry) to get the root
-            if "/" in base_url:
-                parts = base_url.rsplit("/", 1)
-                if len(parts) == 2 and parts[0] != "https:/":
-                    base_url = parts[0]
+            # Extract scheme://netloc from manager_url, then construct /{name}/api/v1/env
+            # Supports all URL formats:
+            #   https://host/api/v1/env -> https://host/{name}/api/v1/env
+            #   https://host/sentry/api/v1/env -> https://host/{name}/api/v1/env
+            #   http://localhost:8080/api/v1/env -> http://localhost:8080/{name}/api/v1/env
+            parsed = urlparse(self.manager_url)
+            root = f"{parsed.scheme}://{parsed.netloc}"
+            new_url = f"{root}/{name}/api/v1/env"
 
             self._apps[name] = InstanceClient(
-                f"{base_url}/{name}/api/v1/env",
+                new_url,
                 self._client.httpx_client if self._client else None,
             )
         return self._apps[name]
@@ -310,11 +324,165 @@ class Fleet:
             for instance_data in response.json()
         ]
 
-    def instance(self, instance_id: str) -> SyncEnv:
-        response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
-        instance = SyncEnv(client=self.client, **response.json())
-        instance.instance.load()
-        return instance
+    def instance(self, instance_id: Union[str, Dict[str, str]]) -> SyncEnv:
+        """Create or connect to an environment instance.
+
+        Supports three modes based on input type:
+        1. dict: Local filesystem mode - {"current": "./data.db", "seed": "./seed.db"}
+        2. str starting with http:// or https://: Localhost/URL mode
+        3. str (other): Remote cloud instance mode
+
+        Args:
+            instance_id: Instance identifier (str), URL (str starting with http://),
+                        or local db mapping (dict)
+
+        Returns:
+            SyncEnv: Environment instance
+        """
+        # Local filesystem mode - dict of resource names to file paths
+        if isinstance(instance_id, dict):
+            return self._create_local_instance(instance_id)
+
+        # Localhost/direct URL mode - string starting with http:// or https://
+        elif isinstance(instance_id, str) and instance_id.startswith(("http://", "https://")):
+            return self._create_url_instance(instance_id)
+
+        # Remote mode - existing behavior
+        else:
+            response = self.client.request("GET", f"/v1/env/instances/{instance_id}")
+            instance = SyncEnv(client=self.client, **response.json())
+            instance.instance.load()
+            return instance
+
+    def _create_url_instance(self, base_url: str) -> SyncEnv:
+        """Create instance connected to a direct URL (localhost or custom).
+
+        Args:
+            base_url: URL of the instance manager API
+
+        Returns:
+            SyncEnv: Environment instance configured for URL mode
+        """
+        instance_client = InstanceClient(url=base_url, httpx_client=self._httpx_client)
+
+        # Create a minimal environment for URL mode
+        env = SyncEnv(
+            client=self.client,
+            instance_id=base_url,
+            env_key="localhost",
+            version="",
+            status="running",
+            subdomain="localhost",
+            created_at="",
+            updated_at="",
+            terminated_at=None,
+            team_id="",
+            region="localhost",
+            env_variables=None,
+            data_key=None,
+            data_version=None,
+            urls=None,
+            health=None,
+        )
+        env._instance = instance_client
+        env._manager_url_override = base_url  # Set manager_url for URL mode
+        return env
+
+    @staticmethod
+    def _normalize_db_path(path: str) -> tuple[str, bool]:
+        """Normalize database path and detect if it's in-memory.
+
+        Args:
+            path: Database path - can be:
+                  - File path: "./data.db"
+                  - Plain memory: ":memory:"
+                  - Named memory: ":memory:namespace"
+                  - URI: "file:name?mode=memory&cache=shared"
+
+        Returns:
+            Tuple of (normalized_path, is_memory)
+        """
+        import uuid
+        import sqlite3
+
+        if path == ":memory:":
+            # Plain :memory: - create unique namespace
+            name = f"mem_{uuid.uuid4().hex[:8]}"
+            return f"file:{name}?mode=memory&cache=shared", True
+        elif path.startswith(":memory:"):
+            # Named memory: :memory:current -> file:current?mode=memory&cache=shared
+            namespace = path[8:]  # Remove ":memory:" prefix
+            return f"file:{namespace}?mode=memory&cache=shared", True
+        elif "mode=memory" in path:
+            # Already a proper memory URI
+            return path, True
+        else:
+            # Regular file path
+            return path, False
+
+    def _create_local_instance(self, dbs: Dict[str, str]) -> SyncEnv:
+        """Create instance with local file-based or in-memory SQLite resources.
+
+        Args:
+            dbs: Map of resource names to paths (e.g., {"current": "./data.db"} or
+                 {"current": ":memory:current"})
+
+        Returns:
+            SyncEnv: Environment instance configured for local mode
+        """
+        import sqlite3
+
+        instance_client = InstanceClient(url="local://", httpx_client=None)
+        instance_client._resources = []  # Mark as loaded
+        instance_client._memory_anchors = {}  # Store anchor connections for in-memory DBs
+
+        # Store creation parameters for local SQLiteResources
+        # This allows db() to create new instances each time (matching HTTP mode behavior)
+        for name, path in dbs.items():
+            # Normalize path and detect if it's in-memory
+            normalized_path, is_memory = self._normalize_db_path(path)
+
+            # Create anchor connection for in-memory databases
+            # This keeps the database alive as long as the env exists
+            if is_memory:
+                anchor_conn = sqlite3.connect(normalized_path, uri=True)
+                instance_client._memory_anchors[name] = anchor_conn
+
+            resource_model = ResourceModel(
+                name=name,
+                type=ResourceType.db,
+                mode=ResourceMode.rw,
+                label=f"Local: {path}",
+            )
+            instance_client._resources_state[ResourceType.db.value][name] = {
+                'type': 'local',
+                'resource_model': resource_model,
+                'db_path': normalized_path,
+                'is_memory': is_memory
+            }
+
+        # Create a minimal environment for local mode
+        env = SyncEnv(
+            client=self.client,
+            instance_id="local",
+            env_key="local",
+            version="",
+            status="running",
+            subdomain="local",
+            created_at="",
+            updated_at="",
+            terminated_at=None,
+            team_id="",
+            region="local",
+            env_variables=None,
+            data_key=None,
+            data_version=None,
+            urls=None,
+            health=None,
+        )
+        env._instance = instance_client
+        env._manager_url_override = "local://"  # Set manager_url for local mode
+        return env
 
     def check_bundle_exists(self, bundle_hash: str) -> VerifiersCheckResponse:
         return _check_bundle_exists(self.client, bundle_hash)