fleet-python 0.2.13__py3-none-any.whl → 0.2.16__py3-none-any.whl

fleet/verifiers/decorator.py

@@ -0,0 +1,103 @@
+"""Fleet SDK Verifier Decorator - Async Version.
+
+Provides a @verifier decorator that can wrap any sync function to support
+both local execution and remote execution via .remote() method.
+"""
+
+import inspect
+import functools
+import traceback
+from typing import Any, Callable, Dict, Optional, TypeVar, Union
+import uuid
+import logging
+
+logger = logging.getLogger(__name__)
+
+F = TypeVar('F', bound=Callable[..., Any])
+
+
+
+
+
+class SyncVerifierFunction:
+    """Wrapper for a verified function that supports local execution with env-first pattern."""
+    
+    def __init__(
+        self,
+        func: F,
+        key: str,
+        verifier_id: str
+    ):
+        self.func = func
+        self.key = key
+        self.name = key  # Keep name for backward compatibility
+        self.verifier_id = verifier_id
+        
+        # Copy function metadata
+        functools.update_wrapper(self, func)
+    
+    def __call__(self, env, *args, **kwargs) -> float:
+        """Local execution of the verifier function with env as first parameter."""
+        try:
+            result = self.func(env, *args, **kwargs)
+            
+            # Handle different return types
+            if isinstance(result, (int, float)):
+                # Direct score return
+                return float(result)
+            elif isinstance(result, dict) and "score" in result:
+                return float(result["score"])
+            else:
+                # Try to extract score from object attributes
+                if hasattr(result, 'score'):
+                    return float(result.score)
+                else:
+                    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
+
+def verifier(
+    key: Optional[str] = None,
+    verifier_id: Optional[str] = None
+) -> Callable[[F], SyncVerifierFunction]:
+    """
+    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.
+        verifier_id: Optional unique ID for the verifier. Defaults to generated UUID.
+    
+    Example:
+        @verifier(key="test_database_state")
+        def check_user_count(env, expected_count: int) -> float:
+            db = env.db()
+            result = db.query("SELECT COUNT(*) FROM users")
+            actual_count = result.rows[0][0]
+            return 1.0 if actual_count >= expected_count else 0.0
+        
+        # Usage with different environments
+        env1 = flt.env.make("fira")
+        env2 = flt.env.make("another_env")
+        
+        # Local execution
+        result = await check_user_count(env1, 5)
+        result = await check_user_count(env2, 5)  # Same verifier, different env
+    """
+    def decorator(func: F) -> SyncVerifierFunction:
+        verifier_key = key or func.__name__
+        verifier_uuid = verifier_id or str(uuid.uuid4())
+        
+        return SyncVerifierFunction(
+            func,
+            verifier_key,
+            verifier_uuid
+        )
+    
+    return decorator

fleet/verifiers/verifier.py

