fleet-python 0.2.29__py3-none-any.whl → 0.2.32__py3-none-any.whl

fleet/_async/tasks.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import re
 from datetime import datetime
-from typing import Any, Dict, Optional
+from typing import Any, Dict, Optional, List
 from uuid import UUID
 
 from pydantic import BaseModel, Field, validator
@@ -15,31 +15,39 @@ from fleet.types import VerifierFunction
 
 class Task(BaseModel):
     """A task model representing a single task in the Fleet system."""
-    
+
     key: str = Field(..., description="Unique task key identifier")
     prompt: str = Field(..., description="Task prompt or instruction")
     env_id: str = Field(..., description="Environment identifier")
-    env_variables: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Environment variables")
+    env_variables: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Environment variables"
+    )
     created_at: Optional[datetime] = Field(None, description="Task creation timestamp")
     version: Optional[str] = Field(None, description="Task version")
     verifier_func: Optional[str] = Field(None, description="Verifier function code")
-    verifier: Optional[Any] = Field(None, description="Verifier function with decorator (async or sync)")
+    verifier: Optional[Any] = Field(
+        None, description="Verifier function with decorator (async or sync)"
+    )
     verifier_id: Optional[str] = Field(None, description="Verifier identifier")
     verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
-    metadata: Optional[Dict[str, Any]] = Field(default_factory=dict, description="Additional task metadata")
+    metadata: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Additional task metadata"
+    )
 
-    @validator('key')
+    @validator("key")
     def validate_key_format(cls, v):
         """Validate key follows kebab-case format."""
-        if not re.match(r'^[a-z0-9]+(-[a-z0-9]+)*$', v):
-            raise ValueError(f'Invalid task key format: {v}. Must follow kebab-case format.')
+        if not re.match(r"^[a-z0-9]+(-[a-z0-9]+)*$", v):
+            raise ValueError(
+                f"Invalid task key format: {v}. Must follow kebab-case format."
+            )
         return v
 
-    @validator('created_at', pre=True, always=True)
+    @validator("created_at", pre=True, always=True)
     def set_created_at(cls, v):
         """Set created_at to current time if not provided."""
         return v or datetime.now()
-    
+
     @property
     def env_key(self) -> str:
         """Get the environment key combining env_id and version."""
@@ -49,24 +57,25 @@ class Task(BaseModel):
 
     class Config:
         """Pydantic model configuration."""
+
         json_encoders = {
             datetime: lambda v: v.isoformat(),
         }
         # Allow arbitrary types for the verifier field
-        arbitrary_types_allowed = True 
+        arbitrary_types_allowed = True
 
     def verify(self, env, *args, **kwargs) -> float:
         """Verify the task using the verifier function (sync version).
-        
+
         For sync environments, calls the sync verifier directly.
         For async verifiers, automatically runs them with asyncio.run().
         """
         if self.verifier:
             import asyncio
             import inspect
-            
+
             result = self.verifier.remote(env, *args, **kwargs)
-            
+
             # If the result is a coroutine, we need to run it
             if inspect.iscoroutine(result):
                 # Check if we're already in an event loop
@@ -84,10 +93,10 @@ class Task(BaseModel):
                 return result
         else:
             raise ValueError("No verifier function found for this task")
-    
+
     async def verify_async(self, *args, **kwargs) -> float:
         """Verify the task using the verifier function (async version).
-        
+
         For async environments, awaits the async verifier.
         Works with both sync and async verifiers in async contexts.
         """
@@ -95,9 +104,53 @@ class Task(BaseModel):
             result = self.verifier.remote(*args, **kwargs)
             # If it's a coroutine, await it
             import inspect
+
             if inspect.iscoroutine(result):
                 return await result
             else:
                 return result
         else:
             raise ValueError("No verifier function found for this task")
