execsql2 2.21.1__py3-none-any.whl → 2.22.0__py3-none-any.whl

execsql/exceptions.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import Any
+
 """
 Custom exception hierarchy for execsql (internal use).
 
@@ -110,15 +112,15 @@ class ErrInfo(ExecSqlError):
         exception_msg: str | None = None,
         other_msg: str | None = None,
     ) -> None:
-        self.type = type
-        self.command = command_text
-        self.exception = None if not exception_msg else exception_msg.replace("\n", "\n     ")
-        self.other = None if not other_msg else other_msg.replace("\n", "\n     ")
-        self.script_file = None
-        self.script_line_no = None
-        self.cmd = None
-        self.cmdtype = None
-        self.error_message = None
+        self.type: str = type
+        self.command: str | None = command_text
+        self.exception: str | None = None if not exception_msg else exception_msg.replace("\n", "\n     ")
+        self.other: str | None = None if not other_msg else other_msg.replace("\n", "\n     ")
+        self.script_file: str | None = None
+        self.script_line_no: int | None = None
+        self.cmd: str | None = None
+        self.cmdtype: str | None = None
+        self.error_message: str | None = None
         # Pass a concise message to Exception so str(e), e.args, and
         # standard loggers produce useful output.
         super().__init__(self.other or self.exception or self.type)
@@ -133,7 +135,8 @@ class ErrInfo(ExecSqlError):
             if self.cmdtype == "cmd":
                 return f"Metacommand: {self.cmd}"
             else:
-                return f"SQL statement: \n         {self.cmd.replace(chr(10), chr(10) + '         ')}"
+                cmd = "" if self.cmd is None else self.cmd
+                return f"SQL statement: \n         {cmd.replace(chr(10), chr(10) + '         ')}"
         return None
 
     def eval_err(self) -> str:
@@ -199,7 +202,7 @@ class DataTypeError(ExecSqlError):
 class DbTypeError(ExecSqlError):
     """Raised when a DataType has no DBMS-specific mapping for the active database."""
 
-    def __init__(self, dbms_id: str, data_type: object, error_msg: str) -> None:
+    def __init__(self, dbms_id: str, data_type: Any, error_msg: str) -> None:
         self.dbms_id = dbms_id
         self.data_type = data_type
         self.error_msg = error_msg or "Unspecified error"

execsql/exporters/base.py

@@ -166,7 +166,7 @@ class WriteSpec:
                 except ConsoleUIError as e:
                     _state.output.reset()
                     _state.exec_log.log_status_info(
-                        f"Console UI write failed (message {{{e.value}}}); output reset to stdout.",
+                        f"Console UI write failed (message {{{e}}}); output reset to stdout.",
                     )
                     _state.output.write(msg)
             if conf.tee_write_log:

execsql/exporters/delimited.py

@@ -17,7 +17,7 @@ Provides:
 import copy
 import re
 import sys
-from typing import Any
+from typing import Any, cast
 
 from execsql.utils.fileio import EncodedFile
 from execsql.exporters.zip import ZipWriter
@@ -42,6 +42,7 @@ class LineDelimiter:
         self.joinchar = delim if delim else ""
         self.quotechar = quote
         self.quote_all_text = _state.conf.quote_all_text if _state.conf else False
+        self.quotedquote: str | None
         if quote:
             if escchar:
                 self.quotedquote = escchar + quote
@@ -63,6 +64,7 @@ class LineDelimiter:
                         or ("\n" in e)
                         or ("\r" in e)
                     ):
+                        assert self.quotedquote is not None
                         d_row.append(f"{self.quotechar}{e.replace(self.quotechar, self.quotedquote)}{self.quotechar}")
                     else:
                         d_row.append(e)
@@ -159,12 +161,12 @@ class CsvFile(EncodedFile):
         self.csvfname = csvfname
         self.junk_header_lines = junk_header_lines
         self.lineformat_set = False  # Indicates whether delimiter, quotechar, and escapechar have been set
-        self.delimiter = None
-        self.quotechar = None
-        self.escapechar = None
-        self.parse_errors = []
-        self.table_data = None  # Set to a DataTable object by 'evaluate_column_types()'
-        self.blank_cols = []  # Indexes of blank column headers--columns may be deleted
+        self.delimiter: str | None = None
+        self.quotechar: str | None = None
+        self.escapechar: str | None = None
+        self.parse_errors: list[str] = []
+        self.table_data: DataTable | None = None  # Set by 'evaluate_column_types()'
+        self.blank_cols: list[int] = []  # Indexes of blank column headers--columns may be deleted
 
     def __repr__(self) -> str:
         return f"CsvFile({self.csvfname!r}, {self.encoding!r})"
@@ -193,8 +195,8 @@ class CsvFile(EncodedFile):
         def __init__(self, line_text: str) -> None:
             """Store the raw line text and prepare delimiter-count storage."""
             self.text = line_text
-            self.delim_counts = {}
-            self.item_errors = []  # A list of error messages.
+            self.delim_counts: dict[str, int] = {}
+            self.item_errors: list[str] = []  # A list of error messages.
 
         def __str__(self) -> str:
             return "; ".join(
@@ -220,14 +222,14 @@ class CsvFile(EncodedFile):
             """Return the previously counted occurrence total for the given delimiter."""
             return self.delim_counts[delim]
 
-        def _well_quoted(self, element: str, qchar: str):
+        def _well_quoted(self, element: str, qchar: str | None):
             # A well-quoted element has either no quotes, a quote on each end and none
             # in the middle, or quotes on both ends and every internal quote is either
             # doubled or escaped.
             # Returns a tuple of three booleans; the first indicates whether the element is
             # well-quoted, the second indicates whether the quote character is used
             # at all, and the third indicates whether the escape character is used.
-            if qchar not in element:
+            if qchar is None or qchar not in element:
                 return (True, False, False)
             if len(element) == 0:
                 return (True, False, False)
@@ -439,7 +441,7 @@ class CsvFile(EncodedFile):
             delim_wts = {}
             for d in delim_stats:
                 delim_wts[d] = delim_stats[d][0] ** 2 * delim_stats[d][1]
-            delim_order = sorted(delim_wts, key=delim_wts.get, reverse=True)
+            delim_order = sorted(delim_wts, key=lambda d: delim_wts[d], reverse=True)
             for d in delim_order:
                 quote_check = eval_quotes(d)
                 if quote_check[0] and quote_check[1]:
@@ -633,6 +635,7 @@ class CsvFile(EncodedFile):
 
         f = self.openclean("rt")
         try:
+            assert self.delimiter is not None
             csv_reader = csv.reader(
                 f,
                 delimiter=self.delimiter,
@@ -644,13 +647,13 @@ class CsvFile(EncodedFile):
                 if len(elements) == 0:
                     break
                 # Normalize empty strings to None for parity with the slow reader.
-                elements = [e if e != "" else None for e in elements]
+                normalized_elements = [e if e != "" else None for e in elements]
                 if conf.del_empty_cols and len(self.blank_cols) > 0:
                     blanks = copy.copy(self.blank_cols)
                     while len(blanks) > 0:
                         b = blanks.pop()
-                        del elements[b]
-                yield elements
+                        del normalized_elements[b]
+                yield normalized_elements
         finally:
             f.close()
 
@@ -721,7 +724,7 @@ class CsvFile(EncodedFile):
             colnames = fold_words(colnames, conf.fold_col_hdrs)
         if conf.dedup_col_hdrs:
             colnames = dedup_words(colnames)
-        return colnames
+        return cast(list[str], colnames)
 
     def column_headers(self) -> list[str]:
         """Return the first row of the file as a list of column header strings."""
@@ -734,6 +737,7 @@ class CsvFile(EncodedFile):
         """Return a :class:`DataTable` describing the file's columns and types."""
         if self.table_data is None:
             self.evaluate_column_types()
