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

fleet/_async/env/client.py

@@ -1,5 +1,5 @@
 from ..client import AsyncFleet, AsyncEnv, Task
-from ...models import Environment as EnvironmentModel, AccountResponse, InstanceResponse
+from ...models import Environment as EnvironmentModel, AccountResponse, InstanceResponse, Run, HeartbeatResponse
 from typing import List, Optional, Dict, Any
 
 
@@ -11,6 +11,7 @@ async def make_async(
     image_type: Optional[str] = None,
     ttl_seconds: Optional[int] = None,
     run_id: Optional[str] = None,
+    heartbeat_interval: Optional[int] = None,
 ) -> AsyncEnv:
     return await AsyncFleet().make(
         env_key,
@@ -20,6 +21,7 @@ async def make_async(
         image_type=image_type,
         ttl_seconds=ttl_seconds,
         run_id=run_id,
+        heartbeat_interval=heartbeat_interval,
     )
 
 
@@ -36,9 +38,9 @@ async def list_regions_async() -> List[str]:
 
 
 async def list_instances_async(
-    status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None
+    status: Optional[str] = None, region: Optional[str] = None, run_id: Optional[str] = None, profile_id: Optional[str] = None
 ) -> List[AsyncEnv]:
-    return await AsyncFleet().instances(status=status, region=region, run_id=run_id)
+    return await AsyncFleet().instances(status=status, region=region, run_id=run_id, profile_id=profile_id)
 
 
 async def get_async(instance_id: str) -> AsyncEnv:
@@ -57,16 +59,45 @@ async def close_async(instance_id: str) -> InstanceResponse:
     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.
+async def close_all_async(run_id: Optional[str] = None, profile_id: Optional[str] = None) -> List[InstanceResponse]:
+    """Close (delete) instances using the batch delete endpoint.
     
     Args:
-        run_id: The run ID whose instances should be closed
+        run_id: Optional run ID to filter instances by
+        profile_id: Optional profile ID to filter instances by (use "self" for your own profile)
         
     Returns:
         List[InstanceResponse] containing the deleted instances
+        
+    Note:
+        At least one of run_id or profile_id must be provided.
+    """
+    return await AsyncFleet().close_all(run_id=run_id, profile_id=profile_id)
+
+
+async def list_runs_async(profile_id: Optional[str] = None, status: Optional[str] = "active") -> List[Run]:
+    """List all runs (groups of instances by run_id) with aggregated statistics.
+    
+    Args:
+        profile_id: Optional profile ID to filter runs by (use "self" for your own profile)
+        status: Filter by run status - "active" (default), "inactive", or "all"
+        
+    Returns:
+        List[Run] containing run information with instance counts and timestamps
+    """
+    return await AsyncFleet().list_runs(profile_id=profile_id, status=status)
+
+
+async def heartbeat_async(instance_id: str) -> HeartbeatResponse:
+    """Send heartbeat to keep instance alive (if heartbeat monitoring is enabled).
+    
+    Args:
+        instance_id: The instance ID to send heartbeat for
+        
+    Returns:
+        HeartbeatResponse containing heartbeat status and deadline information
     """
-    return await AsyncFleet().close_all(run_id)
+    return await AsyncFleet().heartbeat(instance_id)
 
 
 async def account_async() -> AccountResponse:

fleet/_async/instance/client.py

@@ -85,17 +85,9 @@ class AsyncInstanceClient:
         Returns:
             An SQLite database resource for the given database name
         """
-        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)
+        return AsyncSQLiteResource(
+            self._resources_state[ResourceType.db.value][name], self.client
+        )
 
     def browser(self, name: str) -> AsyncBrowserResource:
         return AsyncBrowserResource(
@@ -185,17 +177,10 @@ 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."""
-        self.close()
+        await self.close()

fleet/_async/resources/sqlite.py

@@ -6,7 +6,6 @@ from datetime import datetime
 import tempfile
 import sqlite3
 import os
-import asyncio
 
 from typing import TYPE_CHECKING
 
@@ -680,100 +679,17 @@ class AsyncQueryBuilder:
 
 
 class AsyncSQLiteResource(Resource):
-    def __init__(
-        self,
-        resource: ResourceModel,
-        client: Optional["AsyncWrapper"] = None,
-        db_path: Optional[str] = None,
-    ):
+    def __init__(self, resource: ResourceModel, client: "AsyncWrapper"):
         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:
@@ -785,15 +701,6 @@ 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",
@@ -802,62 +709,6 @@ 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/_async/tasks.py

@@ -215,13 +215,18 @@ class Task(BaseModel):
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
         run_id: Optional[str] = None,
+        heartbeat_interval: Optional[int] = 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, run_id=run_id
+            region=region,
+            image_type=image_type,
+            ttl_seconds=ttl_seconds,
+            run_id=run_id,
+            heartbeat_interval=heartbeat_interval,
         )
 
     async def make(
@@ -230,6 +235,7 @@ class Task(BaseModel):
         image_type: Optional[str] = None,
         ttl_seconds: Optional[int] = None,
         run_id: Optional[str] = None,
+        heartbeat_interval: Optional[int] = None,
     ):
         """Create an environment instance with task's configuration.
 
@@ -238,12 +244,14 @@ class Task(BaseModel):
         - data_key (data_id + data_version, if present)
         - env_variables (if present)
         - run_id (if present)
+        - heartbeat_interval (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
+            heartbeat_interval: Optional heartbeat interval in seconds (30-3600)
 
         Returns:
             Environment instance configured for this task
@@ -251,7 +259,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", run_id="my-batch-123")
+            env = await task.make(region="us-west-2", run_id="my-batch-123", heartbeat_interval=60)
         """
         if not self.env_id:
             raise ValueError("Task has no env_id defined")