+
+    async def make_env(self, region: Optional[str] = None):
+        """Create an environment instance for this task's environment.
+
+        Uses the task's env_id (and version if present) to create the env.
+        """
+        if not self.env_id:
+            raise ValueError("Task has no env_id defined")
+        # Deferred import to avoid circular dependencies
+        from .client import AsyncFleet
+
+        return await AsyncFleet().make(env_key=self.env_key, region=region)
+
+
+async def load_tasks(
+    env_key: Optional[str] = None,
+    keys: Optional[List[str]] = None,
+    version: Optional[str] = None,
+    team_id: Optional[str] = None
+) -> List[Task]:
+    """Convenience function to load tasks with optional filtering.
+
+    Args:
+        env_key: Optional environment key to filter tasks by
+        keys: Optional list of task keys to filter by
+        version: Optional version to filter tasks by
+        team_id: Optional team_id to filter by (admin only)
+
+    Examples:
+        tasks = await fleet.load_tasks(env_key="fira")
+        tasks = await fleet.load_tasks(keys=["task1", "task2"])
+        tasks = await fleet.load_tasks(env_key="fira", version="v1.0")
+    """
+    # Use the global client by default so users can pre-configure it once
+    from .global_client import get_client
+
+    client = get_client()
+    return await client.load_tasks(
+        env_key=env_key, 
+        keys=keys, 
+        version=version, 
+        team_id=team_id
+    )

fleet/_async/verifiers/__init__.py

@@ -9,9 +9,9 @@ from .verifier import (
 
 __all__ = [
     "DatabaseSnapshot",
-    "IgnoreConfig", 
+    "IgnoreConfig",
     "SnapshotDiff",
     "TASK_SUCCESSFUL_SCORE",
     "verifier",
     "AsyncVerifierFunction",
-] 
+]

fleet/_async/verifiers/bundler.py

@@ -544,7 +544,9 @@ class FunctionBundler:
                 # Ensure fleet-python is always included
                 if not requirements:
                     requirements = ["fleet-python"]
-                elif "fleet-python" not in [r.split("==")[0].split(">=")[0] for r in requirements]:
+                elif "fleet-python" not in [
+                    r.split("==")[0].split(">=")[0] for r in requirements
+                ]:
                     requirements.append("fleet-python")
                 requirements_file.write_text("\n".join(sorted(set(requirements))))
 
@@ -663,37 +665,39 @@ class FunctionBundler:
             logger.warning(f"Failed to extract function {function_name}: {e}")
 
         return None
-    
+
     def _get_function_source_without_decorator(self, func: Callable) -> str:
         """Get function source code without the @verifier decorator."""
         source = inspect.getsource(func)
-        lines = source.split('\n')
-        
+        lines = source.split("\n")
+
         # Find where the function definition starts
         func_start = -1
         for i, line in enumerate(lines):
-            if line.strip().startswith('def '):
+            if line.strip().startswith("def "):
                 func_start = i
                 break
-        
+
         if func_start == -1:
             # Couldn't find function definition, return original
             return source
-        
+
         # Return only from the function definition onward
         func_lines = lines[func_start:]
-        
+
         # Remove common indentation
         if func_lines:
             # Find minimum indentation (excluding empty lines)
-            min_indent = float('inf')
+            min_indent = float("inf")
             for line in func_lines:
                 if line.strip():
                     indent = len(line) - len(line.lstrip())
                     min_indent = min(min_indent, indent)
-            
+
             # Remove the common indentation
-            if min_indent < float('inf'):
-                func_lines = [line[min_indent:] if line.strip() else line for line in func_lines]
-        
-        return '\n'.join(func_lines)
+            if min_indent < float("inf"):
+                func_lines = [
+                    line[min_indent:] if line.strip() else line for line in func_lines
+                ]
+
+        return "\n".join(func_lines)

fleet/_async/verifiers/verifier.py

@@ -19,7 +19,7 @@ from ..client import AsyncEnv
 
 logger = logging.getLogger(__name__)
 
-F = TypeVar('F', bound=Callable[..., Any])
+F = TypeVar("F", bound=Callable[..., Any])
 
 # Global cache to track which bundle SHAs have been uploaded to S3
 _uploaded_bundle_shas: Set[str] = set()
@@ -33,7 +33,7 @@ def _get_bundle_sha(bundle_data: bytes) -> str:
 
 class AsyncVerifierFunction:
     """Wrapper for a verified function that supports local execution with env-first pattern."""
