execsql2 2.22.6__py3-none-any.whl → 2.22.8__py3-none-any.whl

execsql/format.py

@@ -176,13 +176,18 @@ _EXECSQL_VAR_RE = re.compile(r"""!(['"]?)!([^!\s][^!]*)!\1!|!\{[^}]+\}!""")
 _IDENT_CHAR_RE = re.compile(r"[A-Za-z0-9_$]")
 
 
-def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
-    """Yield ``(start, end, kind)`` spans for every string literal in *sql*.
+_LITERAL_KINDS = frozenset({"estring", "plain", "dollar"})
+
+
+def _iter_sql_spans(sql: str) -> Iterator[tuple[int, int, str]]:
+    """Yield ``(start, end, kind)`` spans for every non-code region of *sql*.
 
     This is a lexical walk rather than a regex sweep, because an apostrophe
-    only starts a literal in some contexts.  Line comments, block comments
-    (which nest in PostgreSQL), and quoted identifiers are skipped entirely,
-    so quotes inside them never open a literal.
+    only starts a literal in some contexts: inside a line comment, a block
+    comment (which nests in PostgreSQL), or a quoted identifier it is just a
+    character.  Those three regions are reported as spans of their own so
+    callers that care about code positions — :func:`_paren_depths` — can mask
+    them out, and :func:`_iter_sql_literals` filters them back off.
 
     *kind* is one of:
 
@@ -195,6 +200,8 @@ def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
     ``"dollar"``
         A dollar-quoted body, ``$$...$$`` or ``$tag$...$tag$``, in which no
         character is special.