@@ -267,6 +275,7 @@ class Task(BaseModel):
             image_type=image_type,
             ttl_seconds=ttl_seconds,
             run_id=run_id,
+            heartbeat_interval=heartbeat_interval,
         )
 
 
@@ -295,11 +304,8 @@ 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
-        # 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)
+        cleaned_code = re.sub(r"from fleet import.*verifier.*\n", "", cleaned_code)
+        cleaned_code = re.sub(r"import.*verifier.*\n", "", cleaned_code)
 
         # Create a local namespace for executing the code
         local_namespace = {

fleet/_async/verifiers/bundler.py

@@ -37,7 +37,7 @@ class FunctionBundler:
     ) -> bytes:
         """Create a function bundle with statically extracted code."""
 
-        logger.info(f"Creating function bundle for {func.__name__}")
+        # logger.info(f"Creating function bundle for {func.__name__}")
 
         # 1. Parse the main function and find dependencies
         mod_file = Path(func.__code__.co_filename)
@@ -115,7 +115,7 @@ class FunctionBundler:
 
         # Find function calls within the verifier function
         called_functions = self._extract_function_calls(main_func_ast)
-        logger.debug(f"Functions called in verifier: {called_functions}")
+        # logger.debug(f"Functions called in verifier: {called_functions}")
 
         # Find all functions defined in the module
         module_functions = {}
@@ -128,7 +128,7 @@ class FunctionBundler:
         for func_name in called_functions:
             if func_name in module_functions and func_name != func.__name__:
                 same_module_deps.append(func_name)
-                logger.debug(f"Found same-module dependency: {func_name}")
+                # logger.debug(f"Found same-module dependency: {func_name}")
 
         # Separate local and external imports
         local_imports = {}
@@ -292,7 +292,7 @@ class FunctionBundler:
                     code = ast.unparse(node)
                     extracted_code.append(code)
                 except Exception as e:
-                    logger.warning(f"Could not unparse AST node: {e}")
+                    # logger.warning(f"Could not unparse AST node: {e}")
                     # Fallback to original source extraction
                     lines = content.split("\n")
                     start_line = node.lineno - 1
@@ -305,11 +305,11 @@ class FunctionBundler:
                     extracted_code.append(code)
 
             result = "\n\n".join(extracted_code)
-            logger.debug(f"Extracted {len(extracted_code)} items from {file_path}")
+            # logger.debug(f"Extracted {len(extracted_code)} items from {file_path}")
             return result
 
         except Exception as e:
-            logger.warning(f"Failed to extract functions from {file_path}: {e}")
+            # logger.warning(f"Failed to extract functions from {file_path}: {e}")
             # Fallback to including the entire file
             with open(file_path, "r", encoding="utf-8") as f:
                 return f.read()
@@ -464,14 +464,14 @@ class FunctionBundler:
                 version = dist.version  # Get the installed version
                 package_with_version = f"{package_name}=={version}"
                 packages.add(package_with_version)
-                logger.debug(f"Mapped {mod} -> {package_with_version}")
+                # logger.debug(f"Mapped {mod} -> {package_with_version}")
             except imd.PackageNotFoundError:
                 # Skip stdlib or local modules
-                logger.debug(f"Skipping {mod} (stdlib or local)")
+                # logger.debug(f"Skipping {mod} (stdlib or local)")
                 continue
 
         package_list = list(packages)
-        logger.debug(f"Final package list: {package_list}")
+        # logger.debug(f"Final package list: {package_list}")
         return package_list
 
     def _merge_requirements(
@@ -511,10 +511,10 @@ class FunctionBundler:
             if pkg_name not in seen_packages:
                 final_requirements.append(req)
                 seen_packages.add(pkg_name)
-            else:
-                logger.debug(
-                    f"Skipping auto-detected {req}, using explicit version instead"
-                )
+            # else:
+            #     logger.debug(
+            #         f"Skipping auto-detected {req}, using explicit version instead"
+            #     )
 
         # Always ensure fleet-python is included
         if "fleet-python" not in seen_packages:
@@ -565,9 +565,9 @@ class FunctionBundler:
                         )
                         if dep_src:
                             same_module_code += f"\n{dep_src}\n"
-                            logger.debug(
-                                f"Extracted same-module dependency: {dep_name}"
-                            )
+                            # logger.debug(
+                            #     f"Extracted same-module dependency: {dep_name}"
+                            # )
 
                 # Create verifier.py with the main function
                 verifier_file = build_dir / "verifier.py"