-    
+
     def __init__(
         self,
         func: F,
@@ -41,7 +41,7 @@ class AsyncVerifierFunction:
         extra_requirements: Optional[List[str]] = None,
         verifier_id: Optional[str] = None,
         sha256: Optional[str] = None,
-        raw_code: Optional[str] = None
+        raw_code: Optional[str] = None,
     ):
         self.func = func
         self.key = key
@@ -52,10 +52,10 @@ class AsyncVerifierFunction:
         self._bundle_data: Optional[bytes] = None  # Cached bundle data
         self._raw_code: Optional[str] = raw_code  # Store raw code if provided
         self._is_async = asyncio.iscoroutinefunction(func)
-        
+
         # Copy function metadata
         functools.update_wrapper(self, func)
-    
+
     def _get_or_create_bundle(self) -> tuple[bytes, str]:
         """Get or create bundle data and return (bundle_data, sha)."""
         if self._bundle_data is None or self._bundle_sha is None:
@@ -63,68 +63,72 @@ class AsyncVerifierFunction:
             if self._raw_code:
                 import io
                 import zipfile
-                
+
                 # Create zip bundle directly (matching bundler format)
                 zip_buffer = io.BytesIO()
-                with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zf:
+                with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zf:
                     # Add requirements.txt
                     requirements = self.extra_requirements or []
                     if "fleet-python" not in requirements:
                         requirements.append("fleet-python")
                     req_content = "\n".join(requirements)
                     zf.writestr("requirements.txt", req_content)
-                    
+
                     # Add verifier.py with the raw code
                     zf.writestr("verifier.py", self._raw_code)
-                
+
                 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:
                     self._bundle_data = self._bundler.create_bundle(
-                        self.func, 
-                        self.extra_requirements,
-                        self.verifier_id
+                        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}")
-        
+
         return self._bundle_data, self._bundle_sha
-    
+
     async def _check_bundle_status(self, env: AsyncEnv) -> tuple[str, bool]:
         """Check if bundle needs to be uploaded and return (sha, needs_upload)."""
         bundle_data, bundle_sha = self._get_or_create_bundle()
-        
+
         # 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]}...")
             return bundle_sha, False  # No upload needed, server has it
-        
+
         # 1. Check local process cache first
         if bundle_sha in _uploaded_bundle_shas:
             logger.debug(f"Bundle {bundle_sha[:8]}... found in local cache")
             return bundle_sha, False  # Already uploaded, no upload needed
-        
+
         # 2. Check if bundle exists on server (pseudocode)
         # TODO: Add endpoint to check if bundle SHA exists in S3
         try:
             exists = await env.check_bundle_exists(bundle_sha)
             if exists.success:
-                logger.info(f"Bundle {bundle_sha[:8]}... found on server, updating cache")
+                logger.info(
+                    f"Bundle {bundle_sha[:8]}... found on server, updating cache"
+                )
                 _uploaded_bundle_shas.add(bundle_sha)
                 return bundle_sha, False  # Found on server, no upload needed
         except Exception as e:
             logger.warning(f"Failed to check bundle existence: {e}")
-        
+
         # 3. Bundle not found locally or on server - upload needed
         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:
         """Local execution of the verifier function with env as first parameter."""
         try:
@@ -134,7 +138,7 @@ class AsyncVerifierFunction:
             else:
                 # For sync functions, call directly
                 result = self.func(env, *args, **kwargs)
-            
+
             # Handle different return types
             if isinstance(result, (int, float)):
                 # Direct score return
@@ -144,16 +148,18 @@ class AsyncVerifierFunction:
                 return result
             else:
                 # Try to extract score from object attributes
-                if hasattr(result, 'score'):
+                if hasattr(result, "score"):
                     return float(result.score)
                 else:
-                    raise ValueError(f"Verifier function must return a score (number). Got {type(result)}")
-                    
+                    raise ValueError(
+                        f"Verifier function must return a score (number). Got {type(result)}"
+                    )
+
         except Exception as e:
             logger.error(f"Error in verifier {self.key}: {e}")
             # Return error score 0
             return 0.0
