fleet-python 0.2.98__py3-none-any.whl → 0.2.99__py3-none-any.whl

fleet/__init__.py

@@ -73,7 +73,7 @@ from . import env
 from . import global_client as _global_client
 from ._async import global_client as _async_global_client
 
-__version__ = "0.2.98"
+__version__ = "0.2.99"
 
 __all__ = [
     # Core classes

fleet/_async/__init__.py

@@ -44,7 +44,7 @@ from ..types import VerifierFunction
 from .. import env
 from . import global_client as _async_global_client
 
-__version__ = "0.2.98"
+__version__ = "0.2.99"
 
 __all__ = [
     # Core classes

fleet/_async/base.py

@@ -26,7 +26,7 @@ from .exceptions import (
 try:
     from .. import __version__
 except ImportError:
-    __version__ = "0.2.98"
+    __version__ = "0.2.99"
 
 logger = logging.getLogger(__name__)
 

fleet/_async/resources/sqlite.py

@@ -7,6 +7,7 @@ import tempfile
 import sqlite3
 import os
 import asyncio
+import re
 
 from typing import TYPE_CHECKING
 
@@ -23,6 +24,17 @@ from fleet.verifiers.db import (
 )
 
 
+def _quote_identifier(identifier: str) -> str:
+    """Quote an identifier (table or column name) for SQLite.
+
+    SQLite uses double quotes for identifiers and escapes internal quotes by doubling them.
+    This handles reserved keywords like 'order', 'table', etc.
+    """
+    # Escape any double quotes in the identifier by doubling them
+    escaped = identifier.replace('"', '""')
+    return f'"{escaped}"'
+
+
 class AsyncDatabaseSnapshot:
     """Lazy database snapshot that fetches data on-demand through API."""
 
@@ -57,12 +69,12 @@ class AsyncDatabaseSnapshot:
             return
 
         # Get table schema
-        schema_response = await self.resource.query(f"PRAGMA table_info({table})")
+        schema_response = await self.resource.query(f"PRAGMA table_info({_quote_identifier(table)})")
         if schema_response.rows:
             self._schemas[table] = [row[1] for row in schema_response.rows]  # Column names
 
         # Get all data for this table
-        data_response = await self.resource.query(f"SELECT * FROM {table}")
+        data_response = await self.resource.query(f"SELECT * FROM {_quote_identifier(table)}")
         if data_response.rows and data_response.columns:
             self._data[table] = [
                 dict(zip(data_response.columns, row)) for row in data_response.rows
@@ -123,23 +135,23 @@ class AsyncSnapshotQueryBuilder:
         where_parts = []
         for col, op, val in self._conditions:
             if op == "=" and val is None:
-                where_parts.append(f"{col} IS NULL")
+                where_parts.append(f"{_quote_identifier(col)} IS NULL")
             elif op == "IS":
-                where_parts.append(f"{col} IS NULL")
+                where_parts.append(f"{_quote_identifier(col)} IS NULL")
             elif op == "IS NOT":
-                where_parts.append(f"{col} IS NOT NULL")
+                where_parts.append(f"{_quote_identifier(col)} IS NOT NULL")
             elif op == "=":
                 if isinstance(val, str):
                     escaped_val = val.replace("'", "''")
-                    where_parts.append(f"{col} = '{escaped_val}'")
+                    where_parts.append(f"{_quote_identifier(col)} = '{escaped_val}'")
                 else:
-                    where_parts.append(f"{col} = '{val}'")
+                    where_parts.append(f"{_quote_identifier(col)} = '{val}'")
 
         where_clause = " AND ".join(where_parts)
 
         # Build full query
         cols = ", ".join(self._select_cols)
-        query = f"SELECT {cols} FROM {self._table} WHERE {where_clause}"
+        query = f"SELECT {cols} FROM {_quote_identifier(self._table)} WHERE {where_clause}"
 
         if self._order_by:
             query += f" ORDER BY {self._order_by}"
@@ -271,7 +283,7 @@ class AsyncSnapshotDiff:
     async def _get_primary_key_columns(self, table: str) -> List[str]:
         """Get primary key columns for a table."""
         # Try to get from schema
-        schema_response = await self.after.resource.query(f"PRAGMA table_info({table})")
+        schema_response = await self.after.resource.query(f"PRAGMA table_info({_quote_identifier(table)})")
         if not schema_response.rows:
             return ["id"]  # Default fallback
 
@@ -414,18 +426,18 @@ class AsyncSnapshotDiff:
                 return f"'{val}'"
 
         if len(pk_columns) == 1:
-            return f"{pk_columns[0]} = {escape_value(pk_value)}"
+            return f"{_quote_identifier(pk_columns[0])} = {escape_value(pk_value)}"
         else:
             # Composite key
             if isinstance(pk_value, tuple):
                 conditions = [
-                    f"{col} = {escape_value(val)}"
+                    f"{_quote_identifier(col)} = {escape_value(val)}"
                     for col, val in zip(pk_columns, pk_value)
                 ]
                 return " AND ".join(conditions)
             else:
                 # Shouldn't happen if data is consistent
-                return f"{pk_columns[0]} = {escape_value(pk_value)}"
+                return f"{_quote_identifier(pk_columns[0])} = {escape_value(pk_value)}"
 
     async def _expect_no_changes(self):
         """Efficiently verify that no changes occurred between snapshots using row counts."""
@@ -472,7 +484,7 @@ class AsyncSnapshotDiff:
 
                     if table in before_tables:
                         before_count_response = await self.before.resource.query(
-                            f"SELECT COUNT(*) FROM {table}"
+                            f"SELECT COUNT(*) FROM {_quote_identifier(table)}"
                         )
                         before_count = (
                             before_count_response.rows[0][0]
@@ -482,7 +494,7 @@ class AsyncSnapshotDiff:
 
                     if table in after_tables:
                         after_count_response = await self.after.resource.query(
-                            f"SELECT COUNT(*) FROM {table}"
+                            f"SELECT COUNT(*) FROM {_quote_identifier(table)}"
                         )
                         after_count = (
                             after_count_response.rows[0][0]
@@ -549,10 +561,10 @@ class AsyncSnapshotDiff:
         order_by = ", ".join(pk_columns) if pk_columns else "rowid"
 
         before_response = await self.before.resource.query(
-            f"SELECT * FROM {table} ORDER BY {order_by}"
+            f"SELECT * FROM {_quote_identifier(table)} ORDER BY {order_by}"
         )
         after_response = await self.after.resource.query(
-            f"SELECT * FROM {table} ORDER BY {order_by}"
+            f"SELECT * FROM {_quote_identifier(table)} ORDER BY {order_by}"
         )
 
         # Quick check: if column counts differ, there's a schema change
@@ -634,7 +646,7 @@ class AsyncSnapshotDiff:
                 where_sql = self._build_pk_where_clause(pk_columns, pk)
 
                 # Query before snapshot
-                before_query = f"SELECT * FROM {table} WHERE {where_sql}"
+                before_query = f"SELECT * FROM {_quote_identifier(table)} WHERE {where_sql}"
                 before_response = await self.before.resource.query(before_query)
                 before_row = (
                     dict(zip(before_response.columns, before_response.rows[0]))
@@ -727,7 +739,7 @@ class AsyncSnapshotDiff:
             try:
                 # For tables with no allowed changes, just check row counts
                 before_count_response = await self.before.resource.query(
-                    f"SELECT COUNT(*) FROM {table}"
+                    f"SELECT COUNT(*) FROM {_quote_identifier(table)}"
                 )
                 before_count = (
                     before_count_response.rows[0][0]
@@ -736,7 +748,7 @@ class AsyncSnapshotDiff:
                 )
 
                 after_count_response = await self.after.resource.query(
-                    f"SELECT COUNT(*) FROM {table}"
+                    f"SELECT COUNT(*) FROM {_quote_identifier(table)}"
                 )
                 after_count = (
                     after_count_response.rows[0][0] if after_count_response.rows else 0
@@ -1098,7 +1110,7 @@ class AsyncSnapshotDiff:
                 where_sql = self._build_pk_where_clause(pk_columns, pk)
 
                 # Query before snapshot
-                before_query = f"SELECT * FROM {table} WHERE {where_sql}"
+                before_query = f"SELECT * FROM {_quote_identifier(table)} WHERE {where_sql}"
                 before_response = await self.before.resource.query(before_query)
                 before_row = (
                     dict(zip(before_response.columns, before_response.rows[0]))
@@ -1176,7 +1188,7 @@ class AsyncSnapshotDiff:
             try:
                 # For tables with no allowed changes, just check row counts
                 before_count_response = await self.before.resource.query(
-                    f"SELECT COUNT(*) FROM {table}"
+                    f"SELECT COUNT(*) FROM {_quote_identifier(table)}"
                 )
                 before_count = (
                     before_count_response.rows[0][0]
@@ -1185,7 +1197,7 @@ class AsyncSnapshotDiff:
                 )
 
                 after_count_response = await self.after.resource.query(
-                    f"SELECT COUNT(*) FROM {table}"
+                    f"SELECT COUNT(*) FROM {_quote_identifier(table)}"
                 )
                 after_count = (
                     after_count_response.rows[0][0] if after_count_response.rows else 0
@@ -1950,13 +1962,13 @@ class AsyncQueryBuilder:
     # Compile to SQL
     def _compile(self) -> Tuple[str, List[Any]]:
         cols = ", ".join(self._select_cols)
-        sql = [f"SELECT {cols} FROM {self._table}"]
+        sql = [f"SELECT {cols} FROM {_quote_identifier(self._table)}"]
         params: List[Any] = []
 
         # Joins
         for tbl, onmap in self._joins:
-            join_clauses = [f"{self._table}.{l} = {tbl}.{r}" for l, r in onmap.items()]
-            sql.append(f"JOIN {tbl} ON {' AND '.join(join_clauses)}")
+            join_clauses = [f"{_quote_identifier(self._table)}.{_quote_identifier(l)} = {_quote_identifier(tbl)}.{_quote_identifier(r)}" for l, r in onmap.items()]
+            sql.append(f"JOIN {_quote_identifier(tbl)} ON {' AND '.join(join_clauses)}")
 
         # WHERE
         if self._conditions:
@@ -1964,12 +1976,12 @@ class AsyncQueryBuilder:
             for col, op, val in self._conditions:
                 if op in ("IN", "NOT IN") and isinstance(val, tuple):
                     ph = ", ".join(["?" for _ in val])
-                    placeholders.append(f"{col} {op} ({ph})")
+                    placeholders.append(f"{_quote_identifier(col)} {op} ({ph})")
                     params.extend(val)
                 elif op in ("IS", "IS NOT"):
-                    placeholders.append(f"{col} {op} NULL")
+                    placeholders.append(f"{_quote_identifier(col)} {op} NULL")
                 else:
-                    placeholders.append(f"{col} {op} ?")
+                    placeholders.append(f"{_quote_identifier(col)} {op} ?")
                     params.append(val)
             sql.append("WHERE " + " AND ".join(placeholders))
 
@@ -2122,7 +2134,7 @@ class AsyncSQLiteResource(Resource):
                 tables = []
                 for table_name in table_names:
                     # Get table info
-                    cursor.execute(f"PRAGMA table_info({table_name})")
+                    cursor.execute(f"PRAGMA table_info({_quote_identifier(table_name)})")
                     columns = cursor.fetchall()
 
                     # Get CREATE TABLE SQL
@@ -2182,8 +2194,114 @@ class AsyncSQLiteResource(Resource):
         if self._mode == "direct":
             return await self._query_direct(query, args, read_only)
         else:
+            # Check if this is a PRAGMA query - HTTP endpoints don't support PRAGMA
+            query_stripped = query.strip().upper()
+            if query_stripped.startswith("PRAGMA"):
+                return await self._handle_pragma_query_http(query, args)
             return await self._query_http(query, args, read_only)
 
+    async def _handle_pragma_query_http(
+        self, query: str, args: Optional[List[Any]] = None
+    ) -> QueryResponse:
+        """Handle PRAGMA queries in HTTP mode by using the describe endpoint."""
+        query_upper = query.strip().upper()
+
+        # Extract table name from PRAGMA table_info(table_name)
+        if "TABLE_INFO" in query_upper:
+            # Match: PRAGMA table_info("table") or PRAGMA table_info(table)
+            match = re.search(r'TABLE_INFO\s*\(\s*"([^"]+)"\s*\)', query, re.IGNORECASE)
+            if not match:
+                match = re.search(r"TABLE_INFO\s*\(\s*'([^']+)'\s*\)", query, re.IGNORECASE)
+            if not match:
+                match = re.search(r'TABLE_INFO\s*\(\s*([^\s\)]+)\s*\)', query, re.IGNORECASE)
+
+            if match:
+                table_name = match.group(1)
+
+                # Use the describe endpoint to get schema
+                describe_response = await self.describe()
+                if not describe_response.success or not describe_response.tables:
+                    return QueryResponse(
+                        success=False,
+                        columns=None,
+                        rows=None,
+                        error="Failed to get schema information",
+                        message="PRAGMA query failed: could not retrieve schema"
+                    )
+
+                # Find the table in the schema
+                table_schema = None
+                for table in describe_response.tables:
+                    # Handle both dict and TableSchema objects
+                    table_name_in_schema = table.name if hasattr(table, 'name') else table.get("name")
+                    if table_name_in_schema == table_name:
+                        table_schema = table
+                        break
+
+                if not table_schema:
+                    return QueryResponse(
+                        success=False,
+                        columns=None,
+                        rows=None,
+                        error=f"Table '{table_name}' not found",
+                        message=f"PRAGMA query failed: table '{table_name}' not found"
+                    )
+
+                # Get columns from table schema
+                columns = table_schema.columns if hasattr(table_schema, 'columns') else table_schema.get("columns")
+                if not columns:
+                    return QueryResponse(
+                        success=False,
+                        columns=None,
+                        rows=None,
+                        error=f"Table '{table_name}' has no columns",
+                        message=f"PRAGMA query failed: table '{table_name}' has no columns"
+                    )
+
+                # Convert schema to PRAGMA table_info format
+                # Format: (cid, name, type, notnull, dflt_value, pk)
+                rows = []
+                for idx, col in enumerate(columns):
+                    # Handle both dict and object column definitions
+                    if isinstance(col, dict):
+                        col_name = col["name"]
+                        col_type = col.get("type", "")
+                        col_notnull = col.get("notnull", False)
+                        col_default = col.get("default_value")
+                        col_pk = col.get("pk", 0)
+                    else:
+                        col_name = col.name if hasattr(col, 'name') else str(col)
+                        col_type = getattr(col, 'type', "")
+                        col_notnull = getattr(col, 'notnull', False)
+                        col_default = getattr(col, 'default_value', None)
+                        col_pk = getattr(col, 'pk', 0)
+
+                    row = (
+                        idx,  # cid
+                        col_name,  # name
+                        col_type,  # type
+                        1 if col_notnull else 0,  # notnull
+                        col_default,  # dflt_value
+                        col_pk  # pk
+                    )
+                    rows.append(row)
+
+                return QueryResponse(
+                    success=True,
+                    columns=["cid", "name", "type", "notnull", "dflt_value", "pk"],
+                    rows=rows,
+                    message="PRAGMA query executed successfully via describe endpoint"
+                )
+
+        # For other PRAGMA queries, return an error indicating they're not supported
+        return QueryResponse(
+            success=False,
+            columns=None,
+            rows=None,
+            error="PRAGMA query not supported in HTTP mode",
+            message=f"PRAGMA query '{query}' is not supported via HTTP API"
+        )
+
     async def _query_http(
         self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
     ) -> QueryResponse:

fleet/base.py

@@ -27,7 +27,7 @@ from .exceptions import (
 try:
     from . import __version__
 except ImportError:
-    __version__ = "0.2.98"
+    __version__ = "0.2.99"
 
 logger = logging.getLogger(__name__)
 

fleet/resources/sqlite.py

@@ -6,6 +6,7 @@ from datetime import datetime
 import tempfile
 import sqlite3
 import os
+import re
 
 from typing import TYPE_CHECKING
 
@@ -2234,8 +2235,114 @@ class SQLiteResource(Resource):
         if self._mode == "direct":
             return self._query_direct(query, args, read_only)
         else:
+            # Check if this is a PRAGMA query - HTTP endpoints don't support PRAGMA
+            query_stripped = query.strip().upper()
+            if query_stripped.startswith("PRAGMA"):
+                return self._handle_pragma_query_http(query, args)
             return self._query_http(query, args, read_only)
 
+    def _handle_pragma_query_http(
+        self, query: str, args: Optional[List[Any]] = None
+    ) -> QueryResponse:
+        """Handle PRAGMA queries in HTTP mode by using the describe endpoint."""
+        query_upper = query.strip().upper()
+
+        # Extract table name from PRAGMA table_info(table_name)
+        if "TABLE_INFO" in query_upper:
+            # Match: PRAGMA table_info("table") or PRAGMA table_info(table)
+            match = re.search(r'TABLE_INFO\s*\(\s*"([^"]+)"\s*\)', query, re.IGNORECASE)
+            if not match:
+                match = re.search(r"TABLE_INFO\s*\(\s*'([^']+)'\s*\)", query, re.IGNORECASE)
+            if not match:
+                match = re.search(r'TABLE_INFO\s*\(\s*([^\s\)]+)\s*\)', query, re.IGNORECASE)
+
+            if match:
+                table_name = match.group(1)
+
+                # Use the describe endpoint to get schema
+                describe_response = self.describe()
+                if not describe_response.success or not describe_response.tables:
+                    return QueryResponse(
+                        success=False,
+                        columns=None,
+                        rows=None,
+                        error="Failed to get schema information",
+                        message="PRAGMA query failed: could not retrieve schema"
+                    )
+
+                # Find the table in the schema
+                table_schema = None
+                for table in describe_response.tables:
+                    # Handle both dict and TableSchema objects
+                    table_name_in_schema = table.name if hasattr(table, 'name') else table.get("name")
+                    if table_name_in_schema == table_name:
+                        table_schema = table
+                        break
+
+                if not table_schema:
+                    return QueryResponse(
+                        success=False,
+                        columns=None,
+                        rows=None,
+                        error=f"Table '{table_name}' not found",
+                        message=f"PRAGMA query failed: table '{table_name}' not found"
+                    )
+
+                # Get columns from table schema
+                columns = table_schema.columns if hasattr(table_schema, 'columns') else table_schema.get("columns")
+                if not columns:
+                    return QueryResponse(
+                        success=False,
+                        columns=None,
+                        rows=None,
+                        error=f"Table '{table_name}' has no columns",
+                        message=f"PRAGMA query failed: table '{table_name}' has no columns"
+                    )
+
+                # Convert schema to PRAGMA table_info format
+                # Format: (cid, name, type, notnull, dflt_value, pk)
+                rows = []
+                for idx, col in enumerate(columns):
+                    # Handle both dict and object column definitions
+                    if isinstance(col, dict):
+                        col_name = col["name"]
+                        col_type = col.get("type", "")
+                        col_notnull = col.get("notnull", False)
+                        col_default = col.get("default_value")
+                        col_pk = col.get("pk", 0)
+                    else:
+                        col_name = col.name if hasattr(col, 'name') else str(col)
+                        col_type = getattr(col, 'type', "")
+                        col_notnull = getattr(col, 'notnull', False)
+                        col_default = getattr(col, 'default_value', None)
+                        col_pk = getattr(col, 'pk', 0)
+
+                    row = (
+                        idx,  # cid
+                        col_name,  # name
+                        col_type,  # type
+                        1 if col_notnull else 0,  # notnull
+                        col_default,  # dflt_value
+                        col_pk  # pk
+                    )
+                    rows.append(row)
+
+                return QueryResponse(
+                    success=True,
+                    columns=["cid", "name", "type", "notnull", "dflt_value", "pk"],
+                    rows=rows,
+                    message="PRAGMA query executed successfully via describe endpoint"
+                )
+
+        # For other PRAGMA queries, return an error indicating they're not supported
+        return QueryResponse(
+            success=False,
+            columns=None,
+            rows=None,
+            error="PRAGMA query not supported in HTTP mode",
+            message=f"PRAGMA query '{query}' is not supported via HTTP API"
+        )
+
     def _query_http(
         self, query: str, args: Optional[List[Any]] = None, read_only: bool = True
     ) -> QueryResponse:

{fleet_python-0.2.98.dist-info → fleet_python-0.2.99.dist-info}/METADATA

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

{fleet_python-0.2.98.dist-info → fleet_python-0.2.99.dist-info}/RECORD

@@ -23,8 +23,8 @@ examples/openai_simple_example.py,sha256=HmiufucrAZne7tHq9uoEsDWlEhjNC265bQAyIGB
 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=Y1h69yWX21Bg__ins6FQuV6CpxHH8fcfWEChZKb2qWo,7797
-fleet/base.py,sha256=gs_IeLalHKGw8QqrzckPRy7f5Y-KonZxVxSY0ZuUS8I,10065
+fleet/__init__.py,sha256=FMH_B_jo8tuiSiBOlo9EcEkkTTcaV2kOrB0sXCsEVLE,7797
+fleet/base.py,sha256=u8Hgr9HxNJbuNWtrFi9Tw3aQYC_WsPyZQcLYwrBCrVM,10065
 fleet/cli.py,sha256=arX1E-fjLXtcV3tVVkPHfEXxl7FDn4zRmf0ssXlXaMg,40104
 fleet/client.py,sha256=bJnp2g4yBW2EoL_95Q2I2aeR3p-nnb6o9PPNAtwmMGY,67818
 fleet/config.py,sha256=n_wh9Sahu3gGE7nHJ7kqNFUH1qDiBtF4bgZq9MvIBMU,319
@@ -33,8 +33,8 @@ fleet/global_client.py,sha256=frrDAFNM2ywN0JHLtlm9qbE1dQpnQJsavJpb7xSR_bU,1072
 fleet/models.py,sha256=7y7AchrAllsEAxel7C68DoeAyfRd90EVhwI7WbceQ3M,25173
 fleet/tasks.py,sha256=8pEzXmgC7RslqsMC_0s6shhr_t2WGIRpTRqo-MAQjdg,20778
 fleet/types.py,sha256=L4Y82xICf1tzyCLqhLYUgEoaIIS5h9T05TyFNHSWs3s,652
-fleet/_async/__init__.py,sha256=kPnFqzXofI4LRxnrvilAP-5ErqyUUW8EYtbAoNaEshE,9115
-fleet/_async/base.py,sha256=s0kRZZUUfnLEx4h2uXm0i9xvCdbfSa7OfYt4I_o_sck,9630
+fleet/_async/__init__.py,sha256=w9dNJUQNSbM8fmq2BuBtKRKnMpEuxN3pUmX5eXaioFo,9115
+fleet/_async/base.py,sha256=JnwtOLWTorAWI31m5H63VL4c5nbRA46LaMEJxhgoylc,9630
 fleet/_async/client.py,sha256=UdTOxvaLlo3VlMwgED8ZiUIrMxlaClM6cFBAWNUNqD4,64241
 fleet/_async/exceptions.py,sha256=fUmPwWhnT8SR97lYsRq0kLHQHKtSh2eJS0VQ2caSzEI,5055
 fleet/_async/global_client.py,sha256=4WskpLHbsDEgWW7hXMD09W-brkp4euy8w2ZJ88594rQ,1103
@@ -50,7 +50,7 @@ fleet/_async/resources/api.py,sha256=qlM1Ab3LNe1r7Hx27es4CRK565ZLVaJQeEtZKCe9cM0
 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=2aY3zIXuLUBFUnn_uEXlSZf9JQ1MSw5uH9aUfZ6ydeM,96498
+fleet/_async/resources/sqlite.py,sha256=MZY-10anBysxPDZ7SQ7gE7FSW4rF7t_o3ICptt78m0I,102432
 fleet/_async/verifiers/__init__.py,sha256=1WTlCNq4tIFbbXaQu5Bf2WppZq0A8suhtZbxMTSOwxI,465
 fleet/_async/verifiers/bundler.py,sha256=9aWWXFsovBPcndE06IATn5jaeli5fRORAYeenF9heN0,26264
 fleet/_async/verifiers/verifier.py,sha256=iSa-rO-E1R3IQTFS9Z7jbQvQVtsDkilITQP9IIQU2JA,14556
@@ -83,7 +83,7 @@ fleet/resources/api.py,sha256=7YQcATXjhNeEbrIDXqSMerGywxefcRz8luqrObfcsl8,6066
 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=Bdxy09oFmTRLL4S4pF3UH7Hdv29e5s2kPGEifMPvr8U,98323
+fleet/resources/sqlite.py,sha256=3rLVDTzAK54NK_MOrpyga2lU46wvFPWZaAMnnTEHD6o,103220
 fleet/utils/__init__.py,sha256=cZdaIU4KWr_xQFDpShTC2P_XVLYrlDFSBTQwWzfDQ2o,255
 fleet/utils/http_logging.py,sha256=N1qRwOHA4nTe-3JOy-2J9AK0eneWAfv9s66qnyU_Vnw,6332
 fleet/utils/logging.py,sha256=-F_JbGIAaIt_WqVJC0ch4iog4WWFQDJgUS2vxg3YH0A,319
@@ -96,7 +96,7 @@ fleet/verifiers/decorator.py,sha256=RuTjjDijbicNfMSjA7HcTpKueEki5dzNOdTuHS7UoZs,
 fleet/verifiers/parse.py,sha256=qz9AfJrTbjlg-LU-lE8Ciqi7Yt2a8-cs17FdpjTLhMk,8550
 fleet/verifiers/sql_differ.py,sha256=TqTLWyK3uOyLbitT6HYzYEzuSFC39wcyhgk3rcm__k8,6525
 fleet/verifiers/verifier.py,sha256=iqGevW7dSd0J5RdRQjpu-zioy_FYAXnzMfkuB3-QmO0,14601
-fleet_python-0.2.98.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fleet_python-0.2.99.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
@@ -106,8 +106,8 @@ tests/test_instance_dispatch.py,sha256=CvU4C3LBIqsYZdEsEFfontGjyxAZfVYyXnGwxyIvX
 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.98.dist-info/METADATA,sha256=A4D_NEs4hu_gRA21q9LFWy0oS5VRvnYOU0xJ3iZthj4,4239
-fleet_python-0.2.98.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fleet_python-0.2.98.dist-info/entry_points.txt,sha256=qKIQ326cHR5WyCd16QnrW-1DpcT0YyxVRDb3IlTyzTA,39
-fleet_python-0.2.98.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
-fleet_python-0.2.98.dist-info/RECORD,,
+fleet_python-0.2.99.dist-info/METADATA,sha256=aUW3NYcBdYsC5ZXajM2oopQV2gx0jUJqoFNL8e4GPMo,4239
+fleet_python-0.2.99.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fleet_python-0.2.99.dist-info/entry_points.txt,sha256=qKIQ326cHR5WyCd16QnrW-1DpcT0YyxVRDb3IlTyzTA,39
+fleet_python-0.2.99.dist-info/top_level.txt,sha256=qb1zIbtEktyhRFZdqVytwg54l64qtoZL0wjHB4bUg3c,29
+fleet_python-0.2.99.dist-info/RECORD,,