execsql2 2.21.2__py3-none-any.whl → 2.22.1__py3-none-any.whl

execsql/utils/fileio.py

@@ -27,13 +27,15 @@ import io
 import multiprocessing
 import os
 import queue
+import re
 from pathlib import Path
 import stat
 import sys
 import tempfile
 import time
+from collections.abc import Callable
 from encodings.aliases import aliases as codec_dict
-from typing import Any
+from typing import Any, cast
 
 from execsql.exceptions import ErrInfo
 
@@ -76,7 +78,9 @@ def check_dir(filename: str) -> None:
         import execsql.state as _state
 
         conf = _state.conf
-        if conf.make_export_dirs:
+        # conf is None when called via the library API (e.g. a db factory
+        # function) before run() has initialized global state.
+        if conf is not None and conf.make_export_dirs:
             make_export_dirs(filename)
         else:
             dn = str(Path(filename).parent)
@@ -207,11 +211,11 @@ class FileWriter(multiprocessing.Process):
             self.open_timeout = open_timeout
             self.encoding = encoding
             self.openmode = "a"
-            self.handle = None
+            self.handle: io.TextIOWrapper | None = None
             self.status = self.STATUS_UNOPENED
-            self.open_start_time = None
+            self.open_start_time: float | None = None
             self.fail_message_written = False
-            self.output_queue: collections.deque = collections.deque()
+            self.output_queue: collections.deque[str] = collections.deque()
             self.close_after_write = False
 
         def __del__(self) -> None:
@@ -221,6 +225,7 @@ class FileWriter(multiprocessing.Process):
                 pass  # Best-effort cleanup at interpreter shutdown.
 
         def write_queue(self) -> None:
+            assert self.handle is not None
             while len(self.output_queue) > 0:
                 m = self.output_queue.pop()
                 self.handle.write(m)
@@ -238,11 +243,14 @@ class FileWriter(multiprocessing.Process):
                     self.open_start_time = time.time()
                 if time.time() - self.open_start_time < self.open_timeout:
                     try:
-                        self.handle = open(  # noqa: SIM115
-                            file=self.filename,
-                            mode=self.openmode,
-                            encoding=self.encoding,
-                            errors="backslashreplace",
+                        self.handle = cast(
+                            io.TextIOWrapper,
+                            open(  # noqa: SIM115
+                                file=self.filename,
+                                mode=self.openmode,
+                                encoding=self.encoding,
+                                errors="backslashreplace",
+                            ),
                         )
                     except Exception:
                         self.status = self.STATUS_WAITING
@@ -298,10 +306,10 @@ class FileWriter(multiprocessing.Process):
         self.return_msg_queue = return_msg_queue
         self.file_encoding = file_encoding
         self.open_timeout = open_timeout
-        self.files: dict = {}
+        self.files: dict[str, FileWriter.FileControl] = {}
         self.active = True
         # Functions in execvec must be in the same order as the CMD enums.
-        self.execvec = (
+        self.execvec: tuple[Callable[..., None], ...] = (
             self.write,
             self.close_if_open,
             self.close_all,
@@ -424,7 +432,7 @@ def filewriter_filestatus(filename: str) -> int:
     if not _writer_alive():
         return FileWriter.FileControl.STATUS_CLOSED
     fw_input.put((FileWriter.CMD_GET_STATUS, (filename,)))
-    return fw_output.get()
+    return cast(int, fw_output.get())
 
 
 def filewriter_write(filename: str, message: str) -> None:
@@ -527,19 +535,23 @@ class EncodedFile:
 
         if Path(filename).exists():
             self.encoding, self.bom_length = detect_by_bom(filename, file_encoding)
-        self.fo = None
+        self.fo: io.TextIOWrapper | None = None
 
     def open(self, mode: str = "r") -> io.TextIOWrapper:
         import execsql.state as _state
 
         conf = _state.conf
-        self.fo = open(  # noqa: SIM115
-            file=self.filename,
-            mode=mode,
-            encoding=self.encoding,
-            errors=conf.enc_err_disposition,
-            newline=None,
+        self.fo = cast(
+            io.TextIOWrapper,
+            open(  # noqa: SIM115
+                file=self.filename,
+                mode=mode,
+                encoding=self.encoding,
+                errors=conf.enc_err_disposition,
+                newline=None,
+            ),
         )
+        assert self.fo is not None
         return self.fo
 
     def close(self) -> None:
@@ -557,6 +569,7 @@ class EncodedFile:
         # before entering the ``with`` block.
         if self.fo is None:
             self.open("r")
+        assert self.fo is not None
         return self.fo
 
     def __exit__(self, exc_type, exc_val, exc_tb) -> None:
@@ -565,7 +578,15 @@ class EncodedFile:
 
 class Logger:
     # A custom logger for execsql that writes several different types of messages to a log file.
-    log_file = None
+    log_file: io.TextIOWrapper | None = None
+    _COMMON_SECRET_PATTERNS = (
+        re.compile(r"(?i)(://[^/\s:@]+:)([^@\s]+)(@)"),
+        re.compile(r"(?i)\b(password|passwd|token|secret|api[_-]?key|private[_-]?key|webhook)(\s*[=:]\s*)([^\s,;]+)"),
+        re.compile(r"\bsk-(?:live|test)-[A-Za-z0-9_-]+\b"),
+        re.compile(r"\bAKIA[A-Z0-9]{12,}\b"),
+        re.compile(r"\bgh[pousr]_[A-Za-z0-9_]{20,}\b"),
+        re.compile(r"\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b"),
+    )
 
     def __repr__(self) -> str:
         return f"Logger({self.script_file_name!r}, {self.db_name!r}, {self.server_name!r}, {self.cmdline_options!r}, {self.log_file_name!r})"
@@ -587,6 +608,7 @@ class Logger:
         self.db_name = db_name
         self.server_name = server_name
         self.cmdline_options = cmdline_options
+        self._redaction_values: list[str] = []
         if log_file_name:
             self.log_file_name = log_file_name
         else:
@@ -630,6 +652,9 @@ class Logger:
         self.run_start = _now
         self.run_id = _now.strftime("%Y%m%d_%H%M_%S_") + f"{_now.microsecond // 1000:03d}"
         self.user = getpass.getuser()
+        sz: int
+        dt: str
+        abs_script: str
         if script_file_name and Path(script_file_name).is_file():
             sz, dt = file_size_date(script_file_name)
             abs_script = str(Path(script_file_name).resolve())
@@ -653,9 +678,9 @@ class Logger:
         self.seq_no = 0
         atexit.register(self.close)
         self.exit_type = "unknown"
-        self.exit_scriptfile = None
-        self.exit_lno = None
-        self.exit_description = None
+        self.exit_scriptfile: str | None = None
+        self.exit_lno: int | None = None
+        self.exit_description: str | None = None
         atexit.register(self.log_exit)
 
     def _ts(self) -> str:
@@ -663,6 +688,29 @@ class Logger:
 
         return _datetime.datetime.now().isoformat(timespec="seconds")
 
+    def add_redaction_value(self, value: str | None) -> None:
+        if value is None:
+            return
+        value = str(value)
+        if not value or value in self._redaction_values:
+            return
+        self._redaction_values.append(value)
+
+    def _redact(self, msg: str | None) -> str | None:
+        if msg is None:
+            return None
+        redacted = str(msg)
+        for value in sorted(self._redaction_values, key=len, reverse=True):
+            redacted = redacted.replace(value, "***")
+        for pattern in self._COMMON_SECRET_PATTERNS:
+            if pattern.pattern.startswith("(?i)(://"):
+                redacted = pattern.sub(r"\1***\3", redacted)
+            elif "password|passwd|token" in pattern.pattern:
+                redacted = pattern.sub(r"\1\2***", redacted)
+            else:
+                redacted = pattern.sub("***", redacted)
+        return redacted
+
     def _rotate_if_needed(self) -> None:
         try:
             import execsql.state as _state
@@ -701,32 +749,32 @@ class Logger:
         self.writelog(msg)
 
     def log_status_exception(self, msg: str | None) -> None:
-        msg = None if not msg else msg.replace("\n", "")
+        msg = self._redact(None if not msg else msg.replace("\n", ""))
         self.seq_no += 1
         wmsg = f"status\t{self.run_id}\t{self.seq_no}\t{self._ts()}\texception\t{msg or ''}\n"
         self.writelog(wmsg)
 
     def log_status_error(self, msg: str | None) -> None:
-        msg = None if not msg else msg.replace("\n", "")
+        msg = self._redact(None if not msg else msg.replace("\n", ""))
         self.seq_no += 1
         wmsg = f"status\t{self.run_id}\t{self.seq_no}\t{self._ts()}\terror\t{msg or ''}\n"
         self.writelog(wmsg)
 
     def log_status_info(self, msg: str | None) -> None:
-        msg = None if not msg else msg.replace("\n", "")
+        msg = self._redact(None if not msg else msg.replace("\n", ""))
         self.seq_no += 1
         wmsg = f"status\t{self.run_id}\t{self.seq_no}\t{self._ts()}\tinfo\t{msg or ''}\n"
         self.writelog(wmsg)
 
     def log_status_warning(self, msg: str | None) -> None:
-        msg = None if not msg else msg.replace("\n", "")
+        msg = self._redact(None if not msg else msg.replace("\n", ""))
         self.seq_no += 1
         wmsg = f"status\t{self.run_id}\t{self.seq_no}\t{self._ts()}\twarning\t{msg or ''}\n"
         self.writelog(wmsg)
 
     def log_sql_query(self, sql: str, db_name: str, line_no: int | None = None) -> None:
         """Log an executed SQL statement for audit purposes."""
-        cleaned = sql.replace("\n", " ").replace("\t", " ")
+        cleaned = self._redact(sql.replace("\n", " ").replace("\t", " ")) or ""
         if len(cleaned) > 2000:
             cleaned = cleaned[:2000] + "..."
         self.seq_no += 1
@@ -735,7 +783,7 @@ class Logger:
         self.writelog(wmsg)
 
     def log_user_msg(self, msg: str | None) -> None:
-        msg = None if not msg else msg.replace("\n", "")
+        msg = self._redact(None if not msg else msg.replace("\n", ""))
         if msg != "":
             self.seq_no += 1
             wmsg = f"user_msg\t{self.run_id}\t{self.seq_no}\t{self._ts()}\tinfo\t{msg}\n"
@@ -760,14 +808,14 @@ class Logger:
         self.exit_type = "exception"
         self.exit_scriptfile = None
         self.exit_lno = None
-        self.exit_description = msg.replace("\n", "")
+        self.exit_description = self._redact(msg.replace("\n", ""))
 
     def log_exit_error(self, msg: str | None) -> None:
         # Save values to be used by exit() function triggered on program exit
         self.exit_type = "error"
         self.exit_scriptfile = None
         self.exit_lno = None
-        self.exit_description = None if not msg else msg.replace("\n", "")
+        self.exit_description = self._redact(None if not msg else msg.replace("\n", ""))
 
     def log_exit(self) -> None:
         import datetime as _datetime

execsql/utils/gui.py

@@ -19,7 +19,7 @@ their bodies to avoid circular imports.
 from __future__ import annotations
 
 import sys
-from typing import Any
+from typing import Any, cast
 
 __all__ = [
     # Constants
@@ -221,7 +221,7 @@ def gui_console_isrunning() -> bool:
     clicking the Tkinter window's close button).
     """
     if _active_backend is not None:
-        return _active_backend.query_console({}).get("console_running", False)
+        return cast(bool, _active_backend.query_console({}).get("console_running", False))
     return _console_running
 
 
@@ -245,6 +245,7 @@ def enable_gui() -> None:
     # Already initialised — nothing to do.
     if _active_backend is not None:
         return
+    backend: Any
 
     framework = _state.conf.gui_framework if _state.conf else "tkinter"
 
@@ -457,11 +458,12 @@ def _apply_connect_result(alias: str, result: dict) -> None:
     )
 
     db_type = result.get("db_type", "l")
-    server = result.get("server")
-    database = result.get("database")
-    db_file = result.get("db_file")
-    username = result.get("username")
+    server = str(result.get("server") or "")
+    database = str(result.get("database") or "")
+    db_file = str(result.get("db_file") or "")
+    username = str(result.get("username") or "")
 
+    db: Any
     if db_type == "p":
         db = db_Postgres(server, database, user=username, pw_needed=True)
     elif db_type == "s":
@@ -613,7 +615,7 @@ def pause(
     old_settings = termios.tcgetattr(fd)
 
     timer_handler: TimerHandler | None = None
-    old_alarm = signal.SIG_DFL
+    old_alarm: Any = signal.SIG_DFL
 
     try:
         tty.setraw(fd)
@@ -667,6 +669,8 @@ def pause_win(
     """
     try:
         import msvcrt
+
+        msvcrt_mod: Any = msvcrt
     except ImportError:
         # Not on Windows — delegate to the POSIX implementation.
         return pause(text, action=action, countdown=countdown, timeunit=timeunit)
@@ -690,8 +694,8 @@ def pause_win(
                 "{:8.1f}  |{}{}|\r".format(remaining, "+" * bar_left, "-" * (bar_len - bar_left)),
             )
             sys.stdout.flush()
-            if msvcrt.kbhit():
-                ch = msvcrt.getwch()
+            if msvcrt_mod.kbhit():
+                ch = msvcrt_mod.getwch()
                 if ch in ("\r", "\n"):
                     _clear_progress_line()
                     return 0
@@ -703,8 +707,8 @@ def pause_win(
         sys.stderr.write("Press Enter to continue, Esc to quit...\n")
         sys.stderr.flush()
         while True:
-            if msvcrt.kbhit():
-                ch = msvcrt.getwch()
+            if msvcrt_mod.kbhit():
+                ch = msvcrt_mod.getwch()
                 if ch in ("\r", "\n"):
                     return 0
                 if ch == "\x1b":

execsql/utils/mail.py

@@ -17,6 +17,7 @@ from email.mime.base import MIMEBase
 from email.mime.multipart import MIMEMultipart
 from email.mime.text import MIMEText
 from pathlib import Path
+from typing import cast
 
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
@@ -48,6 +49,7 @@ class Mailer:
         self.close()
 
     def __init__(self) -> None:
+        self.smtpconn: smtplib.SMTP
         conf = _state.conf
         if conf.smtp_host is None:
             raise ErrInfo(type="error", other_msg="Can't send email; the email host is not configured.")
@@ -138,14 +140,16 @@ class MailSpec:
         self.sent = False
 
     @staticmethod
-    def _expand(text: str) -> str:
+    def _expand(text: str | None) -> str | None:
         """Expand local and global substitution variables in *text*."""
+        if text is None:
+            return None
         result = text
         localvars = _state.current_localvars()
         if localvars is not None:
             result, _ = localvars.substitute_all(result)
         result, _ = _state.subvars.substitute_all(result)
-        return result
+        return cast(str, result)
 
     def send(self) -> None:
         if self.repeatable or not self.sent:
@@ -153,6 +157,9 @@ class MailSpec:
             send_from = self._expand(self.send_from)
             send_to = self._expand(self.send_to)
             subject = self._expand(self.subject)
+            assert send_from is not None
+            assert send_to is not None
+            assert subject is not None
             msg_content = self._expand(self.msg_content)
             content_filename = self._expand(self.content_filename)
             attach_filename = self._expand(self.attach_filename)

execsql/utils/numeric.py

@@ -45,7 +45,7 @@ def leading_zero_num(dataval: Any) -> bool:
 
 def as_numeric(strval: Any) -> int | float | None:
     # Converts the given value to an int, a float, or None.
-    if type(strval) in (int, float):
+    if isinstance(strval, int | float):
         return strval
     if not isinstance(strval, str):
         strval = str(strval)

execsql/utils/regex.py

@@ -24,7 +24,7 @@ __all__ = [
 ]
 
 
-def ins_rxs(rx_list: tuple, fragment1: object, fragment2: object) -> tuple:
+def ins_rxs(rx_list: tuple[str, ...], fragment1: object, fragment2: object) -> tuple[str, ...]:
     # Returns a tuple of all strings consisting of elements of the 'rx_list' tuple
     # inserted between 'fragment1' and 'fragment2'.  The fragments may themselves
     # be tuples.
@@ -34,7 +34,7 @@ def ins_rxs(rx_list: tuple, fragment1: object, fragment2: object) -> tuple:
         fragment2 = ("",)
     if not isinstance(fragment2, tuple):
         fragment2 = (fragment2,)
-    rv = []
+    rv: list[str] = []
     for te in rx_list:
         for f1 in fragment1:
             for f2 in fragment2:
@@ -42,12 +42,12 @@ def ins_rxs(rx_list: tuple, fragment1: object, fragment2: object) -> tuple:
     return tuple(rv)
 
 
-def ins_quoted_rx(fragment1: object, fragment2: object, rx: str) -> tuple:
+def ins_quoted_rx(fragment1: object, fragment2: object, rx: str) -> tuple[str, ...]:
     return ins_rxs((rx, rf'"{rx}"'), fragment1, fragment2)
 
 
-def ins_schema_rxs(fragment1: object, fragment2: object, suffix: str | None = None) -> tuple:
-    schema_exprs = (
+def ins_schema_rxs(fragment1: object, fragment2: object, suffix: str | None = None) -> tuple[str, ...]:
+    schema_exprs: tuple[str, ...] = (
         r'"(?P<schema>[A-Za-z0-9_\- ]+)"',
         r"(?P<schema>[A-Za-z0-9_\-]+)",
         r"\[(?P<schema>[A-Za-z0-9_\- ]+)\]",
@@ -57,8 +57,8 @@ def ins_schema_rxs(fragment1: object, fragment2: object, suffix: str | None = No
     return ins_rxs(schema_exprs, fragment1, fragment2)
 
 
-def ins_table_rxs(fragment1: object, fragment2: object, suffix: str | None = None) -> tuple:
-    tbl_exprs = (
+def ins_table_rxs(fragment1: object, fragment2: object, suffix: str | None = None) -> tuple[str, ...]:
+    tbl_exprs: tuple[str, ...] = (
         r'(?:"(?P<schema>[A-Za-z0-9_\- ]+)"\.)?"(?P<table>[A-Za-z0-9_\-\# ]+)"',
         r"(?:(?P<schema>[A-Za-z0-9_\-]+)\.)?(?P<table>[A-Za-z0-9_\-\#]+)",
         r'(?:"(?P<schema>[A-Za-z0-9_\- ]+)"\.)?(?P<table>[A-Za-z0-9_\-\#]+)',
@@ -75,7 +75,7 @@ def ins_table_rxs(fragment1: object, fragment2: object, suffix: str | None = Non
     return ins_rxs(tbl_exprs, fragment1, fragment2)
 
 
-def ins_table_list_rxs(fragment1: object, fragment2: object) -> tuple:
+def ins_table_list_rxs(fragment1: object, fragment2: object) -> tuple[str, ...]:
     tbl_exprs = (
         r'(?:(?P<tables>(?:"[A-Za-z0-9_\- ]+"\.)?"[A-Za-z0-9_\-\# ]+"(?:\s*,\s*(?:"[A-Za-z0-9_\- ]+"\.)?"[A-Za-z0-9_\-\# ]+")*))',
         r"(?:(?P<tables>(?:[A-Za-z0-9_\-]+\.)?[A-Za-z0-9_\-\#]+(?:\s*,\s*(?:[A-Za-z0-9_\-]+\.)?[A-Za-z0-9_\-\#]+)*))",
@@ -83,7 +83,7 @@ def ins_table_list_rxs(fragment1: object, fragment2: object) -> tuple:
     return ins_rxs(tbl_exprs, fragment1, fragment2)
 
 
-def ins_fn_rxs(fragment1: object, fragment2: object, symbolicname: str = "filename") -> tuple:
+def ins_fn_rxs(fragment1: object, fragment2: object, symbolicname: str = "filename") -> tuple[str, ...]:
     if os.name == "posix":
         fns = (
             rf"(?P<{symbolicname}>[\w\.\-\\\/\'~`!@#$^&()+={{}}\[\]:;,]*[\w\.\-\\\/\'~`!@#$^&(+={{}}\[\]:;,])",