@@ -586,7 +586,7 @@ class FunctionBundler:
 {code}
 """
                     dest_path.write_text(extracted_content)
-                    logger.debug(f"Created extracted file: {relative_path}")
+                    # logger.debug(f"Created extracted file: {relative_path}")
 
                     # Ensure __init__.py files exist
                     self._ensure_init_files(Path(relative_path), build_dir)
@@ -595,7 +595,7 @@ class FunctionBundler:
                 return self._create_zip_bundle(build_dir)
 
             except Exception as e:
-                logger.error(f"Failed to build function bundle: {e}")
+                # logger.error(f"Failed to build function bundle: {e}")
                 raise RuntimeError(f"Function bundle creation failed: {e}")
 
     def _ensure_init_files(self, rel_path: Path, build_dir: Path):
@@ -607,7 +607,7 @@ class FunctionBundler:
             if not init_file.exists():
                 init_file.parent.mkdir(parents=True, exist_ok=True)
                 init_file.write_text("# Auto-generated __init__.py")
-                logger.debug(f"Created __init__.py: {current}")
+                # logger.debug(f"Created __init__.py: {current}")
             current = current.parent
 
     def _create_zip_bundle(self, build_dir: Path) -> bytes:
@@ -621,7 +621,7 @@ class FunctionBundler:
                     zf.write(file_path, arcname)
 
         bundle_size = len(zip_buffer.getvalue())
-        logger.debug(f"Created function bundle ({bundle_size:,} bytes)")
+        # logger.debug(f"Created function bundle ({bundle_size:,} bytes)")
         return zip_buffer.getvalue()
 
     def _extract_function_source(
@@ -662,7 +662,8 @@ class FunctionBundler:
                     return "\n".join(func_lines)
 
         except Exception as e:
-            logger.warning(f"Failed to extract function {function_name}: {e}")
+            # logger.warning(f"Failed to extract function {function_name}: {e}")
+            pass
 
         return None
 

fleet/_async/verifiers/verifier.py

@@ -79,9 +79,9 @@ class AsyncVerifierFunction:
 
                 self._bundle_data = zip_buffer.getvalue()
                 self._bundle_sha = _get_bundle_sha(self._bundle_data)
-                logger.debug(
-                    f"Created bundle from raw code for {self.key} with SHA: {self._bundle_sha}"
-                )
+                # logger.debug(
+                #     f"Created bundle from raw code for {self.key} with SHA: {self._bundle_sha}"
+                # )
             else:
                 # Try to create bundle from function source
                 try:
@@ -89,9 +89,9 @@ class AsyncVerifierFunction:
                         self.func, self.extra_requirements, self.verifier_id
                     )
                     self._bundle_sha = _get_bundle_sha(self._bundle_data)
-                    logger.debug(
-                        f"Created bundle for {self.key} with SHA: {self._bundle_sha}"
-                    )
+                    # logger.debug(
+                    #     f"Created bundle for {self.key} with SHA: {self._bundle_sha}"
+                    # )
                 except OSError as e:
                     # Can't create bundle - no source and no raw code
                     raise OSError(f"Cannot create bundle for {self.key}: {e}")
@@ -104,20 +104,21 @@ class AsyncVerifierFunction:
 
         # If bundle_data is empty, we're using server-side bundle
         if not bundle_data:
-            logger.debug(f"Using server-side bundle {bundle_sha[:8]}...")
+            # logger.debug(f"Using server-side bundle {bundle_sha[:8]}...")
             return bundle_sha, False  # No upload needed, server has it
 
         # Always check if bundle exists on server
         try:
             exists = await env.check_bundle_exists(bundle_sha)
             if exists.success:
-                logger.info(f"Bundle {bundle_sha[:8]}... found on server")
+                # logger.info(f"Bundle {bundle_sha[:8]}... found on server")
                 return bundle_sha, False  # Found on server, no upload needed
         except Exception as e:
-            logger.warning(f"Failed to check bundle existence: {e}")
+            # logger.warning(f"Failed to check bundle existence: {e}")
+            pass
 
         # Bundle not found on server - upload needed
-        logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
+        # logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
         return bundle_sha, True  # Upload needed
 
     async def __call__(self, env: AsyncEnv, *args, **kwargs) -> float:
@@ -147,7 +148,7 @@ class AsyncVerifierFunction:
                     )
 
         except Exception as e:
-            logger.error(f"Error in verifier {self.key}: {e}")
+            # logger.error(f"Error in verifier {self.key}: {e}")
             # Return error score 0
             return 0.0
 
@@ -179,7 +180,7 @@ class AsyncVerifierFunction:
                 try:
                     return float(result)
                 except (ValueError, TypeError):
-                    logger.warning(f"Could not convert result to float: {result}")
+                    # logger.warning(f"Could not convert result to float: {result}")
                     return 0.0
 
     def _raise_remote_error(self, error_info: Dict[str, Any]):
@@ -238,7 +239,7 @@ Remote traceback:
 
             if needs_upload:
                 # Need to upload bundle to S3
-                logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
+                # logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
                 bundle_data, _ = self._get_or_create_bundle()
 
                 response = await env.execute_verifier_remote(
@@ -252,11 +253,11 @@ Remote traceback:
                     needs_upload=True,
                 )
 
-                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
+                # logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
 
             else:
                 # Bundle already available - execute without upload
-                logger.info(f"Bundle {bundle_sha[:8]}... already cached for {self.key}")
+                # logger.info(f"Bundle {bundle_sha[:8]}... already cached for {self.key}")
                 response = await env.execute_verifier_remote(
                     bundle_data=b"",  # Empty bundle since it's cached
                     bundle_sha=bundle_sha,
@@ -273,9 +274,9 @@ Remote traceback:
         except Exception as e:
             # Check if error indicates bundle not found and retry with upload
             if self._is_bundle_not_found_error(e) and not needs_upload:
-                logger.info(
-                    f"Bundle {bundle_sha[:8]}... not found on server, uploading..."
-                )
+                # logger.info(
+                #     f"Bundle {bundle_sha[:8]}... not found on server, uploading..."
+                # )
                 bundle_data, _ = self._get_or_create_bundle()
                 response = await env.execute_verifier_remote(
                     bundle_data=bundle_data,
@@ -289,7 +290,7 @@ Remote traceback:
                 )
                 return response
             else:
-                logger.error(f"Error in remote execution of {self.key}: {e}")
+                # logger.error(f"Error in remote execution of {self.key}: {e}")
                 raise