-    
+
     async def remote(self, env: AsyncEnv, *args, **kwargs) -> float:
         """Remote execution of the verifier function with SHA-based bundle caching."""
         # Async verifiers are now supported by the backend
@@ -163,20 +169,20 @@ class AsyncVerifierFunction:
         #         "The remote execution environment only supports synchronous functions. "
         #         "Please provide a synchronous version of your verifier."
         #     )
-        
+
         args_array = list(args)
         args_array.append({"env": env.instance_id})
         args = tuple(args_array)
-        
+
         try:
             # Check if bundle needs to be uploaded
             bundle_sha, needs_upload = await self._check_bundle_status(env)
-            
+
             if needs_upload:
                 # Need to upload bundle to S3
                 logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
                 bundle_data, _ = self._get_or_create_bundle()
-                
+
                 response = await env.execute_verifier_remote(
                     bundle_data=bundle_data,
                     bundle_sha=bundle_sha,
@@ -185,42 +191,46 @@ class AsyncVerifierFunction:
                     args=args,
                     args_array=args_array,
                     kwargs=kwargs,
-                    needs_upload=True
+                    needs_upload=True,
                 )
-                
+
                 # Mark as uploaded after successful execution
                 _uploaded_bundle_shas.add(bundle_sha)
                 logger.debug(f"Registered bundle {bundle_sha[:8]}... as uploaded")
-                
+
             else:
                 # Bundle already available - execute without upload
-                logger.info(f"Executing cached bundle {bundle_sha[:8]}... for {self.key}")
+                logger.info(
+                    f"Executing cached bundle {bundle_sha[:8]}... for {self.key}"
+                )
                 bundle_data, _ = self._get_or_create_bundle()
-                
+
                 response = await env.execute_verifier_remote(
-                    bundle_data=bundle_data or b'',  # Empty if using server-side bundle
+                    bundle_data=bundle_data or b"",  # Empty if using server-side bundle
                     bundle_sha=bundle_sha,
                     key=self.key,
                     function_name=self.func.__name__,
                     args=args,
                     args_array=args_array,
                     kwargs=kwargs,
-                    needs_upload=False  # Don't upload, just execute
+                    needs_upload=False,  # Don't upload, just execute
                 )
-            
+
             # Handle response
+            if response.stdout:
+                print(response.stdout)
             if response.success:
                 return self._process_result(response.result)
             else:
                 self._raise_remote_error(response.error)
-                
+
         except Exception as e:
             logger.error(f"Remote execution failed for {self.key}: {e}")
             # If it's an HTTP error, try to get more details
-            if hasattr(e, 'response') and hasattr(e.response, 'text'):
+            if hasattr(e, "response") and hasattr(e.response, "text"):
                 logger.error(f"Server response: {e.response.text}")
             raise
-    
+
     def _process_result(self, result: Any) -> float:
         """Process remote execution result, handling different return types."""
         # Handle different return types like local execution
@@ -230,7 +240,7 @@ class AsyncVerifierFunction:
             return float(result["score"])
         else:
             # Try to extract score from object attributes
-            if hasattr(result, 'score'):
+            if hasattr(result, "score"):
                 return float(result.score)
             else:
                 # Best effort conversion
@@ -239,13 +249,13 @@ class AsyncVerifierFunction:
                 except (ValueError, TypeError):
                     logger.warning(f"Could not convert result to float: {result}")
                     return 0.0
-    
+
     def _raise_remote_error(self, error_info: Dict[str, Any]):
         """Reconstruct remote error as local exception."""
         error_type = error_info.get("type", "RuntimeError")
         message = error_info.get("message", "Remote execution failed")
         traceback_str = error_info.get("traceback", "")
-        
+
         # Create a rich error message
         full_message = f"""
 Remote verifier execution failed:
@@ -254,32 +264,32 @@ Remote verifier execution failed:
 Remote traceback:
 {traceback_str}
         """.strip()
-        
+
         # Try to raise the original exception type
         try:
             exception_class = getattr(__builtins__, error_type, RuntimeError)
             raise exception_class(full_message)
         except:
             raise RuntimeError(full_message)
