fleet-python 0.2.69__py3-none-any.whl → 0.2.69b3__py3-none-any.whl

fleet/resources/sqlite.py

@@ -675,17 +675,97 @@ class SyncQueryBuilder:
 
 
 class SQLiteResource(Resource):
-    def __init__(self, resource: ResourceModel, client: "SyncWrapper"):
+    def __init__(
+        self,
+        resource: ResourceModel,
+        client: Optional["SyncWrapper"] = None,
+        db_path: Optional[str] = None,
+    ):
         super().__init__(resource)
         self.client = client
+        self.db_path = db_path
+        self._mode = "direct" if db_path else "http"
+
+    @property
+    def mode(self) -> str:
+        """Return the mode of this resource: 'direct' (local file) or 'http' (remote API)."""
+        return self._mode
 
     def describe(self) -> DescribeResponse:
         """Describe the SQLite database schema."""
+        if self._mode == "direct":
+            return self._describe_direct()
+        else:
+            return self._describe_http()
+
+    def _describe_http(self) -> DescribeResponse:
+        """Describe database schema via HTTP API."""
         response = self.client.request(
             "GET", f"/resources/sqlite/{self.resource.name}/describe"
         )
         return DescribeResponse(**response.json())
 
+    def _describe_direct(self) -> DescribeResponse:
+        """Describe database schema from local file or in-memory database."""
+        try:
+            # Check if we need URI mode (for shared memory databases)
+            use_uri = 'mode=memory' in self.db_path
+            conn = sqlite3.connect(self.db_path, uri=use_uri)
+            cursor = conn.cursor()
+
+            # Get all tables
+            cursor.execute(
+                "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'"
+            )
+            table_names = [row[0] for row in cursor.fetchall()]
+
+            tables = []
+            for table_name in table_names:
+                # Get table info
+                cursor.execute(f"PRAGMA table_info({table_name})")
+                columns = cursor.fetchall()
+
+                # Get CREATE TABLE SQL
+                cursor.execute(
+                    f"SELECT sql FROM sqlite_master WHERE type='table' AND name=?",
+                    (table_name,)
+                )
+                sql_row = cursor.fetchone()
+                create_sql = sql_row[0] if sql_row else ""
+
+                table_schema = {
+                    "name": table_name,
+                    "sql": create_sql,
+                    "columns": [
+                        {
+                            "name": col[1],
+                            "type": col[2],
+                            "notnull": bool(col[3]),
+                            "default_value": col[4],
+                            "primary_key": col[5] > 0,
+                        }
+                        for col in columns
+                    ],
+                }
+                tables.append(table_schema)
+
+            conn.close()
+
+            return DescribeResponse(
+                success=True,
+                resource_name=self.resource.name,
+                tables=tables,
+                message="Schema retrieved from local file",
+            )
+        except Exception as e:
+            return DescribeResponse(
+                success=False,
+                resource_name=self.resource.name,
+                tables=None,
+                error=str(e),
+                message=f"Failed to describe database: {str(e)}",
+            )
+
     def query(self, query: str, args: Optional[List[Any]] = None) -> QueryResponse:
         return self._query(query, args, read_only=True)
 
@@ -695,6 +775,15 @@ class SQLiteResource(Resource):
     def _query(
         self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
     ) -> QueryResponse:
+        if self._mode == "direct":
+            return self._query_direct(query, args, read_only)
+        else:
+            return self._query_http(query, args, read_only)
+
+    def _query_http(
+        self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
+    ) -> QueryResponse:
+        """Execute query via HTTP API."""
         request = QueryRequest(query=query, args=args, read_only=read_only)
         response = self.client.request(
             "POST",
@@ -703,6 +792,59 @@ class SQLiteResource(Resource):
         )
         return QueryResponse(**response.json())
 
+    def _query_direct(
+        self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
+    ) -> QueryResponse:
+        """Execute query directly on local SQLite file or in-memory database."""
+        try:
+            # Check if we need URI mode (for shared memory databases)
+            use_uri = 'mode=memory' in self.db_path
+            conn = sqlite3.connect(self.db_path, uri=use_uri)
+            cursor = conn.cursor()
+
+            # Execute the query
+            if args:
+                cursor.execute(query, args)
+            else:
+                cursor.execute(query)
+
+            # For write operations, commit the transaction
+            if not read_only:
+                conn.commit()
+
+            # Get column names if available
+            columns = [desc[0] for desc in cursor.description] if cursor.description else []
+
+            # Fetch results for SELECT queries
+            rows = []
+            rows_affected = 0
+            last_insert_id = None
+
+            if cursor.description:  # SELECT query
+                rows = cursor.fetchall()
+            else:  # INSERT/UPDATE/DELETE
+                rows_affected = cursor.rowcount
+                last_insert_id = cursor.lastrowid if cursor.lastrowid else None
+
+            conn.close()
+
+            return QueryResponse(
+                success=True,
+                columns=columns if columns else None,
+                rows=rows if rows else None,
+                rows_affected=rows_affected if rows_affected > 0 else None,
+                last_insert_id=last_insert_id,
+                message="Query executed successfully",
+            )
+        except Exception as e:
+            return QueryResponse(
+                success=False,
+                columns=None,
+                rows=None,
+                error=str(e),
+                message=f"Query failed: {str(e)}",
+            )
+
     def table(self, table_name: str) -> SyncQueryBuilder:
         """Create a query builder for the specified table."""
         return SyncQueryBuilder(self, table_name)

fleet/tasks.py

@@ -286,8 +286,11 @@ def verifier_from_string(
         # Remove lines like: @verifier(key="...")
         cleaned_code = re.sub(r"@verifier\([^)]*\)\s*\n", "", verifier_func)
         # Also remove the verifier import if present
-        cleaned_code = re.sub(r"from fleet import.*verifier.*\n", "", cleaned_code)
-        cleaned_code = re.sub(r"import.*verifier.*\n", "", cleaned_code)
+        # Use MULTILINE flag to match beginning of lines with ^
+        cleaned_code = re.sub(r"^from fleet\.verifiers.*import.*verifier.*$\n?", "", cleaned_code, flags=re.MULTILINE)
+        cleaned_code = re.sub(r"^from fleet import verifier.*$\n?", "", cleaned_code, flags=re.MULTILINE)
+        cleaned_code = re.sub(r"^import fleet\.verifiers.*$\n?", "", cleaned_code, flags=re.MULTILINE)
+        cleaned_code = re.sub(r"^import fleet$\n?", "", cleaned_code, flags=re.MULTILINE)
 
         # Create a globals namespace with all required imports
         exec_globals = globals().copy()

fleet/verifiers/bundler.py

@@ -37,7 +37,7 @@ class FunctionBundler:
     ) -> bytes:
         """Create a function bundle with statically extracted code."""
 
-        # logger.info(f"Creating function bundle for {func.__name__}")
+        logger.info(f"Creating function bundle for {func.__name__}")
 
         # 1. Parse the main function and find dependencies
         mod_file = Path(func.__code__.co_filename)
@@ -115,7 +115,7 @@ class FunctionBundler:
 
         # Find function calls within the verifier function
         called_functions = self._extract_function_calls(main_func_ast)
-        # logger.debug(f"Functions called in verifier: {called_functions}")
+        logger.debug(f"Functions called in verifier: {called_functions}")
 
         # Find all functions defined in the module
         module_functions = {}
@@ -128,7 +128,7 @@ class FunctionBundler:
         for func_name in called_functions:
             if func_name in module_functions and func_name != func.__name__:
                 same_module_deps.append(func_name)
-                # logger.debug(f"Found same-module dependency: {func_name}")
+                logger.debug(f"Found same-module dependency: {func_name}")
 
         # Separate local and external imports
         local_imports = {}
@@ -292,7 +292,7 @@ class FunctionBundler:
                     code = ast.unparse(node)
                     extracted_code.append(code)
                 except Exception as e:
-                    # logger.warning(f"Could not unparse AST node: {e}")
+                    logger.warning(f"Could not unparse AST node: {e}")
                     # Fallback to original source extraction
                     lines = content.split("\n")
                     start_line = node.lineno - 1
@@ -305,11 +305,11 @@ class FunctionBundler:
                     extracted_code.append(code)
 
             result = "\n\n".join(extracted_code)
-            # logger.debug(f"Extracted {len(extracted_code)} items from {file_path}")
+            logger.debug(f"Extracted {len(extracted_code)} items from {file_path}")
             return result
 
         except Exception as e:
-            # logger.warning(f"Failed to extract functions from {file_path}: {e}")
+            logger.warning(f"Failed to extract functions from {file_path}: {e}")
             # Fallback to including the entire file
             with open(file_path, "r", encoding="utf-8") as f:
                 return f.read()
@@ -464,14 +464,14 @@ class FunctionBundler:
                 version = dist.version  # Get the installed version
                 package_with_version = f"{package_name}=={version}"
                 packages.add(package_with_version)
-                # logger.debug(f"Mapped {mod} -> {package_with_version}")
+                logger.debug(f"Mapped {mod} -> {package_with_version}")
             except imd.PackageNotFoundError:
                 # Skip stdlib or local modules
-                # logger.debug(f"Skipping {mod} (stdlib or local)")
+                logger.debug(f"Skipping {mod} (stdlib or local)")
                 continue
 
         package_list = list(packages)
-        # logger.debug(f"Final package list: {package_list}")
+        logger.debug(f"Final package list: {package_list}")
         return package_list
 
     def _merge_requirements(
@@ -511,10 +511,10 @@ class FunctionBundler:
             if pkg_name not in seen_packages:
                 final_requirements.append(req)
                 seen_packages.add(pkg_name)
-            # else:
-            #     logger.debug(
-            #         f"Skipping auto-detected {req}, using explicit version instead"
-            #     )
+            else:
+                logger.debug(
+                    f"Skipping auto-detected {req}, using explicit version instead"
+                )
 
         # Always ensure fleet-python is included
         if "fleet-python" not in seen_packages:
@@ -565,9 +565,9 @@ class FunctionBundler:
                         )
                         if dep_src:
                             same_module_code += f"\n{dep_src}\n"
-                            # logger.debug(
-                            #     f"Extracted same-module dependency: {dep_name}"
-                            # )
+                            logger.debug(
+                                f"Extracted same-module dependency: {dep_name}"
+                            )
 
                 # Create verifier.py with the main function
                 verifier_file = build_dir / "verifier.py"
@@ -586,7 +586,7 @@ class FunctionBundler:
 {code}
 """
                     dest_path.write_text(extracted_content)
-                    # logger.debug(f"Created extracted file: {relative_path}")
+                    logger.debug(f"Created extracted file: {relative_path}")
 
                     # Ensure __init__.py files exist
                     self._ensure_init_files(Path(relative_path), build_dir)
@@ -595,7 +595,7 @@ class FunctionBundler:
                 return self._create_zip_bundle(build_dir)
 
             except Exception as e:
-                # logger.error(f"Failed to build function bundle: {e}")
+                logger.error(f"Failed to build function bundle: {e}")
                 raise RuntimeError(f"Function bundle creation failed: {e}")
 
     def _ensure_init_files(self, rel_path: Path, build_dir: Path):
@@ -607,7 +607,7 @@ class FunctionBundler:
             if not init_file.exists():
                 init_file.parent.mkdir(parents=True, exist_ok=True)
                 init_file.write_text("# Auto-generated __init__.py")
-                # logger.debug(f"Created __init__.py: {current}")
+                logger.debug(f"Created __init__.py: {current}")
             current = current.parent
 
     def _create_zip_bundle(self, build_dir: Path) -> bytes:
@@ -621,7 +621,7 @@ class FunctionBundler:
                     zf.write(file_path, arcname)
 
         bundle_size = len(zip_buffer.getvalue())
-        # logger.debug(f"Created function bundle ({bundle_size:,} bytes)")
+        logger.debug(f"Created function bundle ({bundle_size:,} bytes)")
         return zip_buffer.getvalue()
 
     def _extract_function_source(
@@ -662,8 +662,7 @@ class FunctionBundler:
                     return "\n".join(func_lines)
 
         except Exception as e:
-            # logger.warning(f"Failed to extract function {function_name}: {e}")
-            pass
+            logger.warning(f"Failed to extract function {function_name}: {e}")
 
         return None
 

fleet/verifiers/decorator.py

@@ -49,7 +49,7 @@ class SyncVerifierFunction:
                     )
 
         except Exception as e:
-            # logger.error(f"Error in verifier {self.key}: {e}")
+            logger.error(f"Error in verifier {self.key}: {e}")
             # Return error score 0
             return 0.0
 

fleet/verifiers/verifier.py

@@ -90,9 +90,9 @@ class SyncVerifierFunction:
 
                 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:
@@ -100,9 +100,9 @@ class SyncVerifierFunction:
                         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}")
@@ -115,21 +115,20 @@ class SyncVerifierFunction:
 
         # 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]}...")
+            logger.debug(f"Using server-side bundle {bundle_sha[:8]}...")
             return bundle_sha, False  # No upload needed, server has it
 
         # 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")
+                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}")
-            pass
+            logger.warning(f"Failed to check bundle existence: {e}")
 
         # Bundle not found on server - upload needed
-        # logger.info(f"Bundle {bundle_sha[:8]}... needs to be uploaded")
+        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:
@@ -159,7 +158,7 @@ class SyncVerifierFunction:
                     )
 
         except Exception as e:
-            # logger.error(f"Error in verifier {self.key}: {e}")
+            logger.error(f"Error in verifier {self.key}: {e}")
             # Return error score 0
             return 0.0
 
@@ -191,7 +190,7 @@ class SyncVerifierFunction:
                 try:
                     return float(result)
                 except (ValueError, TypeError):
-                    # logger.warning(f"Could not convert result to float: {result}")
+                    logger.warning(f"Could not convert result to float: {result}")
                     return 0.0
 
     def _raise_remote_error(self, error_info: Dict[str, Any]):
@@ -250,7 +249,7 @@ Remote traceback:
 
             if needs_upload:
                 # Need to upload bundle to S3
-                # logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
+                logger.info(f"Uploading bundle {bundle_sha[:8]}... for {self.key}")
                 bundle_data, _ = self._get_or_create_bundle()
 
                 response = env.execute_verifier_remote(
@@ -264,12 +263,12 @@ Remote traceback:
                     needs_upload=True,
                 )
 
-                # logger.debug(f"Bundle {bundle_sha[:8]}... uploaded successfully")
+                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}")
+                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,
@@ -285,9 +284,9 @@ Remote traceback:
         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..."
-                # )
+                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,
@@ -301,7 +300,7 @@ Remote traceback:
                 )
                 return response
             else:
-                # logger.error(f"Error in remote execution of {self.key}: {e}")
+                logger.error(f"Error in remote execution of {self.key}: {e}")
                 raise
 
 

{fleet_python-0.2.69.dist-info → fleet_python-0.2.69b3.dist-info}/METADATA

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

{fleet_python-0.2.69.dist-info → fleet_python-0.2.69b3.dist-info}/RECORD

@@ -22,59 +22,63 @@ examples/query_builder_example.py,sha256=-cOMfWGNifYfYEt_Ds73XpwATZvFDL6F4KTkVxd
 examples/quickstart.py,sha256=1VT39IRRhemsJgxi0O0gprdpcw7HB4pYO97GAYagIcg,3788
 examples/test_cdp_logging.py,sha256=AkCwQCgOTQEI8w3v0knWK_4eXMph7L9x07wj9yIYM10,2836
 fleet/__init__.py,sha256=yC4HIcbtPAPOgI0lLri3l8nbXkNee9JOihKAc7SXYkY,4201
-fleet/base.py,sha256=B1xY5NjyE6nj98ZiOv6RQTflU00y7XzDYhK2RlT8Q2w,9205
-fleet/client.py,sha256=3mxNqif0Ijog-PQRJrLyg4VEyY-c68DHr-xq8sQMqdg,33926
+fleet/base.py,sha256=bc-340sTpq_DJs7yQ9d2pDWnmJFmA1SwDB9Lagvqtb4,9182
+fleet/client.py,sha256=lNVbAzq23p6-x66YduSdm4ZZC8yJreM82QVIKvDknuQ,40046
 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=GUL61DOD4XDT588T1a-EV7R1kh1w4q_JRLnX1rEI5ek,13911
-fleet/tasks.py,sha256=iwwvN2o1IWT-9zxmAMBHfT12rfX2Hm0DkfUlrPTs298,17956
+fleet/tasks.py,sha256=TWKenYlIJ8eo8TjMkTwfNL7ZRFgopnRXTCclPBMufgE,18281
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
 fleet/_async/__init__.py,sha256=5oOTmh16UsPWL2gDKKWkj2j5WGNeUhMzbQFWjX21jsc,8310
-fleet/_async/base.py,sha256=YWxKjyT-jk1Jh5FmLfKRUig0n1Ubyr4Be-DMfl75hYM,9225
-fleet/_async/client.py,sha256=8zLGgi-Bfl0M7ZUUC4Q3FpXbGe0XK389TE1EB7b9QSs,34440
+fleet/_async/base.py,sha256=oisVTQsx0M_yTmyQJc3oij63uKZ97MHz-xYFsWXxQE8,9202
+fleet/_async/client.py,sha256=xjDlAFWYez1SHKcUnYw-iLQsQ3gEeKiWw3qDX9gnNHs,40029
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
 fleet/_async/models.py,sha256=-3xv2QyoHsvYcWmdKLf9Z93md8XB17DBeJCxdRCB3bo,13571
-fleet/_async/tasks.py,sha256=8d65DBMhmHNaLer1FhttUWK4WLS1SU5Hx9_nALMwM4Y,18002
+fleet/_async/tasks.py,sha256=C3t15WXfAn_DY5UXtf4S27OoAs4U61GO1LirWFHr7AM,18327
 fleet/_async/env/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fleet/_async/env/client.py,sha256=Qv0QiW--ZMAMnz_IPYbYtokGP08x4PvSmkwde8rPCNk,2093
 fleet/_async/instance/__init__.py,sha256=PtmJq8J8bh0SOQ2V55QURz5GJfobozwtQoqhaOk3_tI,515
 fleet/_async/instance/base.py,sha256=3qUBuUR8OVS36LzdP6KyZzngtwPKYO09HoY6Ekxp-KA,1625
-fleet/_async/instance/client.py,sha256=kcrmLZciQxvPSfTtbEq5LIbhscwDHg6WIiNcPyM4L9w,6085
+fleet/_async/instance/client.py,sha256=Nrnoez4J3UnbSJoOfDw8vwb00p_A5RNOy9ROwUE4B_4,6838
 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=up_umepfyX9PDFsnmEMJLjsj7bLa6a3wizZOgMGkK1Q,27409
+fleet/_async/resources/sqlite.py,sha256=zRTbqW0qLt8EO9UTIxtcbrmwPV3cGK3rCaX1oSFsd_E,33036
 fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
-fleet/_async/verifiers/bundler.py,sha256=9aWWXFsovBPcndE06IATn5jaeli5fRORAYeenF9heN0,26264
-fleet/_async/verifiers/verifier.py,sha256=Zvok2Mog09l885StW429Rg_8_4bd-gaYUGIgpILeb_I,14207
+fleet/_async/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
+fleet/_async/verifiers/verifier.py,sha256=IiHX028s6ux0kb2FR0Z5zJangl_IDh6cemXsUN2ktUU,14152
 fleet/env/__init__.py,sha256=sSjD6vk8LzC_pxoXuRc8-ACqeX4PLm1FBWnWxpOhUS8,812
 fleet/env/client.py,sha256=l2vI_BBrSXmyk2un3F1-QDcL-iv2OdBxTdYOdOioF0Q,1881
 fleet/instance/__init__.py,sha256=CyWUkbGAK-DBPw4DC4AnCW-MqqheGhZMA5QSRVu-ws4,479
 fleet/instance/base.py,sha256=OYqzBwZFfTX9wlBGSG5gljqj98NbiJeKIfFJ3uj5I4s,1587
-fleet/instance/client.py,sha256=XM_Qmd7pUzC3-dCMTh6orTEsGeWJXbKueBlvcWcSUuI,5897
+fleet/instance/client.py,sha256=MUUkMV5i0-DPK8awBpRYfc3wy8kVq7IGQ_Re7td1e60,6639
 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=bR6d1zYQ4cMAlmZIJ7jqmY9-N-GokXaDhUyGKTWHsfY,26811
+fleet/resources/sqlite.py,sha256=BZE31mMOuRIT0vB4ppy6bO-QczmlYytHQkgo9nCZIew,31837
 fleet/verifiers/__init__.py,sha256=GntS8qc3xv8mm-cku1t3xjvOll5jcc5FuiVqQgR4Y6Q,458
-fleet/verifiers/bundler.py,sha256=9aWWXFsovBPcndE06IATn5jaeli5fRORAYeenF9heN0,26264
+fleet/verifiers/bundler.py,sha256=Sq0KkqEhM5Ng2x8R6Z4puXvQ8FMlEO7D3-ldBLktPi4,26205
 fleet/verifiers/code.py,sha256=A1i_UabZspbyj1awzKVQ_HRxgMO3fU7NbkxYyTrp7So,48
 fleet/verifiers/db.py,sha256=LAh1HambBInH_D9q9E2Z41YNkCOI9JJfpWPFqztjpfQ,27922
-fleet/verifiers/decorator.py,sha256=RuTjjDijbicNfMSjA7HcTpKueEki5dzNOdTuHS7UoZs,3262
+fleet/verifiers/decorator.py,sha256=nAP3O8szXu7md_kpwpz91hGSUNEVLYjwZQZTkQlV1DM,3260
 fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
-fleet/verifiers/verifier.py,sha256=npnTBB-A1Cl66gNOGPR6UaybvcDy6C6_hWchyIJeDyc,14252
-fleet_python-0.2.69.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet/verifiers/verifier.py,sha256=_lcxXVm8e0xRrK2gNJy9up7pW1zOkPRY5n5lQ85S8jg,14197
+fleet_python-0.2.69b3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 scripts/fix_sync_imports.py,sha256=X9fWLTpiPGkSHsjyQUDepOJkxOqw1DPj7nd8wFlFqLQ,8368
 scripts/unasync.py,sha256=vWVQxRWX8SRZO5cmzEhpvnG_REhCWXpidIGIpWmEcvI,696
 tests/__init__.py,sha256=Re1SdyxH8NfyL1kjhi7SQkGP1mYeWB-D6UALqdIMd8I,35
+tests/test_app_method.py,sha256=kg2IiL75cH-HmsTMS3_wDL39dAesgfv_AT6jVthd5J4,3159
+tests/test_instance_dispatch.py,sha256=CvU4C3LBIqsYZdEsEFfontGjyxAZfVYyXnGwxyIvXOc,23065
+tests/test_sqlite_resource_dual_mode.py,sha256=Mh8jBd-xsIGDYFsOACKKK_5DXMUYlFFS7W-jaY6AjG4,8734
+tests/test_sqlite_shared_memory_behavior.py,sha256=fKx_1BmLS3b8x-9pMgjMycpnaHWY8P-2ZuXEspx6Sbw,4082
 tests/test_verifier_from_string.py,sha256=Lxi3TpFHFb-hG4-UhLKZJkqo84ax9YJY8G6beO-1erM,13581
-fleet_python-0.2.69.dist-info/METADATA,sha256=W0uTnvlkRrRBfTzSYTi0Tb8qxCFFOoD0Hw1GUwFgIAA,3304
-fleet_python-0.2.69.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.69.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
-fleet_python-0.2.69.dist-info/RECORD,,
+fleet_python-0.2.69b3.dist-info/METADATA,sha256=M4OF4x_-pFl_h9xAh7ERomXkssTvlrH5HxDPq-C75Ng,3306
+fleet_python-0.2.69b3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.69b3.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
+fleet_python-0.2.69b3.dist-info/RECORD,,

tests/test_app_method.py

@@ -0,0 +1,85 @@
+"""Unit tests for SyncEnv.app() method URL handling."""
+
+import pytest
+from unittest.mock import Mock, patch
+from fleet.client import Fleet
+
+
+class TestAppMethod:
+    """Test SyncEnv.app() method with different URL formats."""
+
+    @pytest.fixture
+    def fleet_client(self):
+        """Create a Fleet client with mocked HTTP client."""
+        with patch("fleet.client.default_httpx_client") as mock_client:
+            mock_client.return_value = Mock()
+            client = Fleet(api_key="test_key")
+            client.client.request = Mock()
+            return client
+
+    def test_app_with_existing_app_path(self, fleet_client):
+        """Test app() with URL that already has an app path like /sentry."""
+        # Create instance with a URL that has an existing app path
+        env = fleet_client.instance("https://example.com/sentry/api/v1/env")
+
+        # Access jira app
+        jira_client = env.app("jira")
+
+        # Check the constructed URL
+        assert jira_client.base_url == "https://example.com/jira/api/v1/env", \
+            f"Expected https://example.com/jira/api/v1/env, got {jira_client.base_url}"
+
+    def test_app_without_app_path(self, fleet_client):
+        """Test app() with URL that has no app path (just /api/v1/env)."""
+        # Create instance with a URL without an app path
+        env = fleet_client.instance("https://example.com/api/v1/env")
+
+        # Access jira app
+        jira_client = env.app("jira")
+
+        # Check the constructed URL
+        assert jira_client.base_url == "https://example.com/jira/api/v1/env", \
+            f"Expected https://example.com/jira/api/v1/env, got {jira_client.base_url}"
+
+    def test_app_with_different_app_names(self, fleet_client):
+        """Test app() with multiple different app names."""
+        env = fleet_client.instance("https://example.com/api/v1/env")
+
+        jira = env.app("jira")
+        sentry = env.app("sentry")
+        github = env.app("github")
+
+        assert jira.base_url == "https://example.com/jira/api/v1/env"
+        assert sentry.base_url == "https://example.com/sentry/api/v1/env"
+        assert github.base_url == "https://example.com/github/api/v1/env"
+
+    def test_app_caching(self, fleet_client):
+        """Test that app() caches InstanceClient instances."""
+        env = fleet_client.instance("https://example.com/api/v1/env")
+
+        # Call app("jira") twice
+        jira1 = env.app("jira")
+        jira2 = env.app("jira")
+
+        # Should return the same cached instance
+        assert jira1 is jira2
+
+    def test_app_with_localhost(self, fleet_client):
+        """Test app() with localhost URLs."""
+        env = fleet_client.instance("http://localhost:8080/api/v1/env")
+
+        jira = env.app("jira")
+
+        assert jira.base_url == "http://localhost:8080/jira/api/v1/env"
+
+    def test_app_with_port(self, fleet_client):
+        """Test app() with URLs that include port numbers."""
+        env = fleet_client.instance("https://example.com:9000/api/v1/env")
+
+        jira = env.app("jira")
+
+        assert jira.base_url == "https://example.com:9000/jira/api/v1/env"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])