+    ``"line_comment"``, ``"block_comment"``, ``"quoted_ident"``
+        Regions that are not code and hold no literal.
     """
     i, n = 0, len(sql)
     while i < n:
@@ -202,10 +209,13 @@ def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
 
         if c == "-" and sql.startswith("--", i):
             nl = sql.find("\n", i)
-            i = n if nl < 0 else nl + 1
+            stop = n if nl < 0 else nl
+            yield i, stop, "line_comment"
+            i = stop
             continue
 
         if c == "/" and sql.startswith("/*", i):
+            start = i
             depth, i = 1, i + 2
             while i < n and depth:
                 if sql.startswith("/*", i):
@@ -214,9 +224,11 @@ def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
                     depth, i = depth - 1, i + 2
                 else:
                     i += 1
+            yield start, i, "block_comment"
             continue
 
         if c == '"':
+            start = i
             i += 1
             while i < n:
                 if sql[i] == '"':
@@ -226,6 +238,7 @@ def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
                     i += 1
                     break
                 i += 1
+            yield start, i, "quoted_ident"
             continue
 
         if c == "$":
@@ -273,6 +286,46 @@ def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
         i += 1
 
 
+def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
+    """Yield ``(start, end, kind)`` spans for every string literal in *sql*.
+
+    The literal subset of :func:`_iter_sql_spans`; comments and quoted
+    identifiers are dropped, so quotes inside them never open a literal.
+    """
+    for start, end, kind in _iter_sql_spans(sql):
+        if kind in _LITERAL_KINDS:
+            yield start, end, kind
+
+
+def _paren_depths(lines: list[str]) -> list[int]:
+    """Return the parenthesis nesting depth at the start of each of *lines*.
+
+    Parentheses inside string literals, comments, and quoted identifiers do
+    not count.  Depth resets at every ``;`` so one statement with unbalanced
+    parens — which only happens when the input is a fragment — cannot skew
+    the statements that follow.
+    """
+    text = "\n".join(lines)
+    chars = list(text)
+    for start, end, _kind in _iter_sql_spans(text):
+        for i in range(start, min(end, len(chars))):
+            if chars[i] != "\n":
+                chars[i] = " "
+
+    depths: list[int] = []
+    depth = 0
+    for line in "".join(chars).split("\n"):
+        depths.append(depth)
+        for ch in line:
+            if ch == "(":
+                depth += 1
+            elif ch == ")":
+                depth = max(0, depth - 1)
+            elif ch == ";":
+                depth = 0
+    return depths
+
+
 def _sql_literal_texts(sql: str) -> list[str]:
     """Return the source text of every string literal in *sql*, in order."""
     return [sql[start:end] for start, end, _ in _iter_sql_literals(sql)]
@@ -456,7 +509,21 @@ def _sqlglot_format(
 
     try:
         with contextlib.redirect_stderr(io.StringIO()):
-            ast = sqlglot.parse(protected, read="postgres", error_level=sqlglot_errors.ErrorLevel.IGNORE)
+            # Parse with RAISE, not IGNORE.  Under IGNORE sqlglot answers a
+            # statement it cannot parse with a *partial* AST — the tokens it
+            # failed on are simply absent — and regenerating from that AST
+            # writes back SQL that no longer means what the author wrote.
+            # ``INSERT ... CROSS JOIN LATERAL (VALUES ...) AS g(a, b) ON
+            # CONFLICT (a) DO NOTHING`` came back with ``DO NOTHING`` deleted:
+            # still one statement, still 88% of the input's alphanumeric
+            # characters, no string literals to compare, so every guard below
+            # passed it through.  The guards are quantitative and this loss is
+            # qualitative — a dropped ``DISTINCT``, ``CASCADE``, ``DESC`` or
+            # ``NOT`` is smaller still, and no threshold separates those from
+            # ordinary reformatting.  Only the parser knows whether it
+            # understood the whole statement, so ask it: input that does not
+            # parse is left exactly as written.
+            ast = sqlglot.parse(protected, read="postgres", error_level=sqlglot_errors.ErrorLevel.RAISE)
             statements: list[str] = []
             for node in ast:
                 if node is None:
@@ -524,6 +591,10 @@ def _sqlglot_format(
         if restored is None:
             return sql_lines
         return _restore_variables(restored, replacements).split("\n")
+    except sqlglot_errors.ParseError:
+        # Unparsable input: anything generated from a partial parse is
+        # untrustworthy, so emit the original lines untouched.
+        return sql_lines
     except Exception:
         return sql_lines
 
@@ -570,6 +641,34 @@ _CMT_MARKER_RE = re.compile(rf"/\*\s*({re.escape(_CMT_MARKER)}\d+)\s*\*/")
 # converge.  Matching the run as a unit removes it cleanly.  See issue #35.
 _CMT_MARKER_RUN_RE = re.compile(rf"\s*(?:/\*\s*{re.escape(_CMT_MARKER)}\d+\s*\*/\s*)+")
 
+# Characters that must not be preceded by a space once a marker run between
+# them and the previous token is removed.
+_NO_SPACE_BEFORE = frozenset(",;).")
+
+
+def _strip_marker_runs(line: str) -> str:
+    """Remove every comment-marker run from *line*, leaving no stray spacing.
+
+    A run stands where the author wrote nothing, so it is replaced by the one
+    space that keeps its neighbours apart — ``AND /* m */ RTRIM(`` must not
+    become ``ANDRTRIM(``.  At the ends of the line, or against punctuation
+    that binds to the token before it, that space is not a separator but
+    residue: sqlglot emitting ``1 = 1 /* m */;`` left ``1 = 1 ;``, which the
+    next run then normalised — costing a pass and making ``--check`` fail on a
+    file that was already formatted.  See issue #35.
+    """
+
+    def repl(match: re.Match[str]) -> str:
+        before = line[: match.start()]
+        after = line[match.end() :]
+        if not before.strip() or not after.strip():
+            return ""
+        if after[:1] in _NO_SPACE_BEFORE or before.endswith("("):
+            return ""
+        return " "
+
+    return _CMT_MARKER_RUN_RE.sub(repl, line)
+
 
 def _format_preserving_comments(
     lines: list[str],
@@ -595,6 +694,7 @@ def _format_preserving_comments(
     comment_store: dict[str, str] = {}  # marker → original comment line
     # Track the SQL line that originally followed each comment, for fallback
     anchor_sql: dict[str, str] = {}  # marker → next SQL line (stripped)
+    anchor_line: dict[str, int] = {}  # marker → index of that line in `processed`
     pending_markers: list[str] = []
     processed: list[str] = []
     in_block = False
@@ -621,50 +721,87 @@ def _format_preserving_comments(
             processed.append(f"{prefix} {line}" if prefix else line)
             for m in pending_markers:
                 anchor_sql[m] = stripped
+                anchor_line[m] = len(processed) - 1
             pending_markers.clear()
 
     # Trailing comments with no following SQL — preserve as-is
     trailing: list[str] = [comment_store[m] for m in pending_markers]
 
+    # Parenthesis depth each comment sat at in the input.  A comment on its own
+    # line belongs to the SQL line below it, so it shares that line's depth.
+    in_depths = _paren_depths(processed)
+    anchor_depth: dict[str, int] = {m: in_depths[i] for m, i in anchor_line.items()}
+
     # ---- Step 2: format through sqlglot ---------------------------------
     formatted = _sqlglot_format(processed, sql_indent=sql_indent, leading_comma=leading_comma)
 
     # ---- Step 3: restore surviving markers to comment lines -------------
     found_markers: set[str] = set()
-    result: list[str] = []
+    sql_out: list[str] = []
+    marker_sites: list[tuple[int, str]] = []  # (index in sql_out, marker)
     for fline in formatted:
         markers_here = _CMT_MARKER_RE.findall(fline)
-        if markers_here:
-            # Strip markers to get the underlying SQL line and its indent
-            cleaned = _CMT_MARKER_RUN_RE.sub(" ", fline).strip()
-            # Indent comes from the line's own leading whitespace, never from
-            # what is left after removing the marker.  Markers are injected as
-            # ``/* marker */ line`` — with a separating space — so measuring
-            # after removal counts that space as indentation.  Whenever
-            # sqlglot leaves the line untouched (an unparsable statement falls
-            # back verbatim) the extra space is re-measured and re-added on the
-            # next run, growing the indent by one on every pass and never
-            # converging.  See issue #35.
-            line_indent = fline[: len(fline) - len(fline.lstrip())]
-            for m in markers_here:
-                if m in comment_store:
-                    orig = comment_store[m]
-                    # Re-indent the comment to match the SQL line it precedes
-                    orig_stripped = orig.strip()
-                    if orig_stripped:
-                        result.append(line_indent + orig_stripped)
-                    else:
-                        result.append("")
-                    found_markers.add(m)
-            if cleaned:
-                result.append(line_indent + cleaned)
+        if not markers_here:
+            sql_out.append(fline)
+            continue
+        # Strip markers to get the underlying SQL line and its indent
+        cleaned = _strip_marker_runs(fline).strip()
+        # Indent comes from the line's own leading whitespace, never from
+        # what is left after removing the marker.  Markers are injected as
+        # ``/* marker */ line`` — with a separating space — so measuring
+        # after removal counts that space as indentation.  Whenever
+        # sqlglot leaves the line untouched (an unparsable statement falls
+        # back verbatim) the extra space is re-measured and re-added on the
+        # next run, growing the indent by one on every pass and never
+        # converging.  See issue #35.
+        line_indent = fline[: len(fline) - len(fline.lstrip())]
+        for m in markers_here:
+            if m in comment_store:
+                marker_sites.append((len(sql_out), m))
+                found_markers.add(m)
+        if cleaned:
+            sql_out.append(line_indent + cleaned)
+
+    # Place each comment above the line where its expression *starts*, not
+    # above whatever line the marker landed on.  sqlglot attaches an inline
+    # comment to a node, and when it then reflows that node across lines the
+    # marker can surface deep inside the expression — ``COALESCE((a.b).c,
+    # FALSE)`` puts it on the ``).c, FALSE)`` continuation line.  Restoring
+    # there splits the expression around a comment that now documents a
+    # fragment of it.  The comment's own line in the input sat at the
+    # parenthesis depth of the SQL line below it, so walk back from the marker
+    # to the nearest line at that depth: the line the reflowed expression
+    # opens on.  A marker that did not move is already at its anchor depth and
+    # stays where it is.
+    out_depths = _paren_depths(sql_out)
+    comments_before: dict[int, list[str]] = {}
+    for idx, marker in marker_sites:
+        target = idx
+        want = anchor_depth.get(marker, 0)
+        while target > 0 and target < len(out_depths) and out_depths[target] > want:
+            target -= 1
+        orig_stripped = comment_store[marker].strip()
+        if not orig_stripped:
+            comments_before.setdefault(target, []).append("")
+            continue
+        # Re-indent the comment to match the SQL line it precedes
+        if target < len(sql_out):
+            anchor = sql_out[target]
+            indent_str = anchor[: len(anchor) - len(anchor.lstrip())]
         else:
-            result.append(fline)
+            indent_str = ""
+        comments_before.setdefault(target, []).append(indent_str + orig_stripped)
+
+    result: list[str] = []
+    for i, line in enumerate(sql_out):
+        result.extend(comments_before.get(i, ()))
+        result.append(line)
+    result.extend(comments_before.get(len(sql_out), ()))
 
     # ---- Step 4: reinsert lost markers ----------------------------------
     lost = [m for m in comment_store if m not in found_markers and m not in set(pending_markers)]
     if lost:
-        _reinsert_lost_comments(result, lost, comment_store, anchor_sql)
+        _reinsert_lost_comments(result, lost, comment_store, anchor_sql, anchor_depth)
 
     result.extend(trailing)
     return result
@@ -675,14 +812,22 @@ def _reinsert_lost_comments(
     lost_markers: list[str],
     comment_store: dict[str, str],
     anchor_sql: dict[str, str],
+    anchor_depth: dict[str, int],
 ) -> None:
     """Best-effort reinsertion of comments that sqlglot dropped.
 
     For each lost comment, extract key tokens from its anchor SQL line and
     find the output line that best matches, then insert the comment before
     that line (indented to match).  Operates on *result* in place.
+
+    Token matching scores whole lines, so on a reflowed expression the best
+    match is often a continuation line — ``a.meas_value`` out of ``CASE WHEN
+    (a.meas_value).undetected``.  Inserting there splits the expression, so
+    the match is pulled back to the line where the expression opens, the same
+    way surviving markers are placed in :func:`_format_preserving_comments`.
     """
     _word_re = re.compile(r"[a-zA-Z_]\w*")
+    out_depths = _paren_depths(result)
 
     # Process in reverse order so earlier inserts don't shift later indices.
     insertions: list[tuple[int, str]] = []
@@ -709,6 +854,10 @@ def _reinsert_lost_comments(
                 best_score = score
                 best_idx = i
 
+        want = anchor_depth.get(marker, 0)
+        while best_idx > 0 and best_idx < len(out_depths) and out_depths[best_idx] > want:
+            best_idx -= 1
+
         # Re-indent comment to match the target line
         if best_idx < len(result):
             target = result[best_idx]

{execsql2-2.22.6.dist-info → execsql2-2.22.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.22.6
+Version: 2.22.8
 Summary: Runs a SQL script against a PostgreSQL, SQLite, MariaDB/MySQL, DuckDB, Firebird, MS-Access, MS-SQL-Server, or Oracle database, or an ODBC DSN. Provides metacommands to import and export data, copy data between databases, conditionally execute SQL and metacommands, and dynamically alter SQL and metacommands with substitution variables.
 Project-URL: Homepage, https://execsql2.readthedocs.io
 Project-URL: Repository, https://github.com/geocoug/execsql
@@ -384,7 +384,7 @@ execsql-format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.22.6
+    rev: v2.22.8
     hooks:
       - id: execsql-format
 ```

{execsql2-2.22.6.dist-info → execsql2-2.22.8.dist-info}/RECORD

@@ -3,7 +3,7 @@ execsql/__main__.py,sha256=HdbK-SAhyUmfB6xINY5AzxdMSxGzWSGEG_2dv42Jn64,315
 execsql/api.py,sha256=EOtBwMnm-8fmB_KmvxyjglR6C7CjdYhCPBisJ9CFfJg,22227
 execsql/config.py,sha256=txKziUJLV7UPonj2sGFgkmlinDdSV50aHmR_cuCbEIo,34369
 execsql/exceptions.py,sha256=GlphAiR8iZu4UR4U50WgSqEUMd9_8AeQJ_hhPcJOeQU,9381
-execsql/format.py,sha256=YJH_JA1_IqBfeWhgrusA3KKs_xrmbm3ktuVf_xJryws,46017
+execsql/format.py,sha256=OOxsOX6g7otVgL3gI6uGxa5WIh8GTvjJ8WO-_P91zXg,52886
 execsql/models.py,sha256=-DWTVrPNwM-n1h3e3rXMoBv9-wpWVdZahyy4RB7fRRE,15502
 execsql/parser.py,sha256=aOxZ7Mzgvk7G4-nvy9Bgz7xlaZm6oo81cffDeBk_LCk,15597
 execsql/plugins.py,sha256=l82VWa5NpvOQWD6vcO-WKP-vtn0wp9__wWDFAbwxZg0,12838
@@ -101,23 +101,23 @@ execsql/utils/numeric.py,sha256=_7bi5R6pHjMCkOPne_Sh5nUj-B8e9g6WFmjptFHaunA,1573
 execsql/utils/regex.py,sha256=B3mSBhRRx_DpUnX_t9IoYd05KvWAebiLMCZqQAmEwcw,3885
 execsql/utils/strings.py,sha256=UQNjpRCEFa1UO6feU-M-9e24wWAvizs_iu_4fFusLxo,8516
 execsql/utils/timer.py,sha256=eDYf5VzCNFk7oo90InJucUm3XcBdhYMogjZMqeg9xzc,1899
-execsql2-2.22.6.data/data/execsql2_extras/README.md,sha256=vX4NTL095dUoA_hesyRMGYBorEZ_Y_tJ9qrd-MVV09I,5032
-execsql2-2.22.6.data/data/execsql2_extras/config_settings.sqlite,sha256=aY5cxR7Q7J6zJ4bC9lu5mHUrhy211Cq3MNKPQVCt02E,20480
-execsql2-2.22.6.data/data/execsql2_extras/example_config_prompt.sql,sha256=2e8KzzVWhho8KxYVHETSVmZdhW7wodioDsqBLSL6m4s,7487
-execsql2-2.22.6.data/data/execsql2_extras/make_config_db.sql,sha256=WwyC6dK-Eh5CAVppiBCDHqiI1_wEI9U95Ytpr4lsZkg,8726
-execsql2-2.22.6.data/data/execsql2_extras/md_compare.sql,sha256=qYYVAjSeHZzjszxV3Bv6bg8Ckbq2kMHl87_gh4sywMU,24140
-execsql2-2.22.6.data/data/execsql2_extras/md_glossary.sql,sha256=hkZ2Onn57LAKKsuXxzhR8tPtcWXkmWEQkwPE58-Tm2k,10796
-execsql2-2.22.6.data/data/execsql2_extras/md_upsert.sql,sha256=_CAK4BzEboRXTNy03SJR-oOjcEdSNMuRBPL6noWUptY,112560
-execsql2-2.22.6.data/data/execsql2_extras/pg_compare.sql,sha256=1zJd4hVUKHR0tncc2qTBC9B4qVV4Us2ITkJpsjN3tMw,24352
-execsql2-2.22.6.data/data/execsql2_extras/pg_glossary.sql,sha256=IKuwna-_8b20ljSkXZruuiQigrCpo7ueQdUqd1MXiuI,9908
-execsql2-2.22.6.data/data/execsql2_extras/pg_upsert.sql,sha256=HpPJtTHvpEjQy03j-3iPxDEOHMRkudOg7O4D4YR38UI,108315
-execsql2-2.22.6.data/data/execsql2_extras/script_template.sql,sha256=2J35ddZPguJ-vwTsz83wErv0jiWUyJcdW_JM0mNKDXA,11155
-execsql2-2.22.6.data/data/execsql2_extras/ss_compare.sql,sha256=j1qVNUPXQsEU7-DoVgDJCGcE0EuIl7whLBT3fgeiMAo,24833
-execsql2-2.22.6.data/data/execsql2_extras/ss_glossary.sql,sha256=2gLxv34xzKt0vy7hSzJH7a9JiMC3ETrv9MofxQwAibU,13065
-execsql2-2.22.6.data/data/execsql2_extras/ss_upsert.sql,sha256=G_8rQ0VzuKIZHWs24O_WrfzpC5S27R1JsL-bFBR3SUQ,117730
-execsql2-2.22.6.dist-info/METADATA,sha256=zX8fCinRuVHLFNIAKypooRUh_qPFfn-J6oBwu30_J_U,20382
-execsql2-2.22.6.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-execsql2-2.22.6.dist-info/entry_points.txt,sha256=sUOxkM-dN1eBGGpSpDLsAaE0yNXYQKWZAfxPOlMkQyk,90
-execsql2-2.22.6.dist-info/licenses/LICENSE.txt,sha256=LBdhuxejF8_bLCHZ2kWfmDXpDGUu914Gbd6_3JjCRe0,676
-execsql2-2.22.6.dist-info/licenses/NOTICE,sha256=McYzgxYav3U1OaVsY4Su1sfBrfmplpRdA9b6-gCDQCg,342
-execsql2-2.22.6.dist-info/RECORD,,
+execsql2-2.22.8.data/data/execsql2_extras/README.md,sha256=vX4NTL095dUoA_hesyRMGYBorEZ_Y_tJ9qrd-MVV09I,5032
+execsql2-2.22.8.data/data/execsql2_extras/config_settings.sqlite,sha256=aY5cxR7Q7J6zJ4bC9lu5mHUrhy211Cq3MNKPQVCt02E,20480
+execsql2-2.22.8.data/data/execsql2_extras/example_config_prompt.sql,sha256=2e8KzzVWhho8KxYVHETSVmZdhW7wodioDsqBLSL6m4s,7487
+execsql2-2.22.8.data/data/execsql2_extras/make_config_db.sql,sha256=WwyC6dK-Eh5CAVppiBCDHqiI1_wEI9U95Ytpr4lsZkg,8726
+execsql2-2.22.8.data/data/execsql2_extras/md_compare.sql,sha256=qYYVAjSeHZzjszxV3Bv6bg8Ckbq2kMHl87_gh4sywMU,24140
+execsql2-2.22.8.data/data/execsql2_extras/md_glossary.sql,sha256=hkZ2Onn57LAKKsuXxzhR8tPtcWXkmWEQkwPE58-Tm2k,10796
+execsql2-2.22.8.data/data/execsql2_extras/md_upsert.sql,sha256=_CAK4BzEboRXTNy03SJR-oOjcEdSNMuRBPL6noWUptY,112560
+execsql2-2.22.8.data/data/execsql2_extras/pg_compare.sql,sha256=1zJd4hVUKHR0tncc2qTBC9B4qVV4Us2ITkJpsjN3tMw,24352
+execsql2-2.22.8.data/data/execsql2_extras/pg_glossary.sql,sha256=IKuwna-_8b20ljSkXZruuiQigrCpo7ueQdUqd1MXiuI,9908
+execsql2-2.22.8.data/data/execsql2_extras/pg_upsert.sql,sha256=HpPJtTHvpEjQy03j-3iPxDEOHMRkudOg7O4D4YR38UI,108315
+execsql2-2.22.8.data/data/execsql2_extras/script_template.sql,sha256=2J35ddZPguJ-vwTsz83wErv0jiWUyJcdW_JM0mNKDXA,11155
+execsql2-2.22.8.data/data/execsql2_extras/ss_compare.sql,sha256=j1qVNUPXQsEU7-DoVgDJCGcE0EuIl7whLBT3fgeiMAo,24833
+execsql2-2.22.8.data/data/execsql2_extras/ss_glossary.sql,sha256=2gLxv34xzKt0vy7hSzJH7a9JiMC3ETrv9MofxQwAibU,13065
+execsql2-2.22.8.data/data/execsql2_extras/ss_upsert.sql,sha256=G_8rQ0VzuKIZHWs24O_WrfzpC5S27R1JsL-bFBR3SUQ,117730
+execsql2-2.22.8.dist-info/METADATA,sha256=YR0z4uOGh4ontDBb5qfx18stwbhiRyHkyZDAUwE_ST4,20382
+execsql2-2.22.8.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+execsql2-2.22.8.dist-info/entry_points.txt,sha256=sUOxkM-dN1eBGGpSpDLsAaE0yNXYQKWZAfxPOlMkQyk,90
+execsql2-2.22.8.dist-info/licenses/LICENSE.txt,sha256=LBdhuxejF8_bLCHZ2kWfmDXpDGUu914Gbd6_3JjCRe0,676
+execsql2-2.22.8.dist-info/licenses/NOTICE,sha256=McYzgxYav3U1OaVsY4Su1sfBrfmplpRdA9b6-gCDQCg,342
+execsql2-2.22.8.dist-info/RECORD,,

{execsql2-2.22.6.dist-info → execsql2-2.22.8.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.0
+Generator: hatchling 1.32.3
 Root-Is-Purelib: true
 Tag: py3-none-any