fleet-python 0.2.66b2__py3-none-any.whl → 0.2.105__py3-none-any.whl

fleet/tasks.py

@@ -36,9 +36,16 @@ class Task(BaseModel):
     )
     verifier_id: Optional[str] = Field(None, description="Verifier identifier")
     verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
+    verifier_runtime_version: Optional[str] = Field(None, description="Verifier runtime version")
     metadata: Optional[Dict[str, Any]] = Field(
         default_factory=dict, description="Additional task metadata"
     )
+    writer_metadata: Optional[Dict[str, Any]] = Field(
+        None, description="Metadata filled by task writer"
+    )
+    qa_metadata: Optional[Dict[str, Any]] = Field(
+        None, description="Metadata filled by QA reviewer"
+    )
     output_json_schema: Optional[Dict[str, Any]] = Field(
         None, description="JSON schema for expected output format"
     )
@@ -199,26 +206,37 @@ class Task(BaseModel):
                 verifier_id=verifier_id,
                 verifier_key=self.key,
                 sha256=self.verifier_sha or "",
+                verifier_runtime_version=self.verifier_runtime_version or "",
             )
             self.verifier = verifier
 
-    def make_env(self, region: Optional[str] = None):
+    def make_env(
+        self,
+        region: Optional[str] = None,
+        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.
 
-        Uses the task's env_id (and version if present) to create the env.
+        Alias for make() method. 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 Fleet
-
-        return Fleet().make(env_key=self.env_key, region=region)
+        return self.make(
+            region=region,
+            image_type=image_type,
+            ttl_seconds=ttl_seconds,
+            run_id=run_id,
+            heartbeat_interval=heartbeat_interval,
+        )
 
     def make(
         self,
         region: Optional[str] = None,
         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.
 
@@ -226,11 +244,15 @@ class Task(BaseModel):
         - env_key (env_id + version)
         - 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
@@ -238,7 +260,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", heartbeat_interval=60)
         """
         if not self.env_id:
             raise ValueError("Task has no env_id defined")
@@ -253,11 +275,13 @@ 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,
+            heartbeat_interval=heartbeat_interval,
         )
 
 
 def verifier_from_string(
-    verifier_func: str, verifier_id: str, verifier_key: str, sha256: str = ""
+    verifier_func: str, verifier_id: str, verifier_key: str, sha256: str = "", verifier_runtime_version: str = ""
 ) -> "VerifierFunction":
     """Create a verifier function from string code.
 
@@ -266,20 +290,62 @@ def verifier_from_string(
         verifier_id: Unique identifier for the verifier
         verifier_key: Key/name for the verifier
         sha256: SHA256 hash of the verifier code
+        verifier_runtime_version: Verifier runtime version
 
     Returns:
         VerifierFunction instance that can be used to verify tasks
     """
     try:
         import inspect
+        import re
+        import json
+        import string
         from .verifiers import SyncVerifierFunction
         from .verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
         from .verifiers.db import IgnoreConfig
-        from .verifiers.parsing import parse_and_validate_verifier
 
-        # Validate the code and extract function name
-        # This ensures no arbitrary code execution during import
-        func_name = parse_and_validate_verifier(verifier_func)
+        # Strip @verifier decorator if present to avoid double-wrapping
+        # 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)
+
+        # Define helper functions for verifier execution
+        _TRANSLATOR = str.maketrans(string.punctuation, " " * len(string.punctuation))
+        
+        def _normalize_text(value: str) -> str:
+            text = value.lower().translate(_TRANSLATOR)
+            return "".join(text.split())
+        
+        def _stringify_content(content: Any) -> str:
+            if isinstance(content, (dict, list)):
+                return json.dumps(content, sort_keys=True)
+            return str(content)
+        
+        def normalized_contains(target: str, blob: Any) -> bool:
+            normalized_target = _normalize_text(target)
+            normalized_blob = _normalize_text(_stringify_content(blob))
+            return normalized_target in normalized_blob
+        
+        def extract_numbers(text: str) -> list:
+            cleaned_text = text.replace(',', '')
+            pattern = r'-?\d+\.?\d*'
+            matches = re.findall(pattern, cleaned_text)
+            return [float(num) for num in matches]
+        
+        def contains_number(text: str, target_number) -> bool:
+            numbers = extract_numbers(text)
+            try:
+                if isinstance(target_number, str):
+                    target_number = target_number.replace(',', '')
+                target = float(target_number)
+            except (ValueError, AttributeError):
+                return False
+            return target in numbers
 
         # Create a globals namespace with all required imports
         exec_globals = globals().copy()
@@ -289,15 +355,24 @@ def verifier_from_string(
                 "TASK_FAILED_SCORE": TASK_FAILED_SCORE,
                 "IgnoreConfig": IgnoreConfig,
                 "Environment": object,  # Add Environment type if needed
+                "normalized_contains": normalized_contains,
+                "extract_numbers": extract_numbers,
+                "contains_number": contains_number,
+                "json": json,
+                "re": re,
+                "string": string,
             }
         )
 
         # Create a local namespace for executing the code
         local_namespace = {}
 
-        # Execute the verifier code in the namespace
-        # This is now safe because we validated it contains only declarative code
-        exec(verifier_func, exec_globals, local_namespace)
+        # Execute the cleaned verifier code in the namespace
+        exec(cleaned_code, exec_globals, local_namespace)
+
+        # Merge local_namespace into exec_globals so helper functions are accessible
+        # from the main verifier function when it's called
+        exec_globals.update(local_namespace)
 
         # Find the function that was defined (not imported)
         # Functions defined via exec have co_filename == '<string>'
@@ -318,6 +393,7 @@ def verifier_from_string(
             verifier_id=verifier_id,
             sha256=sha256,
             raw_code=verifier_func,
+            verifier_runtime_version=verifier_runtime_version if verifier_runtime_version else None,
         )
 
         # Store additional metadata
@@ -387,7 +463,12 @@ def load_tasks(
 
 
 def update_task(
-    task_key: str, prompt: Optional[str] = None, verifier_code: Optional[str] = None
+    task_key: str,
+    prompt: Optional[str] = None,
+    verifier_code: Optional[str] = None,
+    metadata: Optional[Dict[str, Any]] = None,
+    writer_metadata: Optional[Dict[str, Any]] = None,
+    qa_metadata: Optional[Dict[str, Any]] = None,
 ):
     """Convenience function to update an existing task.
 
@@ -395,6 +476,9 @@ def update_task(
         task_key: The key of the task to update
         prompt: New prompt text for the task (optional)
         verifier_code: Python code for task verification (optional)
+        metadata: Additional metadata for the task (optional)
+        writer_metadata: Metadata filled by task writer (optional)
+        qa_metadata: Metadata filled by QA reviewer (optional)
 
     Returns:
         TaskResponse containing the updated task details
@@ -402,16 +486,25 @@ def update_task(
     Examples:
         response = fleet.update_task("my-task", prompt="New prompt text")
         response = fleet.update_task("my-task", verifier_code="def verify(env): return True")
+        response = fleet.update_task("my-task", metadata={"seed": 42, "story": "Updated story"})
+        response = fleet.update_task("my-task", writer_metadata={"author": "john"})
     """
     from .global_client import get_client
 
     client = get_client()
     return client.update_task(
-        task_key=task_key, prompt=prompt, verifier_code=verifier_code
+        task_key=task_key,
+        prompt=prompt,
+        verifier_code=verifier_code,
+        metadata=metadata,
+        writer_metadata=writer_metadata,
+        qa_metadata=qa_metadata,
     )
 
 
-def get_task(task_key: str, version_id: Optional[str] = None, team_id: Optional[str] = None):
+def get_task(
+    task_key: str, version_id: Optional[str] = None, team_id: Optional[str] = None
+):
     """Convenience function to get a task by key and optional version.
 
     Args:

fleet/utils/__init__.py

@@ -0,0 +1,7 @@
+"""Fleet utilities - shared helpers and browser control."""
+
+from .playwright import PlaywrightComputer, map_key, is_modifier
+from .logging import log_verbose, VERBOSE
+
+__all__ = ["PlaywrightComputer", "map_key", "is_modifier", "log_verbose", "VERBOSE"]
+

fleet/utils/http_logging.py

@@ -0,0 +1,178 @@
+"""HTTP traffic logging via httpx event hooks.
+
+Captures request/response pairs and writes to JSONL file.
+Works with any httpx-based client (including google-genai).
+"""
+
+import json
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+import threading
+
+# Sensitive headers to redact
+SENSITIVE_HEADERS = {
+    "authorization", "x-api-key", "api-key", "x-goog-api-key",
+    "x-gemini-api-key", "x-openai-api-key", "x-anthropic-api-key",
+    "cookie", "set-cookie", "x-auth-token", "x-access-token",
+}
+
+
+def _redact_headers(headers: dict) -> dict:
+    """Redact sensitive headers."""
+    redacted = {}
+    for k, v in headers.items():
+        if k.lower() in SENSITIVE_HEADERS:
+            if len(str(v)) > 12:
+                redacted[k] = str(v)[:8] + "...[REDACTED]"
+            else:
+                redacted[k] = "[REDACTED]"
+        else:
+            redacted[k] = str(v)
+    return redacted
+
+
+class HttpTrafficLogger:
+    """Logs HTTP traffic to JSONL file."""
+    
+    _instance: Optional["HttpTrafficLogger"] = None
+    _lock = threading.Lock()
+    
+    def __init__(self, log_file: Optional[Path] = None):
+        if log_file is None:
+            log_dir = Path.home() / ".fleet" / "proxy_logs"
+            log_dir.mkdir(parents=True, exist_ok=True)
+            log_file = log_dir / f"traffic_{datetime.now().strftime('%Y%m%d_%H%M%S')}.jsonl"
+        
+        self.log_file = log_file
+        self.log_file.parent.mkdir(parents=True, exist_ok=True)
+        self._file = open(log_file, "a")
+        self._write_lock = threading.Lock()
+        self._request_times: dict = {}  # Track request start times
+    
+    @classmethod
+    def get(cls, log_file: Optional[Path] = None) -> "HttpTrafficLogger":
+        """Get singleton instance."""
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = cls(log_file)
+            return cls._instance
+    
+    @classmethod
+    def set_log_file(cls, log_file: Path):
+        """Set log file for singleton (creates new instance if needed)."""
+        with cls._lock:
+            if cls._instance is not None:
+                cls._instance.close()
+            cls._instance = cls(log_file)
+        return cls._instance
+    
+    def log_request(self, request) -> str:
+        """Log request, return request ID for matching response."""
+        request_id = f"{id(request)}_{time.time()}"
+        self._request_times[request_id] = time.time()
+        return request_id
+    
+    def log_response(self, request, response, request_id: Optional[str] = None):
+        """Log complete request/response pair."""
+        start_time = self._request_times.pop(request_id, None) if request_id else None
+        duration_ms = int((time.time() - start_time) * 1000) if start_time else None
+        
+        # Extract host
+        host = str(request.url.host) if hasattr(request.url, 'host') else str(request.url).split('/')[2]
+        
+        # Build request entry
+        request_headers = dict(request.headers) if hasattr(request, 'headers') else {}
+        request_body = None
+        if hasattr(request, 'content') and request.content:
+            try:
+                body_bytes = request.content if isinstance(request.content, bytes) else bytes(request.content)
+                if len(body_bytes) < 50000:
+                    request_body = body_bytes.decode('utf-8', errors='replace')
+            except:
+                pass
+        
+        # Build response entry  
+        response_headers = dict(response.headers) if hasattr(response, 'headers') else {}
+        response_body = None
+        if hasattr(response, 'content') and response.content:
+            try:
+                if len(response.content) < 50000:
+                    response_body = response.content.decode('utf-8', errors='replace')
+            except:
+                pass
+        
+        entry = {
+            "type": "http",
+            "timestamp": datetime.now().isoformat(),
+            "host": host,
+            "duration_ms": duration_ms,
+            "logged_at": datetime.now().isoformat(),
+            "request": {
+                "method": str(request.method),
+                "url": str(request.url),
+                "headers": _redact_headers(request_headers),
+                "body": request_body,
+                "body_length": len(request.content) if hasattr(request, 'content') and request.content else 0,
+            },
+            "response": {
+                "status_code": response.status_code,
+                "headers": _redact_headers(response_headers),
+                "body": response_body,
+                "body_length": len(response.content) if hasattr(response, 'content') and response.content else 0,
+            },
+        }
+        
+        with self._write_lock:
+            self._file.write(json.dumps(entry) + "\n")
+            self._file.flush()
+    
+    def close(self):
+        """Close the log file."""
+        with self._write_lock:
+            if self._file:
+                self._file.close()
+                self._file = None
+
+
+def install_httpx_hooks():
+    """Install global httpx event hooks for traffic logging.
+    
+    This patches httpx to log all HTTP traffic automatically.
+    """
+    try:
+        import httpx
+    except ImportError:
+        return
+    
+    logger = HttpTrafficLogger.get()
+    original_send = httpx.Client.send
+    original_async_send = httpx.AsyncClient.send
+    
+    def patched_send(self, request, **kwargs):
+        request_id = logger.log_request(request)
+        response = original_send(self, request, **kwargs)
+        logger.log_response(request, response, request_id)
+        return response
+    
+    async def patched_async_send(self, request, **kwargs):
+        request_id = logger.log_request(request)
+        response = await original_async_send(self, request, **kwargs)
+        logger.log_response(request, response, request_id)
+        return response
+    
+    httpx.Client.send = patched_send
+    httpx.AsyncClient.send = patched_async_send
+
+
+def setup_logging(log_file: Optional[Path] = None):
+    """Setup HTTP traffic logging.
+    
+    Args:
+        log_file: Path to JSONL log file. If None, creates timestamped file in ~/.fleet/proxy_logs/
+    """
+    if log_file:
+        HttpTrafficLogger.set_log_file(log_file)
+    install_httpx_hooks()

fleet/utils/logging.py

@@ -0,0 +1,13 @@
+"""Logging utilities for Fleet SDK."""
+
+import os
+
+# Verbose logging flag - check once at import time
+VERBOSE = os.environ.get("FLEET_VERBOSE", "false").lower() in ("true", "1", "yes")
+
+
+def log_verbose(*args, **kwargs):
+    """Print only if FLEET_VERBOSE is enabled."""
+    if VERBOSE:
+        print(*args, **kwargs)
+