+        assert self.table_data is not None
         return self.table_data
 
     def evaluate_column_types(self) -> None:
@@ -746,6 +750,7 @@ class CsvFile(EncodedFile):
 
     def create_table(self, database_type: Any, schemaname: str | None, tablename: str, pretty: bool = False) -> str:
         """Generate a CREATE TABLE SQL statement for this file's inferred schema."""
+        assert self.table_data is not None
         return self.table_data.create_table(database_type, schemaname, tablename, pretty)
 
 
@@ -787,6 +792,7 @@ def write_delimited_file(
         quote = ""
         escchar = None
     line_delimiter = LineDelimiter(delim, quote, escchar)
+    ofile: Any
     if zipfile is not None:
         ofile = ZipWriter(zipfile, outfile, append)
         fdesc = f"{outfile} in {zipfile}"

execsql/exporters/duckdb.py

@@ -8,6 +8,8 @@ to a table in a DuckDB database file.  Used by ``EXPORT … FORMAT duckdb``.
 Requires the ``execsql2[duckdb]`` extra.
 """
 
+import datetime as _datetime
+import decimal as _decimal
 import math
 from pathlib import Path
 from typing import Any
@@ -15,6 +17,8 @@ from typing import Any
 from execsql.exceptions import ErrInfo
 from execsql.types import dbt_duckdb
 
+_DUCKDB_SAFE = (int, float, str, bytes, bool, _decimal.Decimal, _datetime.datetime, _datetime.date, _datetime.time)
+
 __all__ = ["export_duckdb", "write_query_to_duckdb"]
 
 
@@ -59,7 +63,8 @@ def export_duckdb(
         curs.close()
     # Construct and run the CREATE TABLE statement
     rowdata = list(rows)
-    tablespec = DataTable(hdrs, rowdata)
+    tablespec = DataTable(hdrs, rowdata, infer_strings=False)
+    rowdata = [tuple(v if (v is None or isinstance(v, _DUCKDB_SAFE)) else str(v) for v in row) for row in rowdata]
     sql = tablespec.create_table(dbt_duckdb, schemaname=None, tablename=tablename)
     curs = ddb.cursor()
     curs.execute(sql)

execsql/exporters/feather.py

@@ -33,7 +33,7 @@ def write_query_to_feather(outfile: str, headers: list[str], rows: Any) -> None:
         ) from e
     rows_list = list(rows)
     if rows_list:
-        df = pl.DataFrame(rows_list, schema=headers, orient="row")
+        df = pl.DataFrame(rows_list, schema=headers, orient="row", infer_schema_length=None)
     else:
         df = pl.DataFrame({h: [] for h in headers})
     filewriter_close(outfile)
@@ -93,7 +93,7 @@ def write_query_to_hdf5(
             raise ErrInfo("error", other_msg=f"Invalid data type for export to HDF5: {repr(datatype)}")
         return t, do_cast
 
-    tbl_desc = DataTable(hdrs, rows)
+    tbl_desc = DataTable(hdrs, rows, infer_strings=False)
     h5type_dict = {}
     cast_flags = []
     for h in hdrs:

execsql/exporters/json.py

@@ -14,7 +14,7 @@ from typing import Any
 import execsql.state as _state
 from execsql.exporters.zip import ZipWriter
 from execsql.exceptions import ErrInfo
-from execsql.models import DataTable
+from execsql.models import DataTable, to_json_type
 from execsql.utils.errors import exception_desc
 from execsql.utils.fileio import filewriter_close
 
@@ -37,6 +37,7 @@ def write_query_to_json(
         raise
     except Exception as e:
         raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
+    f: Any
     if zipfile is None:
         filewriter_close(outfile)
         from execsql.utils.fileio import EncodedFile
@@ -85,6 +86,7 @@ def write_query_to_json_ts(
     except Exception as e:
         raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
     max_col_idx = len(hdrs) - 1
+    f: Any
     if zipfile is None:
         filewriter_close(outfile)
         from execsql.utils.fileio import EncodedFile
@@ -105,7 +107,7 @@ def write_query_to_json_ts(
         f.write('  "fields": [\n')
         if write_types:
             # Scan the data to determine data types.
-            tbl_desc = DataTable(hdrs, rows)
+            tbl_desc = DataTable(hdrs, rows, infer_strings=False)
             # Write the column descriptions to the header.
             # Iterate over hdrs instead of tbl_desc.cols to preserve column order.
             for i, h in enumerate(hdrs):
@@ -113,7 +115,7 @@ def write_query_to_json_ts(
                 c = [col for col in tbl_desc.cols if col.name == h][0]
                 jname = json.dumps(c.name)
                 jtitle = json.dumps(c.name.capitalize().replace("_", " "))
-                jtype = json.dumps(_state.to_json_type[c.dt[1]])
+                jtype = json.dumps(to_json_type[c.dt[1]])
                 f.write(
                     f'    {{\n      "name": {jname},\n      "title": {jtitle},\n      "type": {jtype}\n    }}{qcomma}\n',
                 )

execsql/exporters/latex.py

@@ -14,7 +14,7 @@ from pathlib import Path
 from typing import Any
 
 from execsql.exceptions import ErrInfo
-from execsql.exporters.zip import WriteableZipfile
+from execsql.exporters.zip import ZipWriter
 import execsql.state as _state
 
 __all__ = ["export_latex", "write_query_to_latex"]
@@ -62,7 +62,7 @@ def export_latex(
                 ef = EncodedFile(outfile, conf.output_encoding)
                 f = ef.open("wt")
             else:
-                f = WriteableZipfile(zipfile).open(outfile, append)
+                f = ZipWriter(zipfile, outfile, append)
         try:
             f.write("\\documentclass{article}\n")
             f.write("\\begin{document}\n")

execsql/exporters/markdown.py

@@ -103,6 +103,7 @@ def write_query_to_markdown(
         dashes = (f" {'-' * col_widths[i]} " for i in range(len(str_hdrs)))
         return "|" + "|".join(dashes) + "|\n"
 
+    f: Any
     if zipfile is None:
         filewriter_close(outfile)
         from execsql.utils.fileio import EncodedFile

execsql/exporters/ods.py

@@ -25,6 +25,8 @@ from execsql.utils.strings import unquoted
 
 __all__ = ["OdsFile", "export_ods", "write_query_to_ods", "write_queries_to_ods"]
 
+of: Any = None
+
 
 class OdsFile:
     """Wrapper around the ``odfpy`` library for reading and writing OpenDocument Spreadsheet files."""
@@ -55,9 +57,9 @@ class OdsFile:
             import odf.style  # noqa: F401
         except ImportError:
             fatal_error("The odfpy library is needed to create OpenDocument spreadsheets.")
-        self.filename = None
-        self.wbk = None
-        self.cell_style_names = []
+        self.filename: str | None = None
+        self.wbk: Any = None
+        self.cell_style_names: list[str] = []
 
     def open(self, filename: str) -> None:
         """Open an existing ODS file or create a new one at the given path."""
@@ -278,6 +280,8 @@ class OdsFile:
 
     def save_close(self) -> None:
         """Serialise the workbook to disk and release all resources."""
+        if self.filename is None:
+            raise OdsFileError("Cannot save an ODS file before it has been opened.")
         with open(self.filename, "wb") as ofile:
             self.wbk.write(ofile)
         self.filename = None

execsql/exporters/parquet.py

@@ -28,7 +28,7 @@ def write_query_to_parquet(outfile: str, headers: list[str], rows: Any) -> None:
         ) from e
     rows_list = list(rows)
     if rows_list:
-        df = pl.DataFrame(rows_list, schema=headers, orient="row")
+        df = pl.DataFrame(rows_list, schema=headers, orient="row", infer_schema_length=None)
     else:
         df = pl.DataFrame({h: [] for h in headers})
     filewriter_close(outfile)

execsql/exporters/raw.py

@@ -40,19 +40,19 @@ def write_query_raw(
                         else:
                             of.write(bytes(str(col), db_encoding))
     else:
-        of = ZipWriter(zipfile, outfile, append)
+        zip_of: Any = ZipWriter(zipfile, outfile, append)
         try:
             for row in rowsource:
                 for col in row:
                     if isinstance(col, bytearray):
-                        of.write(col)
+                        zip_of.write(col)
                     else:
                         if isinstance(col, str):
-                            of.write(bytes(col, db_encoding))
+                            zip_of.write(bytes(col, db_encoding))
                         else:
-                            of.write(bytes(str(col), db_encoding))
+                            zip_of.write(bytes(str(col), db_encoding))
         finally:
-            of.close()
+            zip_of.close()
 
 
 def write_query_b64(outfile: str, rowsource: Any, append: bool = False, zipfile: str | None = None) -> None:
@@ -65,10 +65,10 @@ def write_query_b64(outfile: str, rowsource: Any, append: bool = False, zipfile:
                 for col in row:
                     of.write(base64.standard_b64decode(col))
     else:
-        of = ZipWriter(zipfile, outfile, append)
+        zip_of: Any = ZipWriter(zipfile, outfile, append)
         try:
             for row in rowsource:
                 for col in row:
-                    of.write(base64.standard_b64decode(col))
+                    zip_of.write(base64.standard_b64decode(col))
         finally:
-            of.close()
+            zip_of.close()

execsql/exporters/sqlite.py

@@ -8,12 +8,15 @@ to a table in an SQLite database file.  Used by ``EXPORT … FORMAT sqlite``.
 """
 
 import math
+from decimal import Decimal
 from pathlib import Path
 from typing import Any
 
 from execsql.exceptions import ErrInfo
 from execsql.types import dbt_sqlite
 
+_SQLITE_SAFE = (int, float, str, bytes)
+
 __all__ = ["export_sqlite", "write_query_to_sqlite"]
 
 
@@ -54,7 +57,14 @@ def export_sqlite(
             curs.close()
         # Construct and run the CREATE TABLE statement
         rowdata = list(rows)
-        tablespec = DataTable(hdrs, rowdata)
+        tablespec = DataTable(hdrs, rowdata, infer_strings=False)
+        rowdata = [
+            tuple(
+                str(v) if isinstance(v, Decimal) else v if (v is None or isinstance(v, _SQLITE_SAFE)) else str(v)
+                for v in row
+            )
+            for row in rowdata
+        ]
         sql = tablespec.create_table(dbt_sqlite, schemaname=None, tablename=tablename)
         curs = sdb.cursor()
         curs.execute(sql)

execsql/exporters/templates.py

@@ -139,7 +139,7 @@ class JinjaTemplateReport:
         try:
             ofile.write(self.template.render(headers=headers, datatable=data_dict_rows))
         except self._jinja2.TemplateSyntaxError as e:
-            raise ErrInfo("error", other_msg=e.message + f" on template line {e.lineno}") from e
+            raise ErrInfo("error", other_msg=f"{e} on template line {e.lineno}") from e
         except self._jinja2.TemplateError as e:
             raise ErrInfo("error", other_msg=f"Jinja2 template error ({e.message})") from e
         finally:
@@ -160,6 +160,7 @@ def report_query(
     conf = _state.conf
     _state.status.sql_error = False
     headers, ddict = db.select_rowdict(select_stmt)
+    t: Any
     if conf.template_processor == "jinja":
         t = JinjaTemplateReport(template_file)
     else:

execsql/exporters/xls.py

@@ -19,7 +19,7 @@ Both back-ends are optional dependencies; install via
 
 import datetime
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 from execsql.exceptions import XlsFileError, XlsxFileError
 from execsql.utils.errors import fatal_error
@@ -38,7 +38,7 @@ class XlsFile:
 
         def __init__(self) -> None:
             """Initialise an empty message list."""
-            self.log_msgs = []
+            self.log_msgs: list[str] = []
 
         def write(self, msg: str) -> None:
             """Append a log message to the internal list."""
@@ -52,9 +52,9 @@ class XlsFile:
             self._xlrd = xlrd
         except ImportError:
             fatal_error("The xlrd library is needed to read Excel (.xls) spreadsheets.")
-        self.filename = None
-        self.encoding = None
-        self.wbk = None
+        self.filename: str | None = None
+        self.encoding: str | None = None
+        self.wbk: Any = None
         self.datemode = 0
         self.errlog = self.XlsLog()
 
@@ -177,7 +177,7 @@ class XlsxFile:
 
         def __init__(self) -> None:
             """Initialise an empty message list."""
-            self.log_msgs = []
+            self.log_msgs: list[str] = []
 
         def write(self, msg: str) -> None:
             """Append a log message to the internal list."""
@@ -191,9 +191,9 @@ class XlsxFile:
             self._openpyxl = openpyxl
         except ImportError:
             fatal_error("The openpyxl library is needed to read Excel (.xlsx) spreadsheets.")
-        self.filename = None
-        self.encoding = None
-        self.wbk = None
+        self.filename: str | None = None
+        self.encoding: str | None = None
+        self.wbk: Any = None
         self.read_only = False
         self.errlog = self.XlsxLog()
 
@@ -224,7 +224,7 @@ class XlsxFile:
 
     def sheetnames(self) -> list[str]:
         """Return the list of worksheet names in the open workbook."""
-        return self.wbk.sheetnames
+        return cast(list[str], self.wbk.sheetnames)
 
     def sheet_named(self, sheetname: Any) -> Any:
         """Return the sheet matching a name or 1-based integer index."""

execsql/exporters/xml.py

@@ -38,6 +38,7 @@ def write_query_to_xml(
         raise
     except Exception as e:
         raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
+    f: Any
     if zipfile is None:
         filewriter_close(outfile)
         from execsql.utils.fileio import EncodedFile

execsql/exporters/yaml.py

@@ -72,6 +72,7 @@ def write_query_to_yaml(
     data = [dict(zip(uhdrs, row)) for row in rows]
     yaml_text = yaml.dump(data, default_flow_style=False, allow_unicode=True)
 
+    f: Any
     if zipfile is None:
         filewriter_close(outfile)
         from execsql.utils.fileio import EncodedFile

execsql/exporters/zip.py

@@ -12,6 +12,7 @@ directed into a ``.zip`` archive.
 import sys
 import time
 import zipfile
+from typing import IO, Any, Literal, cast
 
 import execsql.state as _state
 
@@ -28,9 +29,9 @@ class WriteableZipfile:
         self.buf = memoryview(bytearray(self.bufsize))
         self.buflen = 0  # Length of buffer contents.
         comp = zipfile.ZIP_BZIP2
-        zmode = "w" if not append else "a"
+        zmode: Literal["w", "a"] = "w" if not append else "a"
         self.zf = zipfile.ZipFile(zipfile_name, mode=zmode, compression=comp, compresslevel=9)
-        self.current_handle = None
+        self.current_handle: IO[bytes] | None = None
 
     def __enter__(self) -> WriteableZipfile:
         return self
@@ -54,7 +55,7 @@ class WriteableZipfile:
         )
         self.current_zinfo.compress_type = self.zf.compression
         if sys.version_info.major >= 3 and sys.version_info.minor >= 7:
-            self.current_zinfo._compresslevel = self.zf.compresslevel
+            self.current_zinfo._compresslevel = self.zf.compresslevel  # type: ignore[attr-defined]
         # See https://stackoverflow.com/questions/434641/how-do-i-set-permissions-attributes-on-a-file-in-a-zip-file-using-pythons-zip
         self.current_zinfo.external_attr = 0o100755 << 16  # ?rw-rw-rw-
         if sys.platform.startswith("win"):
@@ -62,13 +63,13 @@ class WriteableZipfile:
         else:
             self.current_zinfo.create_system = 3
         self.current_zinfo.file_size = 0
-        self.current_handle = self.zf.open(self.current_zinfo, mode="w")
+        self.current_handle = cast(IO[bytes], self.zf.open(self.current_zinfo, mode="w"))
 
     def zip_buffer(self) -> None:
         """Flush any buffered bytes to the currently open zip member file."""
         # Writes the buffer contents, if any, to the zip member file.
         if self.buflen > 0 and self.current_handle is not None:
-            with self.zf._lock:
+            with cast(Any, self.zf)._lock:
                 self.current_zinfo.file_size = self.current_zinfo.file_size + self.buflen
                 self.current_handle.write(self.buf[0 : self.buflen])
             self.buflen = 0
@@ -104,8 +105,8 @@ class ZipWriter:
         """Open the archive at ``zip_fname`` and begin a new member file named ``member_fname``."""
         self.zip_fname = zip_fname
         self.member_fname = member_fname
-        self.zwriter = WriteableZipfile(self.zip_fname, append)
-        self.member = self.zwriter.member_file(member_fname)
+        self.zwriter: WriteableZipfile | None = WriteableZipfile(self.zip_fname, append)
+        self.zwriter.member_file(member_fname)
 
     def __enter__(self) -> ZipWriter:
         return self
@@ -116,6 +117,7 @@ class ZipWriter:
 
     def write(self, str_data: str) -> None:
         """Write a string to the current zip member."""
+        assert self.zwriter is not None
         self.zwriter.write(str_data)
 
     def close(self) -> None:

execsql/format.py

@@ -383,22 +383,22 @@ def _format_preserving_comments(
             # Strip markers to get the underlying SQL line and its indent
             cleaned = _CMT_MARKER_RE.sub("", fline).strip()
             # Determine indent: use the SQL line's indent from sqlglot
-            sql_indent = ""
+            line_indent = ""
             if cleaned:
                 raw_cleaned = _CMT_MARKER_RE.sub("", fline)
-                sql_indent = raw_cleaned[: len(raw_cleaned) - len(raw_cleaned.lstrip())]
+                line_indent = raw_cleaned[: len(raw_cleaned) - len(raw_cleaned.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(sql_indent + orig_stripped)
+                        result.append(line_indent + orig_stripped)
                     else:
                         result.append("")
                     found_markers.add(m)
             if cleaned:
-                result.append(sql_indent + cleaned)
+                result.append(line_indent + cleaned)
         else:
             result.append(fline)
 
@@ -493,8 +493,8 @@ def format_sql_block(
     # which preserves both comments AND sqlglot formatting.  When all
     # comments are between statements, the simpler segmentation works.
     if _has_mid_statement_comments(rebased):
-        result = _format_preserving_comments(rebased, sql_indent=indent, leading_comma=leading_comma)
-        return [target_prefix + line if line.strip() else "" for line in result]
+        formatted_lines = _format_preserving_comments(rebased, sql_indent=indent, leading_comma=leading_comma)
+        return [target_prefix + line if line.strip() else "" for line in formatted_lines]
 
     result: list[str] = []
     seg: list[str] = []

execsql/gui/console.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 import os
 import sys
 import time
-from typing import Any
+from typing import Any, cast
 
 from execsql.gui.base import DIFF_MARKER, GuiBackend, compare_stats as _compare_stats, compute_row_diffs
 
@@ -88,9 +88,9 @@ def _prompt_buttons(button_list: list) -> int | None:
     while True:
         raw = input("Choice: ").strip()
         if raw.lower() in choices:
-            return choices[raw.lower()]
+            return cast(int | None, choices[raw.lower()])
         if raw in choices:
-            return choices[raw]
+            return cast(int | None, choices[raw])
         print("Invalid choice, please try again.", file=sys.stderr)