fleet-python 0.2.25__py3-none-any.whl → 0.2.27__py3-none-any.whl

fleet/client.py

@@ -17,9 +17,10 @@
 import base64
 import cloudpickle
 import httpx
+import json
 import logging
 import os
-from typing import List, Optional, Dict
+from typing import List, Optional, Dict, TYPE_CHECKING
 
 from .base import EnvironmentBase, SyncWrapper
 from .models import (
@@ -30,8 +31,13 @@ from .models import (
     VerifiersExecuteResponse,
     TaskListResponse,
     AccountResponse,
+    TaskRequest,
 )
 from .tasks import Task
+from .verifiers.parse import extract_function_name, convert_new_to_old_verifier
+
+if TYPE_CHECKING:
+    from .verifiers import SyncVerifierFunction
 
 from .instance import (
     InstanceClient,
@@ -260,18 +266,112 @@ class Fleet:
         # Transform TaskResponse objects to Task objects
         tasks = []
         for task_response in task_list_response.tasks:
+            # Create verifier function if verifier data is present
+            verifier = None
+            verifier_func = task_response.verifier_func
+            
+            if task_response.verifier:
+                # Use verifier code from the embedded verifier object
+                verifier_func = task_response.verifier.code
+                
+                # Create VerifierFunction from the embedded data
+                try:
+                    verifier = self._create_verifier_from_data(
+                        verifier_id=task_response.verifier.verifier_id,
+                        verifier_key=task_response.verifier.key,
+                        verifier_code=task_response.verifier.code,
+                        verifier_sha=task_response.verifier.sha256
+                    )
+                except Exception as e:
+                    logger.warning(f"Failed to create verifier {task_response.verifier.key}: {e}")
+            
             task = Task(
                 key=task_response.key,
                 prompt=task_response.prompt,
                 env_id=task_response.environment_id,  # Map environment_id -> env_id
                 created_at=task_response.created_at,
-                verifier=None,  # Keep blank for now as requested
+                version=task_response.version,
+                env_variables=task_response.env_variables or {},
+                verifier_func=verifier_func,  # Set verifier code
+                verifier=verifier,  # Use created verifier or None
                 metadata={}  # Default empty metadata
             )
             tasks.append(task)
         
         return tasks
 
+    def export_tasks(self, env_key: Optional[str] = None, filename: Optional[str] = None):
+        """Export tasks for the authenticated team, optionally filtered by environment.
+        
+        Args:
+            env_key: Optional environment key to filter tasks by
+            filename: Optional filename to write tasks to. If not provided, defaults to 'tasks.json' or 'tasks_{env_key}.json'
+            
+        Returns:
+            str: Path to the exported file if tasks were written, None if no tasks found
+        """
+        tasks = self.load_tasks(env_key)
+        if tasks:
+            # Generate filename if not provided
+            if filename is None:
+                if env_key:
+                    filename = f"tasks_{env_key}.json"
+                else:
+                    filename = "tasks.json"
+            
+            # Convert tasks to serializable format
+            tasks_data = []
+            for task in tasks:
+                task_dict = task.model_dump()
+                # Remove non-serializable verifier object, keep verifier_func (code string)
+                if 'verifier' in task_dict:
+                    task_dict.pop('verifier')
+                tasks_data.append(task_dict)
+            
+            # Write to JSON file
+            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}")
+            return filename
+        else:
+            logger.info("No tasks found to export")
+            return None
+            
+    def import_tasks(self, filename: str):
+        """Import tasks from a JSON file.
+        
+        Args:
+            filename: Path to the JSON file of Task objects to import
+            
+        Returns:
+            List[Task] containing imported Task objects
+        """
+        with open(filename, 'r', encoding='utf-8') as f:
+            tasks_data = json.load(f)
+            
+        # Create tasks from the loaded data
+        tasks = []
+        for task_data in tasks_data:
+            task = Task(**task_data)
+            tasks.append(task)
+
+        for task in tasks:
+            payload = TaskRequest(
+                key=task.key,
+                prompt=task.prompt,
+                environment_id=task.env_id,
+                verifier_func=task.verifier_func,
+                version=task.version or None,
+                env_variables=task.env_variables or {},
+            )
+            try:
+                response = self.client.request("POST", "/v1/tasks", json=payload.model_dump())
+            except Exception as e:
+                logger.error(f"Failed to import task {task.key}: {e}")
+                continue
+
+
     def account(self) -> AccountResponse:
         """Get account information including instance limits and usage.
 
@@ -280,6 +380,109 @@ class Fleet:
         """
         response = self.client.request("GET", "/v1/account")
         return AccountResponse(**response.json())
+    
+    def _create_verifier_from_data(
+        self, 
+        verifier_id: str,
+        verifier_key: str,
+        verifier_code: str,
+        verifier_sha: str
+    ) -> "SyncVerifierFunction":
+        """Create an AsyncVerifierFunction from verifier data.
+        
+        Args:
+            verifier_id: The verifier ID
+            verifier_key: The verifier key
+            verifier_code: The verifier code
+            verifier_sha: The verifier SHA256
+            
+        Returns:
+            AsyncVerifierFunction created from the verifier code
+        """
+        from .verifiers.verifier import SyncVerifierFunction
+
+        # Convert async verifier code to sync
+        if 'async def' in verifier_code:
+            verifier_code = verifier_code.replace('async def', 'def')
+        if 'await ' in verifier_code:
+            verifier_code = verifier_code.replace('await ', '')
+        
+        # Check if this is a new format verifier (has before/after parameters)
+        if 'before: DatabaseSnapshot' in verifier_code and 'after: DatabaseSnapshot' in verifier_code:
+            # Convert new format to old format
+            verifier_code = convert_new_to_old_verifier(verifier_code)
+            # Update function name since wrapper adds _wrapper suffix
+            original_name = extract_function_name(verifier_code.split('\n')[0])
+            if original_name and original_name.endswith('_wrapper'):
+                function_name = original_name
+            else:
+                function_name = extract_function_name(verifier_code)
+        else:
+            # Extract function name from code
+            function_name = extract_function_name(verifier_code)
+        
+        if not function_name:
+            raise ValueError(f"Could not extract function name from verifier {verifier_id}")
+        
+        # Create a function object from the code
+        # Import necessary classes for the namespace
+        from .verifiers.db import IgnoreConfig, DatabaseSnapshot
+        
+        # Create a namespace for the function
+        namespace = {
+            '__builtins__': __builtins__,
+            'Environment': object,  # Placeholder, will be provided at runtime
+            'IgnoreConfig': IgnoreConfig,
+            'DatabaseSnapshot': DatabaseSnapshot,
+            'TASK_FAILED_SCORE': 0,
+            'TASK_SUCCESSFUL_SCORE': 1,
+        }
+        
+        # Execute the code to define the function
+        exec(verifier_code, namespace)
+        
+        # Get the function object
+        if function_name not in namespace:
+            raise ValueError(f"Function {function_name} not found in verifier code")
+        
+        func = namespace[function_name]
+        
+        # Create and return AsyncVerifierFunction with SHA if available
+        # Since the function was created via exec, we need to provide the raw code
+        verifier_func = SyncVerifierFunction(
+            func=func,
+            key=verifier_key,
+            extra_requirements=[],
+            verifier_id=verifier_id,
+            sha256=verifier_sha,  # Pass SHA directly to constructor
+            raw_code=verifier_code  # Provide raw code since func won't have extractable source
+        )
+        
+        # Store the original verifier code for reference
+        verifier_func._verifier_code = verifier_code
+        
+        return verifier_func
+    
+    def _load_verifier(self, verifier_id: str) -> "SyncVerifierFunction":
+        """Load a verifier by ID and create an AsyncVerifierFunction.
+        
+        Args:
+            verifier_id: The verifier ID to fetch
+            
+        Returns:
+            AsyncVerifierFunction created from the verifier code
+        """
+        # Fetch verifier from API
+        response = self.client.request("GET", f"/v1/verifier/{verifier_id}")
+        verifier_data = response.json()
+        
+        # Use the common method to create verifier
+        return self._create_verifier_from_data(
+            verifier_id=verifier_id,
+            verifier_key=verifier_data["key"],
+            verifier_code=verifier_data["code"],
+            verifier_sha=verifier_data.get("sha256", "")
+        )
 
 
 # Shared

fleet/instance/client.py

@@ -11,7 +11,7 @@ from ..resources.sqlite import SQLiteResource
 from ..resources.browser import BrowserResource
 from ..resources.base import Resource
 
-from ..verifiers import DatabaseSnapshot
+from fleet.verifiers import DatabaseSnapshot
 from fleet.verifiers.parse import convert_verifier_string, extract_function_name
 
 from ..exceptions import FleetEnvironmentError

fleet/models.py

@@ -152,6 +152,18 @@ class TaskRequest(BaseModel):
     prompt: str = Field(..., title='Prompt')
     environment_id: str = Field(..., title='Environment Id')
     verifier_id: Optional[str] = Field(None, title='Verifier Id')
+    version: Optional[str] = Field(None, title='Version')
+    env_variables: Optional[Dict[str, Any]] = Field(None, title='Env Variables')
+
+
+class VerifierData(BaseModel):
+    verifier_id: str = Field(..., title='Verifier Id')
+    key: str = Field(..., title='Key')
+    version: int = Field(..., title='Version')
+    sha256: str = Field(..., title='Sha256')
+    code: str = Field(..., title='Code')
+    comment: Optional[str] = Field(None, title='Comment')
+    created_at: str = Field(..., title='Created At')
 
 
 class TaskResponse(BaseModel):
@@ -161,6 +173,10 @@ class TaskResponse(BaseModel):
     environment_id: str = Field(..., title='Environment Id')
     created_at: str = Field(..., title='Created At')
     verifier_id: Optional[str] = Field(None, title='Verifier Id')
+    verifier_func: Optional[str] = Field(None, title='Verifier Func')
+    version: Optional[str] = Field(None, title='Version')
+    env_variables: Optional[Dict[str, Any]] = Field(None, title='Env Variables')
+    verifier: Optional[VerifierData] = Field(None, title='Verifier')
 
 
 class ValidationError(BaseModel):

fleet/verifiers/__init__.py

@@ -1,7 +1,7 @@
 """Fleet verifiers module - database snapshot validation utilities and verifier decorator."""
 
-from fleet.verifiers.db import DatabaseSnapshot, IgnoreConfig, SnapshotDiff
-from fleet.verifiers.code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
+from .db import DatabaseSnapshot, IgnoreConfig, SnapshotDiff
+from .code import TASK_SUCCESSFUL_SCORE, TASK_FAILED_SCORE
 from .decorator import (
     verifier,
     SyncVerifierFunction,

fleet/verifiers/parse.py

@@ -140,4 +140,68 @@ def convert_verifier_string(verifier_str: str) -> str:
     # Replace TASK_FAILED_SCORE with 0 in the function string
     new_func = new_func.replace('TASK_FAILED_SCORE', '0')
 
-    return new_func
+    return new_func
+
+
+def convert_new_to_old_verifier(verifier_str: str) -> str:
+    """
+    Convert a verifier function from the new format (before/after: DatabaseSnapshot)
+    to the old format (env: Environment).
+    
+    This is the inverse of convert_verifier_string.
+    
+    Args:
+        verifier_str: The new format verifier function as a string
+        
+    Returns:
+        The converted verifier function string that accepts env
+    """   
+    # Extract function name, parameters, docstring, and body
+    # Pattern for new format with flexible whitespace and multiline support
+    func_pattern = r'def\s+(\w+)\s*\(\s*before\s*:\s*DatabaseSnapshot\s*,?\s*after\s*:\s*DatabaseSnapshot\s*,?\s*transcript\s*:\s*str\s*\|\s*None\s*=\s*None\s*,?\s*\)\s*->\s*int:\s*((?:\s*""".*?"""\s*)?)(.*)'
+    
+    # Try multiline pattern that's more flexible
+    func_pattern_multiline = r'def\s+(\w+)\s*\(\s*\n?\s*before\s*:\s*DatabaseSnapshot\s*,?\s*\n?\s*after\s*:\s*DatabaseSnapshot\s*,?\s*\n?\s*transcript\s*:\s*str\s*\|\s*None\s*=\s*None\s*,?\s*\n?\s*\)\s*->\s*int:\s*\n?((?:\s*""".*?"""\s*)?)(.*)'
+    
+    match = re.match(func_pattern_multiline, verifier_str.strip(), re.DOTALL | re.MULTILINE)
+    
+    if not match:
+        # Even more flexible pattern
+        func_pattern_flexible = r'def\s+(\w+)\s*\([^)]*\)\s*->\s*int:\s*\n?((?:\s*""".*?"""\s*)?)(.*)'
+        match = re.match(func_pattern_flexible, verifier_str.strip(), re.DOTALL)
+        
+        if not match:
+            raise ValueError("Could not parse new format verifier function")
+    
+    func_name = match.group(1)
+    docstring = match.group(2).strip()
+    body = match.group(3)
+    
+    # Indent the original function body
+    indented_verifier = '\n'.join('    ' + line if line.strip() else line for line in verifier_str.splitlines())
+    
+    # Build the wrapper function
+    wrapper_func = f'''def {func_name}_wrapper(env, *args, **kwargs) -> float:
+    """Wrapper to adapt new format verifier to old format."""
+    # Import required modules
+    from .verifiers.db import DatabaseSnapshot, IgnoreConfig
+    
+    # Constants
+    TASK_SUCCESSFUL_SCORE = 1
+    TASK_FAILED_SCORE = 0
+    
+    # Extract before and after from env
+    before = env.db("seed")
+    after = env.db("current")
+    
+    # Get transcript from kwargs if provided
+    transcript = kwargs.get('transcript', kwargs.get('final_answer', None))
+    
+    # Define the inner function
+{indented_verifier}
+    
+    # Call the inner function and convert result
+    result = {func_name}(before, after, transcript)
+    return float(result)'''
+    
+    return wrapper_func

fleet/verifiers/verifier.py

@@ -11,6 +11,7 @@ import functools
 import uuid
 import logging
 import hashlib
+import inspect
 from typing import Any, Callable, Dict, Optional, List, TypeVar, Set
 
 from .bundler import FunctionBundler
@@ -38,16 +39,19 @@ class SyncVerifierFunction:
         func: F,
         key: str,
         extra_requirements: Optional[List[str]] = None,
-        verifier_id: Optional[str] = None
+        verifier_id: Optional[str] = None,
+        sha256: Optional[str] = None,
+        raw_code: Optional[str] = None
     ):
         self.func = func
         self.key = key
         self.verifier_id = verifier_id or str(uuid.uuid4())
         self.extra_requirements = extra_requirements or []
         self._bundler = FunctionBundler()
-        self._bundle_sha: Optional[str] = None  # Cached bundle SHA
+        self._bundle_sha: Optional[str] = sha256  # Use provided SHA if available
         self._bundle_data: Optional[bytes] = None  # Cached bundle data
-        self._is_async = asyncio.iscoroutinefunction(func)
+        self._raw_code: Optional[str] = raw_code  # Store raw code if provided
+        self._is_async = inspect.iscoroutinefunction(func)
         
         # Copy function metadata
         functools.update_wrapper(self, func)
@@ -55,14 +59,40 @@ class SyncVerifierFunction:
     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:
-            # Create bundle and cache it
-            self._bundle_data = self._bundler.create_bundle(
-                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}")
+            # If we have raw code, create a bundle from it
+            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:
+                    # 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}")
+            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._bundle_sha = _get_bundle_sha(self._bundle_data)
+                    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
     
@@ -70,6 +100,11 @@ class SyncVerifierFunction:
         """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")
@@ -121,12 +156,13 @@ class SyncVerifierFunction:
     
     def remote(self, env: SyncEnv, *args, **kwargs) -> float:
         """Remote execution of the verifier function with SHA-based bundle caching."""
-        if self._is_async:
-            raise NotImplementedError(
-                f"Async verifier '{self.key}' cannot be executed remotely. "
-                "The remote execution environment only supports synchronous functions. "
-                "Please provide a synchronous version of your verifier."
-            )
+        # Async verifiers are now supported by the backend
+        # if self._is_async:
+        #     raise NotImplementedError(
+        #         f"Async verifier '{self.key}' cannot be executed remotely. "
+        #         "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})
@@ -162,11 +198,12 @@ class SyncVerifierFunction:
                 bundle_data, _ = self._get_or_create_bundle()
                 
                 response = env.execute_verifier_remote(
-                    bundle_data=bundle_data,  # Still need bundle_data for local caching
+                    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
                 )
@@ -248,7 +285,9 @@ Remote traceback:
 
 def verifier(
     key: Optional[str] = None,
-    extra_requirements: Optional[List[str]] = None
+    extra_requirements: Optional[List[str]] = None,
+    sha256: Optional[str] = None,
+    raw_code: Optional[str] = None
 ) -> Callable[[F], SyncVerifierFunction]:
     """
     Decorator to create a verifier function with env-first pattern.
@@ -260,6 +299,8 @@ def verifier(
     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)
@@ -297,7 +338,9 @@ def verifier(
             func,
             verifier_key,
             extra_requirements,
-            verifier_uuid
+            verifier_uuid,
+            sha256,
+            raw_code
         )
     
     return decorator

{fleet_python-0.2.25.dist-info → fleet_python-0.2.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.25
+Version: 0.2.27
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -66,6 +66,7 @@ export FLEET_API_KEY="sk_your_key_here"
 
 ```python
 import fleet as flt
+import datetime
 
 # Create environment by key
 env = flt.env.make("fira")
@@ -73,11 +74,11 @@ env = flt.env.make("fira")
 # Reset environment with seed and options
 env.reset(
     seed=42,
-    timestamp=datetime.now()
+    timestamp=int(datetime.datetime.now().timestamp())
 )
 
-# Access environment state ('crm' is the resource id for a sqlite database)
-sql = env.state("sqlite://crm")
+# Access environment state ('current' is the resource id for a sqlite database)
+sql = env.state("sqlite://current")
 sql.exec("UPDATE customers SET status = 'active' WHERE id = 123")
 
 # Clean up

{fleet_python-0.2.25.dist-info → fleet_python-0.2.27.dist-info}/RECORD

@@ -6,7 +6,8 @@ examples/example_client.py,sha256=70HKEhz_Gb79YcvKQauCPdS08AAwjo9unt2dh1jN_Oo,10
 examples/example_mcp_anthropic.py,sha256=iyO0OCem5SWEtJQGan6pBuGfN3LZXeeIN9DdMHw9f9M,2542
 examples/example_mcp_openai.py,sha256=5BQzMWrNdtBrBCNcUYgU6qB9Aabc10UTMKvaFb4NerI,492
 examples/example_sync.py,sha256=l8l-QOGTMnijiSK0mt5aofzXqbv-kKU3WCow4QS-7yg,976
-examples/example_task.py,sha256=vXIUQHXRPM3lVEJOT7o0oVFZU8no3u_2BoSK1VRnHKA,6811
+examples/example_task.py,sha256=W6Cuhtb06FWv2N972KjdVBdbNzkHwLBEZBTAeoHrweQ,7014
+examples/example_tasks.py,sha256=tZMtT7wNzv6jb4VYoEKeR0eX-dJhwajTtoBN-os6-I4,776
 examples/example_verifier.py,sha256=PfGphI6gnfhSM_SRb4KyhHYddJmapk2hhRrSIaxAtr4,2025
 examples/gemini_example.py,sha256=8mDXGGCaodyK6uXgpWhxi-DQ5OA-GFW12Gfwh0b3EDY,16177
 examples/json_tasks_example.py,sha256=3ub2LLiC6hXpVEH1175QxCmfCD3Blfo3yoG85uV5CS8,5334
@@ -17,18 +18,17 @@ examples/query_builder_example.py,sha256=Q3lUBETHpu1aS2FXAO79ADYqCxOjMMMZNgCcFVa
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 fleet/__init__.py,sha256=2WHAk_ZRIxDs1uxrWf-sSeokiK4f_nDVHJJ1_VUFSPA,2306
 fleet/base.py,sha256=0yYuMN0lBkrfTTZBt5NQp5112xWgziuWEk4GuHJB1wE,9189
-fleet/client.py,sha256=K7tLdwvLx-ExGtNoIDqsuROb-egaM-OxGijI19vnUqY,12069
+fleet/client.py,sha256=Nb4m6AX7uG6k0hdNqyBzAcEdYu1kJLicUnzvTAE_u8Y,20242
 fleet/config.py,sha256=rqR-y2TbZS-VYACaqrg-PUe0y0UDbR1ZNU1KGJZBwNQ,272
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/models.py,sha256=trtM-3A2wW4pOg6EvbKxiukU2clSNFrj4Uax7l2uiIM,11665
-fleet/tasks.py,sha256=OScp0tHIbCmOpmCFzHATBmA7WiJMlehP3rvEfeMAoPk,1648
+fleet/models.py,sha256=6SqoWdTIygF3jriZW53a-jQ1JZoPatuWZ4JQ1qIY5MY,12453
 fleet/types.py,sha256=eXeI8BFmiU5hln0PVvJbUZs7BSjl6wSqAtN9zaJT6yY,652
 fleet/_async/__init__.py,sha256=AJWCnuo7XKja4yBb8fK2wX7ntciLXQrpzdRHwjTRP6M,62
 fleet/_async/base.py,sha256=s0rYOtXsMJeitOvpa-Oh8ciLV226p_TIPp3fplzWvV4,9209
-fleet/_async/client.py,sha256=2LlMFO5cnLIwvunSixKRk3kJ-F55WufmoyutwgDYf64,12414
+fleet/_async/client.py,sha256=O2LB8FyJ4rGzAuE8nAeycYZAACQGPPENMKS7YDhTOmA,20388
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/_async/models.py,sha256=trtM-3A2wW4pOg6EvbKxiukU2clSNFrj4Uax7l2uiIM,11665
-fleet/_async/tasks.py,sha256=7ddJWkgulGW7dTPVQUUcl2L0HgsajmMQY6AUblHpG8A,1649
+fleet/_async/models.py,sha256=6SqoWdTIygF3jriZW53a-jQ1JZoPatuWZ4JQ1qIY5MY,12453
+fleet/_async/tasks.py,sha256=CJDt3dhg_88bHUYVqp2WcVenh6Y41wvp_iMaRiJeFDs,4069
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=MR2Ju7AudGWmztTVUPPut-ys3yqD7D00D_jsxZaRybA,858
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
@@ -38,32 +38,32 @@ fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 fleet/_async/resources/base.py,sha256=ZFx2I9L7px-Z8LvbPUZJtbtajpqUn1yS1NFbZZutP9Q,668
 fleet/_async/resources/browser.py,sha256=oldoSiymJ1lJkADhpUG81ViOBDNyppX1jSoEwe9-W94,1369
 fleet/_async/resources/sqlite.py,sha256=DvDLRI5dJ7_v4WkHw-Zday1M_FQUdzAqUCy9FtfOY8w,26636
-fleet/_async/verifiers/__init__.py,sha256=Z2Ic77mw6-mhF5CmVrucmDnAGSTAtiejR_eZjTjPPA0,447
+fleet/_async/verifiers/__init__.py,sha256=7dtLOFgirYQmEIiDMcx02-ZqR7yqrfjOiqBBuXBz914,466
 fleet/_async/verifiers/bundler.py,sha256=A4yR3wBOcVZYFAv87CD58QlJn6L4QXeilrasnVm8n74,26185
-fleet/_async/verifiers/verifier.py,sha256=-BNKVKVpg_x4VoPNafEEIGZrP0u7Nh-7OKN6juCiqqs,12322
+fleet/_async/verifiers/verifier.py,sha256=vS2Nv-tLgDa_1xhMHdkw0297uNMzzSlRPsXe4zIJsqw,14528
 fleet/env/__init__.py,sha256=Wt6mO2dQnOdzdjOCvtiIP49wpSrmS7OaZ_OeHNrzqsY,595
 fleet/env/client.py,sha256=2FzA7qfR-B7tVdCNa4uQk10g8zXV-9MNjAqx2D5vQ7c,710
 fleet/instance/__init__.py,sha256=-Anms7Vw_FO8VBIvwnAnq4rQjwl_XNfAS-i7bypHMow,478
 fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
-fleet/instance/client.py,sha256=4x-3IZZNwlK02OJLKp7mhSymRgXk8NToRCDU3ZuDnJ0,5891
+fleet/instance/client.py,sha256=0gNXWRKNSXUqVTf6E5VUFO2gEZrBTF87QnvpLr5xaD8,5895
 fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
 fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/resources/base.py,sha256=203gD54NP1IvjuSqFo-f7FvrkhtjChggtzrxJK7xf2E,667
 fleet/resources/browser.py,sha256=hRNM0YMsVQUAraZGNi_B-KXxLpuddy4ntoEDFSw7czU,1295
 fleet/resources/mcp.py,sha256=lDMyY4pMC3Khwp2Wycc6Ds6KeLAUOgHkDnmztuAnXm8,1872
 fleet/resources/sqlite.py,sha256=FeAykW7T0Pol7ckDLCtcjJDHDTI7y9ilWp7fnw4tuM8,26266
-fleet/verifiers/__init__.py,sha256=9sRqYEjPN-EGMhytkw0Q68vay7azmpY9TvkBJQ3_8Os,489
+fleet/verifiers/__init__.py,sha256=qfjAuF_QKu7rPD8yNtBcGMaAUiyCoECDma3MHgSTUuQ,459
 fleet/verifiers/bundler.py,sha256=A4yR3wBOcVZYFAv87CD58QlJn6L4QXeilrasnVm8n74,26185
 fleet/verifiers/code.py,sha256=EOi6ES8Zdzlm9iybRFaJmz9t2W4Ulo2wrCdbEBqxzbc,47
 fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
 fleet/verifiers/decorator.py,sha256=Q-KHhicnIYFwX7FX_VZguzNfu8ZslqNUeWxcS2CwNVY,3386
-fleet/verifiers/parse.py,sha256=FYbzgX86dLAxoAZ3jXfu6zRPlNxgzjTkhO3yxMC0hZ4,5261
+fleet/verifiers/parse.py,sha256=W4cBnto-XfPNrRwsYs7PFR3QJoI5UfWyB-QWsm1jUEg,7844
 fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
-fleet/verifiers/verifier.py,sha256=XVK6a17GnQjxjEkYgl05QKjlmqTA5sWf-eGzcM-QR7E,12249
-fleet_python-0.2.25.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-scripts/fix_sync_imports.py,sha256=zangqElfqIvIc-E0S46m6R-51pTZ6gbd8oUVkvCGzJo,4768
+fleet/verifiers/verifier.py,sha256=7yiqko332lX0pgjbyAQ6KbaGm_V8TX864ceH-4fvvW0,14470
+fleet_python-0.2.27.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scripts/fix_sync_imports.py,sha256=m2OHz1lCAdDVIRhPvn8grNXpRaPo1b99dRMYI7TiEes,7117
 scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
-fleet_python-0.2.25.dist-info/METADATA,sha256=K9TL_OP6vnVBzED_sXSpvZDli67CXfQ5FKOotwEMkKg,3297
-fleet_python-0.2.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.25.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.25.dist-info/RECORD,,
+fleet_python-0.2.27.dist-info/METADATA,sha256=LS8LDwtM3SwLodzsypJJRxoaag9-9pP5cMvYD5yUkas,3347
+fleet_python-0.2.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.27.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.27.dist-info/RECORD,,