fleet-python 0.2.67__tar.gz → 0.2.69b2__tar.gz

{fleet_python-0.2.67/fleet_python.egg-info → fleet_python-0.2.69b2}/PKG-INFO

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

{fleet_python-0.2.67 → fleet_python-0.2.69b2}/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 (
@@ -47,6 +47,11 @@ from .instance import (
     ResetResponse,
     ExecuteFunctionResponse,
 )
+from ..instance.models import (
+    Resource as ResourceModel,
+    ResourceType,
+    ResourceMode,
+)
 from ..config import (
     DEFAULT_MAX_RETRIES,
     DEFAULT_TIMEOUT,
@@ -212,6 +217,7 @@ class AsyncFleet:
         env_variables: Optional[Dict[str, Any]] = None,
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
     ) -> AsyncEnv:
         if ":" in env_key:
             env_key_part, env_version = env_key.split(":", 1)
@@ -247,6 +253,7 @@ class AsyncFleet:
             image_type=image_type,
             created_from="sdk",
             ttl_seconds=ttl_seconds,
+            run_id=run_id,
         )
 
         # Only use region-specific base URL if no custom base URL is set
@@ -269,13 +276,15 @@ class AsyncFleet:
         return await self.make(env_key=f"{task.env_id}:{task.version}")
 
     async def instances(
-        self, status: Optional[str] = None, region: Optional[str] = None
+        self, status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
     ) -> List[AsyncEnv]:
         params = {}
         if status:
             params["status"] = status
         if region:
             params["region"] = region
+        if run_id:
+            params["run_id"] = run_id
 
         response = await self.client.request("GET", "/v1/env/instances", params=params)
         return [
@@ -283,11 +292,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)
@@ -302,6 +463,28 @@ class AsyncFleet:
     async def delete(self, instance_id: str) -> InstanceResponse:
         return await _delete_instance(self.client, instance_id)
 
+    async def close(self, instance_id: str) -> InstanceResponse:
+        """Close (delete) a specific instance by ID.
+        
+        Args:
+            instance_id: The instance ID to close
+            
+        Returns:
+            InstanceResponse containing the deleted instance details
+        """
+        return await _delete_instance(self.client, instance_id)
+
+    async def close_all(self, run_id: str) -> List[InstanceResponse]:
+        """Close (delete) all instances associated with a run_id.
+        
+        Args:
+            run_id: The run ID whose instances should be closed
+            
+        Returns:
+            List[InstanceResponse] containing the deleted instances
+        """
+        return await _delete_instances_by_run_id(self.client, run_id)
+
     async def load_tasks_from_file(self, filename: str) -> List[Task]:
         with open(filename, "r", encoding="utf-8") as f:
             tasks_data = f.read()
@@ -811,6 +994,11 @@ async def _delete_instance(client: AsyncWrapper, instance_id: str) -> InstanceRe
     return InstanceResponse(**response.json())
 
 
+async def _delete_instances_by_run_id(client: AsyncWrapper, run_id: str) -> List[InstanceResponse]:
+    response = await client.request("DELETE", f"/v1/env/instances/run/{run_id}")
+    return [InstanceResponse(**instance_data) for instance_data in response.json()]
+
+
 async def _check_bundle_exists(
     client: AsyncWrapper, bundle_hash: str
 ) -> VerifiersCheckResponse:

{fleet_python-0.2.67 → fleet_python-0.2.69b2}/fleet/_async/env/client.py

@@ -1,5 +1,5 @@
 from ..client import AsyncFleet, AsyncEnv, Task
-from ...models import Environment as EnvironmentModel, AccountResponse
+from ...models import Environment as EnvironmentModel, AccountResponse, InstanceResponse
 from typing import List, Optional, Dict, Any
 
 
@@ -10,6 +10,7 @@ async def make_async(
     env_variables: Optional[Dict[str, Any]] = None,
     image_type: Optional[str] = None,
     ttl_seconds: Optional[int] = None,
+    run_id: Optional[str] = None,
 ) -> AsyncEnv:
     return await AsyncFleet().make(
         env_key,
@@ -18,6 +19,7 @@ async def make_async(
         env_variables=env_variables,
         image_type=image_type,
         ttl_seconds=ttl_seconds,
+        run_id=run_id,
     )
 
 
@@ -34,14 +36,38 @@ async def list_regions_async() -> List[str]:
 
 
 async def list_instances_async(
-    status: Optional[str] = None, region: Optional[str] = None
+    status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
 ) -> List[AsyncEnv]:
-    return await AsyncFleet().instances(status=status, region=region)
+    return await AsyncFleet().instances(status=status, region=region, run_id=run_id)
 
 
 async def get_async(instance_id: str) -> AsyncEnv:
     return await AsyncFleet().instance(instance_id)
 
 
+async def close_async(instance_id: str) -> InstanceResponse:
+    """Close (delete) a specific instance by ID.
+    
+    Args:
+        instance_id: The instance ID to close
+        
+    Returns:
+        InstanceResponse containing the deleted instance details
+    """
+    return await AsyncFleet().close(instance_id)
+
+
+async def close_all_async(run_id: str) -> List[InstanceResponse]:
+    """Close (delete) all instances associated with a run_id.
+    
+    Args:
+        run_id: The run ID whose instances should be closed
+        
+    Returns:
+        List[InstanceResponse] containing the deleted instances
+    """
+    return await AsyncFleet().close_all(run_id)
+
+
 async def account_async() -> AccountResponse:
     return await AsyncFleet().account()

{fleet_python-0.2.67 → fleet_python-0.2.69b2}/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.67 → fleet_python-0.2.69b2}/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.67 → fleet_python-0.2.69b2}/fleet/_async/tasks.py

@@ -214,13 +214,14 @@ class Task(BaseModel):
         region: Optional[str] = None,
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
     ):
         """Create an environment instance for this task's environment.
 
         Alias for make() method. Uses the task's env_id (and version if present) to create the env.
         """
         return await self.make(
-            region=region, image_type=image_type, ttl_seconds=ttl_seconds
+            region=region, image_type=image_type, ttl_seconds=ttl_seconds, run_id=run_id
         )
 
     async def make(
@@ -228,6 +229,7 @@ class Task(BaseModel):
         region: Optional[str] = None,
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
     ):
         """Create an environment instance with task's configuration.
 
@@ -235,11 +237,13 @@ class Task(BaseModel):
         - env_key (env_id + version)
         - data_key (data_id + data_version, if present)
         - env_variables (if present)
+        - run_id (if present)
 
         Args:
             region: Optional AWS region for the environment
             image_type: Optional image type for the environment
             ttl_seconds: Optional TTL in seconds for the instance
+            run_id: Optional run ID to group instances
 
         Returns:
             Environment instance configured for this task
@@ -247,7 +251,7 @@ class Task(BaseModel):
         Example:
             task = fleet.Task(key="my-task", prompt="...", env_id="my-env",
                             data_id="my-data", data_version="v1.0")
-            env = await task.make(region="us-west-2")
+            env = await task.make(region="us-west-2", run_id="my-batch-123")
         """
         if not self.env_id:
             raise ValueError("Task has no env_id defined")
@@ -262,6 +266,7 @@ class Task(BaseModel):
             env_variables=self.env_variables if self.env_variables else None,
             image_type=image_type,
             ttl_seconds=ttl_seconds,
+            run_id=run_id,
         )
 
 
@@ -290,8 +295,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)
 
         # Create a local namespace for executing the code
         local_namespace = {