@@ -0,0 +1,301 @@
+"""Fleet SDK Verifier - Async Version.
+
+Provides a @verifier decorator that can wrap any sync function to support
+both local execution and remote execution via .remote() method.
+
+The decorated function must take 'env' as its first parameter, making it explicit
+that verifiers operate within an environment context.
+"""
+
+import functools
+import uuid
+import asyncio
+import logging
+import hashlib
+import inspect
+from typing import Any, Callable, Dict, Optional, List, TypeVar, Set, Union
+
+from .bundler import FunctionBundler
+from ..client import Environment
+
+logger = logging.getLogger(__name__)
+
+F = TypeVar('F', bound=Callable[..., Any])
+
+# Global cache to track which bundle SHAs have been uploaded to S3
+_uploaded_bundle_shas: Set[str] = set()
+
+
+@functools.lru_cache(maxsize=128)
+def _get_bundle_sha(bundle_data: bytes) -> str:
+    """Calculate SHA256 hash of bundle data with LRU caching."""
+    return hashlib.sha256(bundle_data).hexdigest()
+
+
+class SyncVerifierFunction:
+    """Wrapper for a verified function that supports local execution with env-first pattern."""
+    
+    def __init__(
+        self,
+        func: F,
+        key: str,
+        extra_requirements: Optional[List[str]] = None,
+        verifier_id: Optional[str] = None
+    ):
+        self.func = func
+        self.key = key
+        self.name = key  # Keep name for backward compatibility
+        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_data: Optional[bytes] = None  # Cached bundle data
+        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:
+            # 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.name} with SHA: {self._bundle_sha}")
+        
+        return self._bundle_data, self._bundle_sha
+    
+    def _check_bundle_status(self, env: Environment) -> tuple[str, bool]:
+        """Check if bundle needs to be uploaded and return (sha, needs_upload)."""
+        bundle_data, bundle_sha = self._get_or_create_bundle()
+        
+        # 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 = env.check_bundle_exists(bundle_sha)
+            if exists.success:
+                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
+    
+    def __call__(self, env: Environment, *args, **kwargs) -> float:
+        """Local execution of the verifier function with env as first parameter."""
+        try:
+            if self._is_async:
+                # For async functions, await the result
+                result = self.func(env, *args, **kwargs)
+            else:
+                # For sync functions, call directly
+                result = self.func(env, *args, **kwargs)
+            
+            # Handle different return types
+            if isinstance(result, (int, float)):
+                # Direct score return
+                return float(result)
+            elif isinstance(result, dict) and "score" in result:
+                # For local execution, return the full dict if that's what the function returns
+                return result
+            else:
+                # Try to extract score from object attributes
+                if hasattr(result, 'score'):
+                    return float(result.score)
+                else:
+                    raise ValueError(f"Verifier function must return a score (number). Got {type(result)}")
+                    
+        except Exception as e:
+            logger.error(f"Error in verifier {self.name}: {e}")
+            # Return error score 0
+            return 0.0
+    
+    def remote(self, env: Environment, *args, **kwargs) -> float:
+        """Remote execution of the verifier function with SHA-based bundle caching."""
+        if self._is_async:
+            raise NotImplementedError(
+                f"Async verifier '{self.name}' cannot be executed remotely. "
+                "The remote execution environment only supports synchronous functions. "
+                "Please provide a synchronous version of your verifier."
+            )
+        
+        try:
+            # Check if bundle needs to be uploaded
+            bundle_sha, needs_upload = 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 = env.execute_verifier_remote(
+                    bundle_data=bundle_data,
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    kwargs=kwargs,
+                    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}")
+                bundle_data, _ = self._get_or_create_bundle()
+                
+                response = env.execute_verifier_remote(
+                    bundle_data=bundle_data,  # Still need bundle_data for local caching
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    kwargs=kwargs,
+                    needs_upload=False  # Don't upload, just execute
+                )
+            
+            # Handle response
+            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'):
+                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
+        if isinstance(result, (int, float)):
+            return float(result)
+        elif isinstance(result, dict) and "score" in result:
+            return float(result["score"])
+        else:
+            # Try to extract score from object attributes
+            if hasattr(result, 'score'):
+                return float(result.score)
+            else:
+                # Best effort conversion
+                try:
+                    return float(result)
+                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:
+{message}
+
+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: Environment) -> 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'):
+            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
+        )
+
+
+def verifier(
+    key: Optional[str] = None,
+    extra_requirements: Optional[List[str]] = None
+) -> Callable[[F], SyncVerifierFunction]:
+    """
+    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.
+    
+    Example:
+        # Synchronous verifier (works locally and remotely)
+        @verifier(key="check_user_count")
+        def check_user_count(env, expected_count: int) -> float:
+            db = env.db()
+            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:
+            db = env.db()
+            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")
+        
+        # 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) -> SyncVerifierFunction:
+        verifier_key = key or func.__name__
+        verifier_uuid = str(uuid.uuid4())
+        
+        return SyncVerifierFunction(
+            func,
+            verifier_key,
+            extra_requirements,
+            verifier_uuid
+        )
+    
+    return decorator 

{fleet_python-0.2.13.dist-info → fleet_python-0.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.13
+Version: 0.2.16
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -25,6 +25,8 @@ Requires-Dist: pydantic>=2.0.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: httpx-retries>=0.4.0
 Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: modulegraph2>=0.2.0
+Requires-Dist: cloudpickle==3.1.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
@@ -114,44 +116,3 @@ running_instances = flt.env.list_instances(status_filter="running")
 # List available environment types
 available_envs = flt.env.list_envs()
 ```
-
-## Development
-
-### Code Structure
-
-This SDK uses `unasync` to maintain both async and sync versions of the code from a single source:
-
-- **`fleet/_async/`** - The source code (async version) - **EDIT THIS**
-- **`fleet/`** - The generated sync version - **DO NOT EDIT** (auto-generated)
-
-### Making Changes
-
-⚠️ **Important**: All code modifications should be made in the `fleet/_async/` directory. The synchronous versions in `fleet/` are automatically generated.
-
-1. Make your changes in `fleet/_async/`
-2. Run `make unasync` to generate the sync versions
-3. Test both async and sync versions
-4. Commit all changes (both async source and generated sync files)
-
-Example workflow:
-```bash
-# Edit the async source files
-vim fleet/_async/client.py
-
-# Generate sync versions
-make unasync
-
-# Run tests
-python examples/examle.py
-
-# Commit both source and generated files
-git add fleet/_async/ fleet/
-git commit -m "Add new feature"
-```
-
-### Why This Structure?
-
-- Single source of truth for business logic
-- Automatic sync/async API generation
-- Consistent behavior between sync and async versions
-- Easier maintenance and testing

fleet_python-0.2.16.dist-info/RECORD

@@ -0,0 +1,69 @@
+examples/diff_example.py,sha256=zXEPFC-_Ap_uEihf0Shs5R7W7Pq1I5i_Y_KC-TYxyQw,5643
+examples/dsl_example.py,sha256=tYHfSyuyhJUSL-nKDhMA4hgZgDVNQkF5RRJLof6H_WY,7163
+examples/example.py,sha256=SAz5iPxca8n9MvnHVoWHI7GCaTgJwkegX78rMutF9gE,1082
+examples/example_action_log.py,sha256=XrLqFNS8hD-K6nKVSohYi6oJkYotLCZJYJsGSbHuqEc,627
+examples/example_client.py,sha256=70HKEhz_Gb79YcvKQauCPdS08AAwjo9unt2dh1jN_Oo,1030
+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_verifier.py,sha256=PfGphI6gnfhSM_SRb4KyhHYddJmapk2hhRrSIaxAtr4,2025
+examples/gemini_example.py,sha256=8mDXGGCaodyK6uXgpWhxi-DQ5OA-GFW12Gfwh0b3EDY,16177
+examples/json_tasks_example.py,sha256=3ub2LLiC6hXpVEH1175QxCmfCD3Blfo3yoG85uV5CS8,5334
+examples/nova_act_example.py,sha256=hZLpObVsiXKQzqGwMZVMf4A2j_z4TYE-YO9pgNmaKPk,836
+examples/openai_example.py,sha256=I2vk_SJN9BkSRQCYRJfbtGJ-HJ2xzQj-lOjwqmLos5M,8234
+examples/openai_simple_example.py,sha256=I42ytIwv0INgDO39pp1MOQSqsJz2YYH8GeNNBaUtq3A,1748
+examples/query_builder_example.py,sha256=Q3lUBETHpu1aS2FXAO79ADYqCxOjMMMZNgCcFVapiII,3918
+examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
+fleet/__init__.py,sha256=V2y7yMsloc56E4QdluakrVRiITQLmasxmAOBJ1oJ3cU,2365
+fleet/base.py,sha256=0yYuMN0lBkrfTTZBt5NQp5112xWgziuWEk4GuHJB1wE,9189
+fleet/client.py,sha256=_1SwqqmgrYkzqm50X27yUdpEqe--vqBPmTLOImg6sdA,28514
+fleet/config.py,sha256=zd19st83NJdW9DdOq7Irpc0x-iUnMad0JOtAr_nD5DM,273
+fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
+fleet/models.py,sha256=YMHFAgBF4OqoAOv-arHze3bPDDZ5DAzb3CXhVLF6pPw,9019
+fleet/playwright.py,sha256=BmRvez5DUa0ttAQB084hPAyt9_8WxdzCGBGF-GZbTuQ,8593
+fleet/tasks.py,sha256=w-0vVGfEuCWRHMEJ73SN141J7Lz2pD_0v-nNG4TyJTU,1645
+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=1ooP-8uIXIpqeRlNR6JIdnOrzD4ZLxgd9Mi1qwsKRFo,10555
+fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
+fleet/_async/playwright.py,sha256=NXKcwJezl6jEV2CKBgeaB7zLshFWypgSA5GYXevDRX8,8908
+fleet/_async/tasks.py,sha256=w-0vVGfEuCWRHMEJ73SN141J7Lz2pD_0v-nNG4TyJTU,1645
+fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fleet/_async/env/client.py,sha256=PQGKcvnVTr3o2KNsgQM7ZBqaCjimv-wEn-XiYGm44Ko,753
+fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
+fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
+fleet/_async/instance/client.py,sha256=5fd_ABdlpmWIrDrOVnSs2XUUoXwcfvrV1LflLd7sqjw,5760
+fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fleet/_async/resources/base.py,sha256=ZFx2I9L7px-Z8LvbPUZJtbtajpqUn1yS1NFbZZutP9Q,668
+fleet/_async/resources/browser.py,sha256=oldoSiymJ1lJkADhpUG81ViOBDNyppX1jSoEwe9-W94,1369
+fleet/_async/resources/sqlite.py,sha256=d1wRLUIPIrKO6YaRaq3luPPQW_SjyRG1RJI67unu9jM,26633
+fleet/_async/verifiers/__init__.py,sha256=Z2Ic77mw6-mhF5CmVrucmDnAGSTAtiejR_eZjTjPPA0,447
+fleet/_async/verifiers/bundler.py,sha256=A4yR3wBOcVZYFAv87CD58QlJn6L4QXeilrasnVm8n74,26185
+fleet/_async/verifiers/verifier.py,sha256=ImrpduuEZFEvBeiKBxGN-cHXNLz6hWJGipVM90qfjdA,12242
+fleet/env/__init__.py,sha256=yYk657kVDnMWYbuPS_2o0kpVC99AYD85o5WG1jCaWSY,531
+fleet/env/client.py,sha256=HwJ-xCg3oZMJ48nP9_EaHk4Rao-na9myPX9X5JxYMbo,644
+fleet/instance/__init__.py,sha256=-Anms7Vw_FO8VBIvwnAnq4rQjwl_XNfAS-i7bypHMow,478
+fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
+fleet/instance/client.py,sha256=TgW2aGloF9qj_jloZQBKd62rRsrbBKPD7FmXXDdHBJU,5944
+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=OEqfNYPAptANza0T8K7UEn6nI7JnzlCICFMW8r2r83Q,1367
+fleet/resources/mcp.py,sha256=55LBwhNDqSeFVCD0O3OP9m2DdJE-KEYRQiCnVyze8DM,1864
+fleet/resources/sqlite.py,sha256=U0KneMzFKFrcuXcGrl4gkFPNoWST7_gWINphcA_UPJA,26251
+fleet/verifiers/__init__.py,sha256=-dm2x0wC8UbfGcMCbPtjb0-LospGUhD-S3Pm4oha6BY,445
+fleet/verifiers/bundler.py,sha256=A4yR3wBOcVZYFAv87CD58QlJn6L4QXeilrasnVm8n74,26185
+fleet/verifiers/code.py,sha256=NJ4OLZnpqLkI1lXY7-5m2GuZklLxMzHUCnRMVyN2_OI,25
+fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
+fleet/verifiers/decorator.py,sha256=Q-KHhicnIYFwX7FX_VZguzNfu8ZslqNUeWxcS2CwNVY,3386
+fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
+fleet/verifiers/verifier.py,sha256=C5L24M7VBHWKaWlryC1EdW1g7keZBGzVSjgXC_SlpXA,12205
+fleet_python-0.2.16.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scripts/fix_sync_imports.py,sha256=BIQfnaOoQ7bwR1c-pDqH9ifN47W1bwL7OafWVXZNkuA,4368
+scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
+fleet_python-0.2.16.dist-info/METADATA,sha256=cntZGoC-jIhNPMXU18gUUGLsoM752--JWZS5mRjGyhg,3297
+fleet_python-0.2.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.16.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.16.dist-info/RECORD,,

fleet_python-0.2.13.dist-info/RECORD

@@ -1,52 +0,0 @@
-examples/dsl_example.py,sha256=3Eu5924a8x61nuSGXqGz8XjPLNKKH8Ye7lSYHSvixtk,5361
-examples/example.py,sha256=SAz5iPxca8n9MvnHVoWHI7GCaTgJwkegX78rMutF9gE,1082
-examples/example_client.py,sha256=70HKEhz_Gb79YcvKQauCPdS08AAwjo9unt2dh1jN_Oo,1030
-examples/example_sync.py,sha256=l8l-QOGTMnijiSK0mt5aofzXqbv-kKU3WCow4QS-7yg,976
-examples/gemini_example.py,sha256=8mDXGGCaodyK6uXgpWhxi-DQ5OA-GFW12Gfwh0b3EDY,16177
-examples/json_tasks_example.py,sha256=3ub2LLiC6hXpVEH1175QxCmfCD3Blfo3yoG85uV5CS8,5334
-examples/nova_act_example.py,sha256=hZLpObVsiXKQzqGwMZVMf4A2j_z4TYE-YO9pgNmaKPk,836
-examples/openai_example.py,sha256=I2vk_SJN9BkSRQCYRJfbtGJ-HJ2xzQj-lOjwqmLos5M,8234
-examples/openai_simple_example.py,sha256=I42ytIwv0INgDO39pp1MOQSqsJz2YYH8GeNNBaUtq3A,1748
-examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
-fleet/__init__.py,sha256=-EFlLzHmyJIUGSZ4_XIts6OhXIXGPyu5PgI9JxgDzTg,2165
-fleet/base.py,sha256=E4gUv_eQEU4eSzTBy8gLGwl0s4t57OCTnsMYTKP3qI0,8782
-fleet/client.py,sha256=XT61Tnq9O4B8eF01X2fFQYD4twwyKUrEK1UJawvZbUo,5583
-fleet/config.py,sha256=9eWhJl81JinQJfZxD52t4Rgn5flnhhNqv2vGmddN2os,274
-fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/models.py,sha256=Jf6Zmk689TPXhTSnVENK_VCw0VsujWzEWsN3T29MQ0k,3713
-fleet/playwright.py,sha256=BmRvez5DUa0ttAQB084hPAyt9_8WxdzCGBGF-GZbTuQ,8593
-fleet/_async/__init__.py,sha256=AJWCnuo7XKja4yBb8fK2wX7ntciLXQrpzdRHwjTRP6M,62
-fleet/_async/base.py,sha256=qXdaKthvrE4ZyELIapuFS63dHV6ulEYPDqddgK9qX1g,8801
-fleet/_async/client.py,sha256=2ETcEUmpAdRToaUPmM4YGOPRXWwxoC4E9iM1Zk5BMwY,5842
-fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
-fleet/_async/playwright.py,sha256=2r4ywuv2ZqT0Qu3-k8A7V4YijeAOHnN8HiqJreLEYGI,8924
-fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/env/client.py,sha256=niS4uL8WY9G_lKyDhCqF5IdasxZJ3OCiiiJ5AG8_2a4,785
-fleet/_async/instance/__init__.py,sha256=LC-1PGi8UyUHh4oQSyT9ZUg2K30a0gkhEytTf1vsKIU,535
-fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
-fleet/_async/instance/client.py,sha256=ZndvSeNxpdX8gIkLr7z6_IhKWDDxfcORtvq9evRIST0,5742
-fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fleet/_async/resources/base.py,sha256=ZFx2I9L7px-Z8LvbPUZJtbtajpqUn1yS1NFbZZutP9Q,668
-fleet/_async/resources/browser.py,sha256=oldoSiymJ1lJkADhpUG81ViOBDNyppX1jSoEwe9-W94,1369
-fleet/_async/resources/sqlite.py,sha256=_haVOT97ai1N6etYT-ZnhjILYunjK6XFjs_t8Xb8o2o,1503
-fleet/env/__init__.py,sha256=yYk657kVDnMWYbuPS_2o0kpVC99AYD85o5WG1jCaWSY,531
-fleet/env/client.py,sha256=HwJ-xCg3oZMJ48nP9_EaHk4Rao-na9myPX9X5JxYMbo,644
-fleet/instance/__init__.py,sha256=Hr8xPPoqzKOViXZXWmaL6dQ7NOBn-GooTGzoIvGmiE4,514
-fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
-fleet/instance/client.py,sha256=GGBCf9Df1LxzwYXLPEbof-MJfGQs1BdZp7tvJR9Yi3I,5564
-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/sqlite.py,sha256=sZVWsuq46ger-ta6PSlqcXGJG8iWpNQVj0CPmDNBXv8,1446
-fleet/verifiers/__init__.py,sha256=mRMN8x0gDWFJ1MRLqdBtQw0gn_q8kDV3lMLyoiEf1yY,281
-fleet/verifiers/code.py,sha256=NJ4OLZnpqLkI1lXY7-5m2GuZklLxMzHUCnRMVyN2_OI,25
-fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
-fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
-fleet_python-0.2.13.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-scripts/fix_sync_imports.py,sha256=BIQfnaOoQ7bwR1c-pDqH9ifN47W1bwL7OafWVXZNkuA,4368
-scripts/unasync.py,sha256=--Fmaae47o-dZ1HYgX1c3Nvi-rMjcFymTRlJcWWnmpw,725
-fleet_python-0.2.13.dist-info/METADATA,sha256=JHCDePiOeKojRCtFXv7P4lVljs_pJyAl1alEjTabsA8,4358
-fleet_python-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.13.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.13.dist-info/RECORD,,