fleet-python 0.2.67__py3-none-any.whl → 0.2.69b2__py3-none-any.whl

fleet/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, SyncWrapper
 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 Fleet:
         env_variables: Optional[Dict[str, Any]] = None,
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
+        run_id: Optional[str] = None,
     ) -> SyncEnv:
         if ":" in env_key:
             env_key_part, env_version = env_key.split(":", 1)
@@ -247,6 +253,7 @@ class Fleet:
             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 Fleet:
         return self.make(env_key=f"{task.env_id}:{task.version}")
 
     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[SyncEnv]:
         params = {}
         if status:
             params["status"] = status
         if region:
             params["region"] = region
+        if run_id:
+            params["run_id"] = run_id
 
         response = self.client.request("GET", "/v1/env/instances", params=params)
         return [
@@ -283,11 +292,163 @@ 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
+        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
+        return env
 
     def check_bundle_exists(self, bundle_hash: str) -> VerifiersCheckResponse:
         return _check_bundle_exists(self.client, bundle_hash)
@@ -300,6 +461,28 @@ class Fleet:
     def delete(self, instance_id: str) -> InstanceResponse:
         return _delete_instance(self.client, instance_id)
 
+    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 _delete_instance(self.client, instance_id)
+
+    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 _delete_instances_by_run_id(self.client, run_id)
+
     def load_tasks_from_file(self, filename: str) -> List[Task]:
         with open(filename, "r", encoding="utf-8") as f:
             tasks_data = f.read()
@@ -810,6 +993,11 @@ def _delete_instance(client: SyncWrapper, instance_id: str) -> InstanceResponse:
     return InstanceResponse(**response.json())
 
 
+def _delete_instances_by_run_id(client: SyncWrapper, run_id: str) -> List[InstanceResponse]:
+    response = client.request("DELETE", f"/v1/env/instances/run/{run_id}")
+    return [InstanceResponse(**instance_data) for instance_data in response.json()]
+
+
 def _check_bundle_exists(
     client: SyncWrapper, bundle_hash: str
 ) -> VerifiersCheckResponse:

fleet/env/__init__.py

@@ -7,6 +7,8 @@ from .client import (
     list_regions,
     get,
     list_instances,
+    close,
+    close_all,
     account,
 )
 
@@ -17,6 +19,8 @@ from .._async.env.client import (
     list_regions_async,
     get_async,
     list_instances_async,
+    close_async,
+    close_all_async,
     account_async,
 )
 
@@ -27,11 +31,15 @@ __all__ = [
     "list_regions",
     "list_instances",
     "get",
+    "close",
+    "close_all",
     "make_async",
     "list_envs_async",
     "list_regions_async",
     "list_instances_async",
     "get_async",
+    "close_async",
+    "close_all_async",
     "account",
     "account_async",
 ]

fleet/env/client.py

@@ -1,5 +1,5 @@
 from ..client import Fleet, SyncEnv, 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 @@ def make(
     env_variables: Optional[Dict[str, Any]] = None,
     image_type: Optional[str] = None,
     ttl_seconds: Optional[int] = None,
+    run_id: Optional[str] = None,
 ) -> SyncEnv:
     return Fleet().make(
         env_key,
@@ -18,6 +19,7 @@ def make(
         env_variables=env_variables,
         image_type=image_type,
         ttl_seconds=ttl_seconds,
+        run_id=run_id,
     )
 
 
@@ -34,14 +36,38 @@ def list_regions() -> List[str]:
 
 
 def list_instances(
-    status: Optional[str] = None, region: Optional[str] = None
+    status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
 ) -> List[SyncEnv]:
-    return Fleet().instances(status=status, region=region)
+    return Fleet().instances(status=status, region=region, run_id=run_id)
 
 
 def get(instance_id: str) -> SyncEnv:
     return Fleet().instance(instance_id)
 
 
+def close(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 Fleet().close(instance_id)
+
+
+def close_all(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 Fleet().close_all(run_id)
+
+
 def account() -> AccountResponse:
     return Fleet().account()

fleet/instance/client.py

@@ -83,9 +83,17 @@ class InstanceClient:
         Returns:
             An SQLite database resource for the given database name
         """
-        return SQLiteResource(
-            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 SQLiteResource(
+                resource_info['resource_model'],
+                client=None,
+                db_path=resource_info['db_path']
+            )
+        # HTTP mode - resource_info is a ResourceModel, create new wrapper
+        return SQLiteResource(resource_info, self.client)
 
     def browser(self, name: str) -> BrowserResource:
         return BrowserResource(
@@ -175,10 +183,17 @@ class InstanceClient:
         response = 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()
+
     def __enter__(self):
-        """Async context manager entry."""
+        """Context manager entry."""
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit."""
+        """Context manager exit."""
         self.close()

fleet/models.py

@@ -51,6 +51,7 @@ class Instance(BaseModel):
     team_id: str = Field(..., title="Team Id")
     region: str = Field(..., title="Region")
     env_variables: Optional[Dict[str, Any]] = Field(None, title="Env Variables")
+    run_id: Optional[str] = Field(None, title="Run Id")
 
 
 class InstanceRequest(BaseModel):
@@ -363,6 +364,7 @@ class InstanceResponse(BaseModel):
     data_version: Optional[str] = Field(None, title="Data Version")
     urls: Optional[InstanceURLs] = Field(None, title="Urls")
     health: Optional[bool] = Field(None, title="Health")
+    run_id: Optional[str] = Field(None, title="Run Id")
 
 
 class AccountResponse(BaseModel):

fleet/resources/sqlite.py

@@ -675,17 +675,97 @@ class SyncQueryBuilder:
 
 
 class SQLiteResource(Resource):
-    def __init__(self, resource: ResourceModel, client: "SyncWrapper"):
+    def __init__(
+        self,
+        resource: ResourceModel,
+        client: Optional["SyncWrapper"] = 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
 
     def describe(self) -> DescribeResponse:
         """Describe the SQLite database schema."""
+        if self._mode == "direct":
+            return self._describe_direct()
+        else:
+            return self._describe_http()
+
+    def _describe_http(self) -> DescribeResponse:
+        """Describe database schema via HTTP API."""
         response = self.client.request(
             "GET", f"/resources/sqlite/{self.resource.name}/describe"
         )
         return DescribeResponse(**response.json())
 
+    def _describe_direct(self) -> DescribeResponse:
+        """Describe database schema from local file or in-memory database."""
+        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)}",
+            )
+
     def query(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
         return self._query(query, args, read_only=True)
 
@@ -695,6 +775,15 @@ class SQLiteResource(Resource):
     def _query(
         self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
     ) -> QueryResponse:
+        if self._mode == "direct":
+            return self._query_direct(query, args, read_only)
+        else:
+            return self._query_http(query, args, read_only)
+
+    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 = self.client.request(
             "POST",
@@ -703,6 +792,59 @@ class SQLiteResource(Resource):
         )
         return QueryResponse(**response.json())
 
+    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."""
+        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)}",
+            )
+
     def table(self, table_name: str) -> SyncQueryBuilder:
         """Create a query builder for the specified table."""
         return SyncQueryBuilder(self, table_name)

fleet/tasks.py

@@ -207,18 +207,20 @@ 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 self.make(region=region, image_type=image_type, ttl_seconds=ttl_seconds)
+        return self.make(region=region, image_type=image_type, ttl_seconds=ttl_seconds, run_id=run_id)
 
     def make(
         self,
         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.
 
@@ -226,11 +228,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
@@ -238,7 +242,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 = task.make(region="us-west-2")
+            env = task.make(region="us-west-2", run_id="my-batch-123")
         """
         if not self.env_id:
             raise ValueError("Task has no env_id defined")
@@ -253,6 +257,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,
         )
 
 
@@ -281,8 +286,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 globals namespace with all required imports
         exec_globals = globals().copy()

{fleet_python-0.2.67.dist-info → fleet_python-0.2.69b2.dist-info}/METADATA

@@ -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