-    
+
     def _get_env_id(self, env: AsyncEnv) -> str:
         """Generate a unique identifier for the environment."""
         # Use instance base URL or similar unique identifier
-        if hasattr(env, 'instance') and hasattr(env.instance, 'base_url'):
+        if hasattr(env, "instance") and hasattr(env.instance, "base_url"):
             return f"{env.instance.base_url}"
         else:
             # Fallback to object id (less ideal but works)
             return str(id(env))
-    
+
     def _is_bundle_not_found_error(self, error: Exception) -> bool:
         """Check if the error indicates the bundle was not found on the server."""
         # Check for common "bundle not found" error patterns
         error_msg = str(error).lower()
         return (
-            "bundle not found" in error_msg or
-            "verifier not found" in error_msg or
-            "404" in error_msg or
-            "not found" in error_msg
+            "bundle not found" in error_msg
+            or "verifier not found" in error_msg
+            or "404" in error_msg
+            or "not found" in error_msg
         )
 
 
@@ -287,21 +297,21 @@ def verifier(
     key: Optional[str] = None,
     extra_requirements: Optional[List[str]] = None,
     sha256: Optional[str] = None,
-    raw_code: Optional[str] = None
+    raw_code: Optional[str] = None,
 ) -> Callable[[F], AsyncVerifierFunction]:
     """
     Decorator to create a verifier function with env-first pattern.
-    
+
     The decorated function must take 'env' as its first parameter, making it explicit
     that verifiers operate within an environment context. This makes verifiers reusable
     across different environments.
-    
+
     Args:
         key: Optional key for the verifier. Defaults to function name.
         extra_requirements: Additional PyPI packages needed by the verifier.
         sha256: Optional SHA256 hash of existing server-side bundle to use.
         raw_code: Optional raw code to use as bundle (bypasses source extraction).
-    
+
     Example:
         # Synchronous verifier (works locally and remotely)
         @verifier(key="check_user_count")
@@ -310,7 +320,7 @@ def verifier(
             result = db.query("SELECT COUNT(*) FROM users")
             actual_count = result.rows[0][0]
             return 1.0 if actual_count >= expected_count else 0.0
-        
+
         # Async verifier (only works locally)
         @verifier(key="check_user_async")
         async def check_user_async(env, expected_count: int) -> float:
@@ -318,29 +328,25 @@ def verifier(
             result = await db.query("SELECT COUNT(*) FROM users")
             actual_count = result.rows[0][0]
             return 1.0 if actual_count >= expected_count else 0.0
-        
+
         # Usage
-        env = await flt.env.make_async("fira")
-        
+        env = await fleet.env.make_async("fira")
+
         # Local execution
         result = await check_user_count(env, 5)        # sync verifier
         result = await check_user_async(env, 5)       # async verifier
-        
+
         # Remote execution
         result = await check_user_count.remote(env, 5) # sync verifier works
         # await check_user_async.remote(env, 5)        # raises NotImplementedError
     """
+
     def decorator(func: F) -> AsyncVerifierFunction:
         verifier_key = key or func.__name__
         verifier_uuid = str(uuid.uuid4())
-        
+
         return AsyncVerifierFunction(
-            func,
-            verifier_key,
-            extra_requirements,
-            verifier_uuid,
-            sha256,
-            raw_code
+            func, verifier_key, extra_requirements, verifier_uuid, sha256, raw_code
         )
-    
-    return decorator 
+
+    return decorator

fleet/base.py

@@ -46,6 +46,7 @@ class BaseWrapper:
         headers["Authorization"] = f"Bearer {self.api_key}"
         # Debug log
         import logging
+
         logger = logging.getLogger(__name__)
         logger.debug(f"Headers being sent: {headers}")
         return headers
@@ -89,7 +90,7 @@ class SyncWrapper(BaseWrapper):
     def _handle_error_response(self, response: httpx.Response) -> None:
         """Handle HTTP error responses and convert to appropriate Fleet exceptions."""
         status_code = response.status_code
-        
+
         # Debug log 500 errors
         if status_code == 500:
             logger.error(f"Got 500 error from {response.url}")