fleet-python 0.2.45__py3-none-any.whl → 0.2.47__py3-none-any.whl

fleet/_async/models.py

@@ -273,6 +273,12 @@ class VerifiersExecuteResponse(BaseModel):
     result: Optional[Any] = Field(
         None, description="The return value of the function", title="Result"
     )
+    verifier_id: Optional[str] = Field(
+        None, description="ID of the verifier", title="Verifier Id"
+    )
+    execution_id: Optional[str] = Field(
+        None, description="ID of the execution record", title="Execution Id"
+    )
     error: Optional[Dict[str, Any]] = Field(
         None, description="Error details if verification failed", title="Error"
     )

fleet/_async/tasks.py

@@ -3,13 +3,16 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Any, Dict, Optional, List
+from typing import Any, Dict, Optional, List, TYPE_CHECKING
 
 from pydantic import BaseModel, Field, validator
 
 # Import the shared VerifierFunction type that works for both async and sync
 from fleet.types import VerifierFunction
 
+if TYPE_CHECKING:
+    from fleet._async.models import VerifiersExecuteResponse
+
 
 class Task(BaseModel):
     """A task model representing a single task in the Fleet system."""
@@ -24,9 +27,9 @@ class Task(BaseModel):
     version: Optional[str] = Field(None, description="Task version")
     verifier_func: Optional[str] = Field(None, description="Verifier function code")
     verifier: Optional[Any] = Field(
-        None, 
+        None,
         description="Verifier function with decorator (async or sync)",
-        exclude=True  # Exclude from JSON serialization
+        exclude=True,  # Exclude from JSON serialization
     )
     verifier_id: Optional[str] = Field(None, description="Verifier identifier")
     verifier_sha: Optional[str] = Field(None, description="Verifier SHA256 hash")
@@ -68,7 +71,7 @@ class Task(BaseModel):
         # If verifier doesn't exist but verifier_func does, rebuild it
         if not self.verifier and self.verifier_func:
             self._rebuild_verifier()
-            
+
         if self.verifier:
             import asyncio
             import inspect
@@ -102,7 +105,7 @@ class Task(BaseModel):
         # If verifier doesn't exist but verifier_func does, rebuild it
         if not self.verifier and self.verifier_func:
             self._rebuild_verifier()
-            
+
         if self.verifier:
             result = self.verifier.remote(*args, **kwargs)
             # If it's a coroutine, await it
@@ -115,6 +118,65 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
+    async def verify_detailed_async(
+        self, *args, **kwargs
+    ) -> "VerifiersExecuteResponse":
+        """Verify the task and return the full execute response model.
+
+        For async environments, awaits the async verifier.
+        Works with both sync and async verifiers in async contexts.
+        """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
+        if self.verifier:
+            result = self.verifier.remote_with_response(*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")
+
+    def verify_detailed(self, env, *args, **kwargs) -> "VerifiersExecuteResponse":
+        """Verify the task and return the full execute response model (sync version).
+
+        For sync environments, calls the sync verifier directly.
+        For async verifiers, automatically runs them with asyncio.run().
+        """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
+        if self.verifier:
+            import asyncio
+            import inspect
+
+            # Check if verifier has remote_with_response method (for decorated verifiers)
+            result = self.verifier.remote_with_response(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
+                try:
+                    asyncio.get_running_loop()
+                    # We're in an async context, can't use asyncio.run()
+                    raise RuntimeError(
+                        "Cannot run async verifier in sync mode while event loop is running. "
+                        "Use await task.verify_detailed_async() instead."
+                    )
+                except RuntimeError:
+                    # No event loop running, safe to use asyncio.run()
+                    return asyncio.run(result)
+            else:
+                return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
     def _rebuild_verifier(self):
         """Rebuild the verifier from verifier_func string if it exists."""
         if self.verifier_func:
@@ -127,7 +189,7 @@ class Task(BaseModel):
                 sha256=self.verifier_sha or "",
             )
             self.verifier = verifier
-    
+
     async def make_env(self, region: Optional[str] = None):
         """Create an environment instance for this task's environment.
 

fleet/_async/verifiers/verifier.py

@@ -12,17 +12,17 @@ import uuid
 import logging
 import hashlib
 import asyncio
-from typing import Any, Callable, Dict, Optional, List, TypeVar, Set, Tuple
+from typing import Any, Callable, Dict, Optional, List, TypeVar, Tuple
 
 from .bundler import FunctionBundler
 from ..client import AsyncEnv
+from ...models import VerifiersExecuteResponse
 
 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()
+# Removed global cache - always check server for bundle status
 
 
 @functools.lru_cache(maxsize=128)
@@ -107,25 +107,16 @@ class AsyncVerifierFunction:
             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
+        # Always check if bundle exists on server
         try:
             exists = await env.check_bundle_exists(bundle_sha)
             if exists.success:
-                logger.info(
-                    f"Bundle {bundle_sha[:8]}... found on server, updating cache"
-                )
-                _uploaded_bundle_shas.add(bundle_sha)
+                logger.info(f"Bundle {bundle_sha[:8]}... found on server")
                 return bundle_sha, False  # Found on server, no upload needed
         except Exception as e:
             logger.warning(f"Failed to check bundle existence: {e}")
 
-        # 3. Bundle not found locally or on server - upload needed
+        # Bundle not found on server - upload needed
         logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
         return bundle_sha, True  # Upload needed
 
@@ -162,74 +153,15 @@ class AsyncVerifierFunction:
 
     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
-        # 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})
-        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,
-                    key=self.key,
-                    function_name=self.func.__name__,
-                    args=args,
-                    args_array=args_array,
-                    kwargs=kwargs,
-                    needs_upload=True,
-                )
+        response = await self.remote_with_response(env, *args, **kwargs)
 
-                # 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 = await env.execute_verifier_remote(
-                    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
-                )
-
-            # 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"):
-                logger.error(f"Server response: {e.response.text}")
-            raise
+        # Handle response
+        if response.stdout:
+            print(response.stdout)
+        if response.success:
+            return self._process_result(response.result)
+        else:
+            self._raise_remote_error(response.error)
 
     def _process_result(self, result: Any) -> float:
         """Process remote execution result, handling different return types."""
@@ -269,7 +201,7 @@ Remote traceback:
         try:
             exception_class = getattr(__builtins__, error_type, RuntimeError)
             raise exception_class(full_message)
-        except:
+        except Exception:
             raise RuntimeError(full_message)
 
     def _get_env_id(self, env: AsyncEnv) -> str:
@@ -292,6 +224,74 @@ Remote traceback:
             or "not found" in error_msg
         )
 
+    async def remote_with_response(
+        self, env: "AsyncEnv", *args, **kwargs
+    ) -> "VerifiersExecuteResponse":
+        """Remote execution of the verifier function that returns the full response model."""
+        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,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=True,
+                )
+
+                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
+
+            else:
+                # Bundle already available - execute without upload
+                logger.info(f"Bundle {bundle_sha[:8]}... already cached for {self.key}")
+                response = await env.execute_verifier_remote(
+                    bundle_data=b"",  # Empty bundle since it's cached
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=False,
+                )
+
+            return response
+
+        except Exception as e:
+            # Check if error indicates bundle not found and retry with upload
+            if self._is_bundle_not_found_error(e) and not needs_upload:
+                logger.info(
+                    f"Bundle {bundle_sha[:8]}... not found on server, uploading..."
+                )
+                bundle_data, _ = self._get_or_create_bundle()
+                response = await env.execute_verifier_remote(
+                    bundle_data=bundle_data,
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=True,
+                )
+                return response
+            else:
+                logger.error(f"Error in remote execution of {self.key}: {e}")
+                raise
+
 
 def verifier(
     key: Optional[str] = None,

fleet/client.py

@@ -579,6 +579,8 @@ class Fleet:
             task = Task(**task_data)
             tasks.append(task)
 
+        responses = []
+
         for task in tasks:
             payload = TaskRequest(
                 key=task.key,
@@ -592,10 +594,13 @@ class Fleet:
                 response = self.client.request(
                     "POST", "/v1/tasks", json=payload.model_dump()
                 )
+                responses.append(response)
             except Exception as e:
                 logger.error(f"Failed to import task {task.key}: {e}")
                 continue
 
+        return responses
+
     def account(self) -> AccountResponse:
         """Get account information including instance limits and usage.
 

fleet/models.py

@@ -275,6 +275,12 @@ class VerifiersExecuteResponse(BaseModel):
     result: Optional[Any] = Field(
         None, description="The return value of the function", title="Result"
     )
+    verifier_id: Optional[str] = Field(
+        None, description="ID of the verifier", title="Verifier Id"
+    )
+    execution_id: Optional[str] = Field(
+        None, description="ID of the execution record", title="Execution Id"
+    )
     error: Optional[Dict[str, Any]] = Field(
         None, description="Error details if verification failed", title="Error"
     )

fleet/tasks.py

@@ -4,13 +4,16 @@ from __future__ import annotations
 
 import asyncio
 from datetime import datetime
-from typing import Any, Dict, Optional, List
+from typing import Any, Dict, Optional, List, TYPE_CHECKING
 
 from pydantic import BaseModel, Field, validator
 
 # Import the shared VerifierFunction type that works for both async and sync
 from fleet.types import VerifierFunction
 
+if TYPE_CHECKING:
+    from fleet.models import VerifiersExecuteResponse
+
 
 class Task(BaseModel):
     """A task model representing a single task in the Fleet system."""
@@ -116,6 +119,57 @@ class Task(BaseModel):
         else:
             raise ValueError("No verifier function found for this task")
 
+    def verify_detailed(self, env, *args, **kwargs) -> "VerifiersExecuteResponse":
+        """Verify the task and return the full execute response model.
+
+        For sync environments, calls the sync verifier directly.
+        For async verifiers, automatically runs them with asyncio.run().
+        """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
+        if self.verifier:
+            import inspect
+
+            # Check if verifier has remote_with_response method (for decorated verifiers)
+            result = self.verifier.remote_with_response(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
+                try:
+                    asyncio.get_running_loop()
+                    # We're in an async context, can't use asyncio.run()
+                    raise RuntimeError(
+                        "Cannot run async verifier in sync mode while event loop is running. "
+                        "Use await task.verify_detailed_async() instead."
+                    )
+                except RuntimeError:
+                    # No event loop running, safe to use asyncio.run()
+                    return asyncio.run(result)
+            else:
+                return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
+    def verify_detailed_async(self, *args, **kwargs) -> "VerifiersExecuteResponse":
+        """Verify the task and return the full execute response model (async version).
+
+        For async environments, returns a coroutine that when awaited returns the response.
+        Works with both sync and async verifiers in async contexts.
+        """
+        # If verifier doesn't exist but verifier_func does, rebuild it
+        if not self.verifier and self.verifier_func:
+            self._rebuild_verifier()
+
+        if self.verifier:
+            result = self.verifier.remote_with_response(*args, **kwargs)
+            # Return the result (could be a coroutine or a value)
+            return result
+        else:
+            raise ValueError("No verifier function found for this task")
+
     def _rebuild_verifier(self):
         """Rebuild the verifier from verifier_func string if it exists."""
         if self.verifier_func:

fleet/verifiers/verifier.py

@@ -19,7 +19,6 @@ from typing import (
     Optional,
     List,
     TypeVar,
-    Set,
     TYPE_CHECKING,
     Tuple,
 )
@@ -28,13 +27,13 @@ from .bundler import FunctionBundler
 
 if TYPE_CHECKING:
     from ..client import SyncEnv
+    from ..models import VerifiersExecuteResponse
 
 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()
+# Removed global cache - always check server for bundle status
 
 
 @functools.lru_cache(maxsize=128)
@@ -119,25 +118,16 @@ class SyncVerifierFunction:
             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
+        # Always check if bundle exists on server
         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)
+                logger.info(f"Bundle {bundle_sha[:8]}... found on server")
                 return bundle_sha, False  # Found on server, no upload needed
         except Exception as e:
             logger.warning(f"Failed to check bundle existence: {e}")
 
-        # 3. Bundle not found locally or on server - upload needed
+        # Bundle not found on server - upload needed
         logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
         return bundle_sha, True  # Upload needed
 
@@ -174,74 +164,15 @@ class SyncVerifierFunction:
 
     def remote(self, env: "SyncEnv", *args, **kwargs) -> float:
         """Remote execution of the verifier function with SHA-based bundle caching."""
-        # 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})
-        args = tuple(args_array)
-
-        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,
-                    args_array=args_array,
-                    kwargs=kwargs,
-                    needs_upload=True,
-                )
+        response = self.remote_with_response(env, *args, **kwargs)
 
-                # 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 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
-                )
-
-            # 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"):
-                logger.error(f"Server response: {e.response.text}")
-            raise
+        # Handle response
+        if response.stdout:
+            print(response.stdout)
+        if response.success:
+            return self._process_result(response.result)
+        else:
+            self._raise_remote_error(response.error)
 
     def _process_result(self, result: Any) -> float:
         """Process remote execution result, handling different return types."""
@@ -281,7 +212,7 @@ Remote traceback:
         try:
             exception_class = getattr(__builtins__, error_type, RuntimeError)
             raise exception_class(full_message)
-        except:
+        except Exception:
             raise RuntimeError(full_message)
 
     def _get_env_id(self, env: "SyncEnv") -> str:
@@ -304,6 +235,74 @@ Remote traceback:
             or "not found" in error_msg
         )
 
+    def remote_with_response(
+        self, env: "SyncEnv", *args, **kwargs
+    ) -> "VerifiersExecuteResponse":
+        """Remote execution of the verifier function that returns the full response model."""
+        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 = 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,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=True,
+                )
+
+                logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
+                return response
+
+            else:
+                # Bundle already available - execute without upload
+                logger.info(f"Bundle {bundle_sha[:8]}... already cached for {self.key}")
+                response = env.execute_verifier_remote(
+                    bundle_data=b"",  # Empty bundle since it's cached
+                    bundle_sha=bundle_sha,
+                    key=self.key,
+                    function_name=self.func.__name__,
+                    args=args,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=False,
+                )
+                return response
+
+        except Exception as e:
+            # Check if error indicates bundle not found and retry with upload
+            if self._is_bundle_not_found_error(e) and not needs_upload:
+                logger.info(
+                    f"Bundle {bundle_sha[:8]}... not found on server, uploading..."
+                )
+                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,
+                    args_array=args_array,
+                    kwargs=kwargs,
+                    needs_upload=True,
+                )
+                return response
+            else:
+                logger.error(f"Error in remote execution of {self.key}: {e}")
+                raise
+
 
 def verifier(
     key: Optional[str] = None,

{fleet_python-0.2.45.dist-info → fleet_python-0.2.47.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.45
+Version: 0.2.47
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0

{fleet_python-0.2.45.dist-info → fleet_python-0.2.47.dist-info}/RECORD

@@ -21,20 +21,20 @@ examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
 fleet/__init__.py,sha256=Mkdeh45N47lnSv73Eehj92cGU-AImUitvDWJLFhEp0Y,3844
 fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
-fleet/client.py,sha256=TOSHgaYUduK6g0vrmVnbisdJ5EPH8bNQXYSZrzgjgv0,27038
+fleet/client.py,sha256=Nk7XQS1-sVMkRWh99ZziHVEQ3ta67901oQd6tNZGi8I,27131
 fleet/config.py,sha256=uY02ZKxVoXqVDta-0IMWaYJeE1CTXF_fA9NI6QUutmU,319
 fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
-fleet/models.py,sha256=WAiRXa68aXSVbCqmQMn36n9cSlls6YsicV6BbyoeiYQ,12750
-fleet/tasks.py,sha256=3VKk3g1gXXhy-N9QnDq2eTdNK9rJENn_N6_TKZU-uvY,9634
+fleet/models.py,sha256=_Gy2wyHM5eUYP3-nOuxBUNTxI8AtteKX0_-jcVtS-os,12988
+fleet/tasks.py,sha256=1QLbjejJLZc5rkwpHBh3TS4X10Gc3t1pZIZCs005_3Q,12024
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
 fleet/_async/__init__.py,sha256=7C_JaEHoqZ4cddsCmlJ4z-UaU6Kr2CBZSgwx5B6fqnc,6765
 fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
 fleet/_async/client.py,sha256=ub6YGR8tBIEob3z5u8F0x0fktUYiVet87RN8iqJiY2I,27306
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
-fleet/_async/models.py,sha256=li5Cii7ASUHCFMFeJIMklyicYczqPez768RxO0Q0F2o,12618
-fleet/_async/tasks.py,sha256=TAS7IkSsS8rTW34blTaEPuWzuBqe8NezLpz1ozjP82M,9416
+fleet/_async/models.py,sha256=GX-sRciZDenW2O7Qx9w_ftOkJyE4ph1-92WMq6lynHE,12856
+fleet/_async/tasks.py,sha256=968pI3Ce2Kl83SJO6YeSA7SKVKSl9lRAd7TN1bACoXA,11906
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=8dS42VvSgdqfuh96l6cyiLZlKElilmfTeRSZ4LZnFuE,1143
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
@@ -47,7 +47,7 @@ fleet/_async/resources/mcp.py,sha256=TLEsLiFhfVfZFs0Fu_uDPm-h4FPdvqgQblYqs-PTHhc
 fleet/_async/resources/sqlite.py,sha256=0B6mI8Ad4-pxITMxlBST5RFcG6kqAqwnHW9PPAcpVLk,26185
 fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
 fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
-fleet/_async/verifiers/verifier.py,sha256=pfJFuQ4WsA71AowEESd-sWQUjCVWmG5PX2-GAxDm2-8,14350
+fleet/_async/verifiers/verifier.py,sha256=IiHX028s6ux0kb2FR0Z5zJangl_IDh6cemXsUN2ktUU,14152
 fleet/env/__init__.py,sha256=cS9zCYobM5jypppDMZIQMYd6hOg5f4sgqRXEQ67pckk,676
 fleet/env/client.py,sha256=imF47xJG4JeihcZw4Y-_fXz4XxS-OgIkzUK-TLjpeJY,977
 fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
@@ -66,11 +66,11 @@ fleet/verifiers/db.py,sha256=LAh1HambBInH_D9q9E2Z41YNkCOI9JJfpWPFqztjpfQ,27922
 fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,3260
 fleet/verifiers/parse.py,sha256=IaROVGmtmilsHQp2sMoJUJcB7tATLLsoHdF0TTWcoC0,8541
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
-fleet/verifiers/verifier.py,sha256=WViDlhEU9OEwWBjp7fvIW0-HltpuFcuXfzGazQnJUuw,14380
-fleet_python-0.2.45.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet/verifiers/verifier.py,sha256=_lcxXVm8e0xRrK2gNJy9up7pW1zOkPRY5n5lQ85S8jg,14197
+fleet_python-0.2.47.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=X9fWLTpiPGkSHsjyQUDepOJkxOqw1DPj7nd8wFlFqLQ,8368
 scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
-fleet_python-0.2.45.dist-info/METADATA,sha256=po9K7F5ILTQzLIR95WWM1l7seIpd68Mby99ggmdkgk0,3304
-fleet_python-0.2.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.45.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
-fleet_python-0.2.45.dist-info/RECORD,,
+fleet_python-0.2.47.dist-info/METADATA,sha256=QLRHeDWIHUFE9aJ4wtRSImYpKou3AnoTJdd871U1mlg,3304
+fleet_python-0.2.47.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.47.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.47.dist-info/RECORD,,