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

fleet/verifiers/verifier.py

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

{fleet_python-0.2.29.dist-info → fleet_python-0.2.34.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fleet-python
-Version: 0.2.29
+Version: 0.2.34
 Summary: Python SDK for Fleet environments
 Author-email: Fleet AI <nic@fleet.so>
 License: Apache-2.0
@@ -65,11 +65,11 @@ export FLEET_API_KEY="sk_your_key_here"
 ## Basic Usage
 
 ```python
-import fleet as flt
+import fleet
 import datetime
 
 # Create environment by key
-env = flt.env.make("fira")
+env = fleet.env.make("fira")
 
 # Reset environment with seed and options
 env.reset(
@@ -91,10 +91,10 @@ env.close()
 
 ```python
 # Create environment instance with explicit version
-env = flt.env.make("fira:v1.2.5")
+env = fleet.env.make("fira:v1.2.5")
 
 # Create environment instance with default (latest) version
-env = flt.env.make("fira")
+env = fleet.env.make("fira")
 
 ```
 
@@ -102,18 +102,18 @@ env = flt.env.make("fira")
 
 ```python
 # Connect to a running instance
-env = flt.env.get("env_instance_id")
+env = fleet.env.get("env_instance_id")
 
 # List all running instances
-instances = flt.env.list_instances()
+instances = fleet.env.list_instances()
 for instance in instances:
     print(f"Instance: {instance.instance_id}")
     print(f"Type: {instance.environment_type}")
     print(f"Status: {instance.status}")
 
 # Filter instances by status (running, pending, stopped, error)
-running_instances = flt.env.list_instances(status_filter="running")
+running_instances = fleet.env.list_instances(status_filter="running")
 
 # List available environment types
-available_envs = flt.env.list_envs()
+available_envs = fleet.env.list_envs()
 ```

fleet_python-0.2.34.dist-info/RECORD

@@ -0,0 +1,76 @@
+examples/diff_example.py,sha256=iLlpBW_NBjzXBqlvYwjx74uxYZkMGJfea6s3tJhvuNY,5684
+examples/dsl_example.py,sha256=yFLgM-Was4-w575xJgPk9DIBmXa34hLJsIB4XwTADOE,7252
+examples/example.py,sha256=yn9mqS2yJ6896s25btnJx9-_SLLbyS-Fu-SIcas6jok,1081
+examples/exampleResume.py,sha256=hzdL9QfYtwlje5geWS2cgWgjcnLX4UtXSAd-92F66Lw,7044
+examples/example_account.py,sha256=t5_Tnr7DcLYfNpEAbuBySQIqsqiQQGySuiItIghCjAM,225
+examples/example_action_log.py,sha256=pwvLro_Fkrw4DII002bHGuWfoZ6QRvUMDD9BnMqJgLQ,622
+examples/example_client.py,sha256=M9Mfi1FcD2LtSDVk89R_-tgG98swvDYy4qx2zVayJ-0,1025
+examples/example_mcp_anthropic.py,sha256=2ouLWAojhdnxhJc6yxkgo8e3TnNjC48yz8zpaPQm3Jw,2597
+examples/example_mcp_openai.py,sha256=xhqJd2-mnQs4-ZmydGrX7pPs7_X5i-YFqkO1cr3L-5g,480
+examples/example_sync.py,sha256=EkuWmUzB1ZsBJQk6ZRflB793rKsuRHeSg5HJZHVhBB0,975
+examples/example_task.py,sha256=dhG6STAkNsTdHs9cO1RFH9WfuvRmq5bRC211hTeFrk8,7088
+examples/example_tasks.py,sha256=Af57KbxpDxWWAVnjVC6IC0Rbxr_Z6kTEQk-XcDe4vTo,747
+examples/example_verifier.py,sha256=0vwNITIG3m4CkSPwIxNXcGx9TqrxEsCGqK2A8keKZMM,2392
+examples/gemini_example.py,sha256=qj9WDazQTYNiRHNeUg9Tjkp33lJMwbx8gDfpFe1sDQo,16180
+examples/json_tasks_example.py,sha256=CYPESGGtOo0fmsDdLidujTfsE4QlJHw7rOhyVqPJ_Ls,5329
+examples/nova_act_example.py,sha256=rH23Lp74Okf0rn8ynMdWjK2aviEf5NLPH4k_53Pyxho,831
+examples/openai_example.py,sha256=dEWERrTEP5xBiGkLkQjBQGd2NqoxX6gcW6XteBPsWFQ,8231
+examples/openai_simple_example.py,sha256=HmiufucrAZne7tHq9uoEsDWlEhjNC265bQAyIGBRU2o,1745
+examples/query_builder_example.py,sha256=-cOMfWGNifYfYEt_Ds73XpwATZvFDL6F4KTkVxdMjzg,3951
+examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
+examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
+fleet/__init__.py,sha256=LYJ8zS6Ldo5wLpRqsFMoiikkyosTmm7sRTUY4SnJAgE,3880
+fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
+fleet/client.py,sha256=JG9soTIkGK_uRezHU79PFn7PBXeN1iNpun1D4JDFTyE,22310
+fleet/config.py,sha256=uY02ZKxVoXqVDta-0IMWaYJeE1CTXF_fA9NI6QUutmU,319
+fleet/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
+fleet/global_client.py,sha256=oSWhV1cggVKQ0ec0YDOGu6Zr0Tgdcx3oKMM6s2Y9fQw,1073
+fleet/models.py,sha256=9tDjgcgKPMnf-R_MDh-Ocp_UMbyJ8tJyjb15XqU0N94,12454
+fleet/tasks.py,sha256=1AlNhe0WRggj3pIwTeaxMhpmMqI0MGBVjEmODVu37YI,5648
+fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
+fleet/_async/__init__.py,sha256=1X00u-0Zu4S-e8MGE9nJWbZEt3H-DHZA-gfwN-JuP2U,7415
+fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
+fleet/_async/client.py,sha256=cX5eFE4J1nfdXddarc2HcNQpBYzQejlVWwbM2n3URlg,22497
+fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
+fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
+fleet/_async/models.py,sha256=9tDjgcgKPMnf-R_MDh-Ocp_UMbyJ8tJyjb15XqU0N94,12454
+fleet/_async/tasks.py,sha256=jHGAvMkR3byayR429YSDiiIDV3W30y4UHZf9W6UhA8M,5721
+fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fleet/_async/env/client.py,sha256=Fx4jVEGlM4JB_pgk9lZutzPAOgp6Yi3vxt3waMPrMvM,971
+fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
+fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
+fleet/_async/instance/client.py,sha256=z9q_-dIBwPc1X6VlQOi_aV2v6KOKueJGg8NMyP5iFQM,6082
+fleet/_async/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fleet/_async/resources/base.py,sha256=UfrenxUqcpL8SgYGOo8o8HgRvv2-ZO5G2Cdo91ofEdg,664
+fleet/_async/resources/browser.py,sha256=oldoSiymJ1lJkADhpUG81ViOBDNyppX1jSoEwe9-W94,1369
+fleet/_async/resources/mcp.py,sha256=TLEsLiFhfVfZFs0Fu_uDPm-h4FPdvqgQblYqs-PTHhc,1720
+fleet/_async/resources/sqlite.py,sha256=h6pX41j8_aJaeZ7UVs25QQGgMWbHMPlGpDnPGMIAF6w,26133
+fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
+fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
+fleet/_async/verifiers/verifier.py,sha256=lwVIV5ZpWJhM87tXShtjwN5KP7n5XDcPq0XX7AjV6_E,14343
+fleet/env/__init__.py,sha256=6-zgP705M61tCquiDKw29dBZGq1US9mtsB1gQngJ4FQ,664
+fleet/env/client.py,sha256=I4pjnXGzifZSr7iZFdn0cTX6nLuGYo-sCt-qk4ez29Y,805
+fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
+fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
+fleet/instance/client.py,sha256=O6B0A2Z0b5SxOLs4TipZ9Ol8yG-b-LG15vVOKMmd6BQ,5908
+fleet/instance/models.py,sha256=ZTiue0YOuhuwX8jYfJAoCzGfqjLqqXRLqK1LVFhq6rQ,4183
+fleet/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fleet/resources/base.py,sha256=AXZzT0_yWHkT497q3yekfr0xsD4cPGMCC6y7C43TIkk,663
+fleet/resources/browser.py,sha256=hRNM0YMsVQUAraZGNi_B-KXxLpuddy4ntoEDFSw7czU,1295
+fleet/resources/mcp.py,sha256=c6O4vVJnXANuHMGMe4IPxgp4zBEbFaGm6_d9e6j8Myc,1695
+fleet/resources/sqlite.py,sha256=rwpYmfyw8CjlA-HEsD4fCqYS8wFMxaTiX_tO3gJxDjg,25763
+fleet/verifiers/__init__.py,sha256=IlImvlfgMRQ2V6f4_n7skXYBV8ZoUUjnWaFKnYQQsU8,459
+fleet/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
+fleet/verifiers/code.py,sha256=A1i_UabZspbyj1awzKVQ_HRxgMO3fU7NbkxYyTrp7So,48
+fleet/verifiers/db.py,sha256=tssmvJjDHuBIy8qlL_P5-UdmEFUw2DZcqLsWZ8ot3Xw,27766
+fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,3260
+fleet/verifiers/parse.py,sha256=0bAbj9VvT__yU4ZVREUK-Tn9dukh9LCpmfVsgj1DfP4,8508
+fleet/verifiers/sql_differ.py,sha256=dmiGCFXVMEMbAX519OjhVqgA8ZvhnvdmC1BVpL7QCF0,6490
+fleet/verifiers/verifier.py,sha256=53oBWAf0yy3bZmZx9eH9AWIf65H7OP2UUm0YwWCL6Mc,14286
+fleet_python-0.2.34.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+scripts/fix_sync_imports.py,sha256=0XKTkAV7WdMxRfk8-x4Ts1LjSbUpyI0tPL0DcTQ_38w,7308
+scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
+fleet_python-0.2.34.dist-info/METADATA,sha256=WmolSCZR49qXHttFTyPhRnEJxj6po_YbDeUhOnk4t9M,3354
+fleet_python-0.2.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.34.dist-info/top_level.txt,sha256=_3DSmTohvSDf3AIP_BYfGzhwO1ECFwuzg83X-wHCx3Y,23
+fleet_python-0.2.34.dist-info/RECORD,,