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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.67
+Version: 0.2.69
 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.69}/fleet/_async/base.py

@@ -48,7 +48,7 @@ class BaseWrapper:
         import logging
 
         logger = logging.getLogger(__name__)
-        logger.debug(f"Headers being sent: {headers}")
+        # logger.debug(f"Headers being sent: {headers}")
         return headers
 
 
@@ -93,8 +93,9 @@ class AsyncWrapper(BaseWrapper):
 
         # Debug log 500 errors
         if status_code == 500:
-            logger.error(f"Got 500 error from {response.url}")
-            logger.error(f"Response text: {response.text}")
+            # logger.error(f"Got 500 error from {response.url}")
+            # logger.error(f"Response text: {response.text}")
+            pass
 
         # Try to parse error response as JSON
         try:

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

@@ -212,6 +212,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 +248,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 +271,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 [
@@ -302,6 +306,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()
@@ -380,8 +406,8 @@ class AsyncFleet:
             error_msg = f"Failed to create verifier {task_json.get('key', task_json.get('id'))}: {e}"
             if raise_on_verifier_error:
                 raise ValueError(error_msg) from e
-            else:
-                logger.warning(error_msg)
+            # else:
+            #     logger.warning(error_msg)
 
         task = Task(
             key=task_json.get("key", task_json.get("id")),
@@ -473,25 +499,25 @@ class AsyncFleet:
                                     verifier_sha=tr.verifier.sha256,
                                 )
                             except Exception as e:
-                                logger.warning(
-                                    f"Failed to create verifier {tr.verifier.key}: {e}"
-                                )
+                                # logger.warning(
+                                #     f"Failed to create verifier {tr.verifier.key}: {e}"
+                                # )
                                 return None
                         else:
                             # Fallback: try fetching by ID
                             try:
-                                logger.warning(
-                                    f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
-                                    f"Attempting to refetch by id {tr.verifier.verifier_id}"
-                                )
+                                # logger.warning(
+                                #     f"Embedded verifier code missing for {tr.verifier.key} (NoSuchKey). "
+                                #     f"Attempting to refetch by id {tr.verifier.verifier_id}"
+                                # )
                                 return await self._load_verifier(
                                     tr.verifier.verifier_id
                                 )
                             except Exception as e:
-                                logger.warning(
-                                    f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
-                                    "Leaving verifier unset."
-                                )
+                                # logger.warning(
+                                #     f"Refetch by verifier id failed for {tr.verifier.key}: {e}. "
+                                #     "Leaving verifier unset."
+                                # )
                                 return None
 
                 # Add the coroutine for parallel execution
@@ -530,9 +556,10 @@ class AsyncFleet:
             if task_response.verifier:
                 # Process verifier result
                 if isinstance(verifier_result, Exception):
-                    logger.warning(
-                        f"Verifier loading failed for {task_response.key}: {verifier_result}"
-                    )
+                    # logger.warning(
+                    #     f"Verifier loading failed for {task_response.key}: {verifier_result}"
+                    # )
+                    pass
                 elif verifier_result is not None:
                     verifier = verifier_result
                     embedded_code = task_response.verifier.code or ""
@@ -606,10 +633,10 @@ class AsyncFleet:
             with open(filename, "w", encoding="utf-8") as f:
                 json.dump(tasks_data, f, indent=2, default=str)
 
-            logger.info(f"Exported {len(tasks)} tasks to {filename}")
+            # logger.info(f"Exported {len(tasks)} tasks to {filename}")
             return filename
         else:
-            logger.info("No tasks found to export")
+            # logger.info("No tasks found to export")
             return None
 
     async def import_single_task(self, task: Task, project_key: Optional[str] = None):
@@ -638,7 +665,7 @@ class AsyncFleet:
             )
             return response
         except Exception as e:
-            logger.error(f"Failed to import task {task.key}: {e}")
+            # logger.error(f"Failed to import task {task.key}: {e}")
             return None
 
     async def import_tasks(self, filename: str, project_key: Optional[str] = None):
@@ -811,6 +838,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:
@@ -853,17 +885,17 @@ async def _execute_verifier_remote(
         request_data["bundle"] = bundle_b64
 
     # Debug logging
-    logger.debug(
-        f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
-    )
-    logger.debug(f"Request has bundle: {needs_upload}")
-    logger.debug(f"Using client with base_url: {client.base_url}")
-    logger.debug(f"Request data keys: {list(request_data.keys())}")
-    logger.debug(
-        f"Bundle size: {len(request_data.get('bundle', ''))} chars"
-        if "bundle" in request_data
-        else "No bundle"
-    )
+    # logger.debug(
+    #     f"Sending verifier execute request: key={key}, sha256={bundle_sha[:8]}..., function_name={function_name}"
+    # )
+    # logger.debug(f"Request has bundle: {needs_upload}")
+    # logger.debug(f"Using client with base_url: {client.base_url}")
+    # logger.debug(f"Request data keys: {list(request_data.keys())}")
+    # logger.debug(
+    #     f"Bundle size: {len(request_data.get('bundle', ''))} chars"
+    #     if "bundle" in request_data
+    #     else "No bundle"
+    # )
 
     # Note: This should be called on the instance URL, not the orchestrator
     # The instance has manager URLs for verifier execution
@@ -871,6 +903,6 @@ async def _execute_verifier_remote(
 
     # Debug the response
     response_json = response.json()
-    logger.debug(f"Verifier execute response: {response_json}")
+    # logger.debug(f"Verifier execute response: {response_json}")
 
     return VerifiersExecuteResponse(**response_json)

{fleet_python-0.2.67 → fleet_python-0.2.69}/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.69}/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,
         )
 
 

{fleet_python-0.2.67 → fleet_python-0.2.69}/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_python-0.2.67 → fleet_python-0.2.69}/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
 
 

{fleet_python-0.2.67 → fleet_python-0.2.69}/fleet/base.py

@@ -48,7 +48,7 @@ class BaseWrapper:
         import logging
 
         logger = logging.getLogger(__name__)
-        logger.debug(f"Headers being sent: {headers}")
+        # logger.debug(f"Headers being sent: {headers}")
         return headers
 
 
@@ -93,8 +93,9 @@ class SyncWrapper(BaseWrapper):
 
         # Debug log 500 errors
         if status_code == 500:
-            logger.error(f"Got 500 error from {response.url}")
-            logger.error(f"Response text: {response.text}")
+            # logger.error(f"Got 500 error from {response.url}")
+            # logger.error(f"Response text: {response.text}")
+            pass
 
         # Try to parse error response as JSON
         try: