execsql2 2.28.0__py3-none-any.whl → 2.30.0__py3-none-any.whl

execsql/manifest.py

@@ -10,7 +10,11 @@ Files are recorded as the executor runs each metacommand, after variable
 substitution, so paths are the ones actually used. What a metacommand touches
 is decided by :mod:`execsql.metacommands.effects`. Variable values and passwords are never written:
 the run log hides ``-a`` and ``--var`` values because they can be secrets, and
-the manifest lists only their names.
+the manifest lists only their names. A password or decrypted value that reaches
+a path, a connection target or an error message is written as ``***``, as are
+common secret shapes (a URL's password, ``password=...``, API tokens). ``-a`` and
+``--var`` values, which the log also masks, are kept: they are usually part of
+the paths the manifest exists to report.
 
 One recorder is active per run; :func:`current` returns it, or ``None`` when
 no manifest was asked for, so the executor's hooks cost one check. Writing the
@@ -81,6 +85,22 @@ def _now() -> datetime.datetime:
     return datetime.datetime.now(tz=datetime.timezone.utc)
 
 
+def _masked(value: Any) -> Any:
+    """*value* with the run's passwords and common secret shapes replaced by ``***`` in every string it holds.
+
+    ``-a`` / ``--var`` values are left in place; times, counts and line numbers are not strings.
+    """
+    from execsql.utils.fileio import redact
+
+    if isinstance(value, str):
+        return redact(value, arguments=False)
+    if isinstance(value, list):
+        return [_masked(item) for item in value]
+    if isinstance(value, dict):
+        return {key: _masked(item) for key, item in value.items()}
+    return value
+
+
 class RunManifest:
     """Collects what one run does and writes it as JSON when the run ends."""
 
@@ -166,20 +186,20 @@ class RunManifest:
         finished = _now()
         data = {
             "execsql_version": __version__,
-            "script": self.script,
+            "script": _masked(self.script),
             "started": self.started.isoformat(timespec="seconds"),
             "finished": finished.isoformat(timespec="seconds"),
             "duration_s": round((finished - self.started).total_seconds(), 3),
             "exit_status": exit_status,
-            "config_files": self.config_files,
-            "database": self.database,
+            "config_files": _masked(self.config_files),
+            "database": _masked(self.database),
             "variables": self.variables,
             "statements": {"sql": self.sql_statements, "metacommands": self.metacommands},
-            "files_read": self.reads,
-            "files_written": self.writes,
-            "files_deleted": self.deletes,
-            "connections": self.connections,
-            "errors": self.errors,
+            "files_read": _masked(self.reads),
+            "files_written": _masked(self.writes),
+            "files_deleted": _masked(self.deletes),
+            "connections": _masked(self.connections),
+            "errors": _masked(self.errors),
         }
         self.written = True
         import execsql.state as _state

execsql/metacommands/__init__.py

@@ -242,7 +242,6 @@ from execsql.metacommands.system import (
 # Regex helper functions (from utils/regex.py)
 from execsql.utils.regex import (
     ins_rxs,
-    ins_quoted_rx,
     ins_schema_rxs,
     ins_table_rxs,
     ins_table_list_rxs,
@@ -443,7 +442,6 @@ __all__ = [
     "x_pg_upsert_qa",
     # regex helpers
     "ins_rxs",
-    "ins_quoted_rx",
     "ins_schema_rxs",
     "ins_table_rxs",
     "ins_table_list_rxs",

execsql/metacommands/io_fileops.py

@@ -307,6 +307,11 @@ def x_cd(**kwargs: Any) -> None:
             command_text=kwargs["metacommandline"],
             other_msg="Directory does not exist",
         )
+    if _state.cd_from is None:
+        try:
+            _state.cd_from = os.getcwd()
+        except OSError:  # the directory is gone: nowhere to return to
+            pass
     os.chdir(new_dir)
     script, lno = current_script_line()
     _state.exec_log.log_status_info(f"Current directory changed to {new_dir} at line {lno} of {script}")

execsql/script/executor.py

@@ -957,16 +957,15 @@ class ExecutingStatement:
     rather than copying fields out of it, so there is nothing to keep in sync
     and no second source of truth about what is executing.  Error reporting
     (:mod:`execsql.utils.errors`), the debug REPL, and ``api.run()`` read
-    these five attributes; everything is derived from ``node`` on access, so
+    its attributes; everything is derived from ``node`` on access, so
     constructing one costs a single small object per statement rather than
     the two classes the previous shim built each time.
     """
 
-    __slots__ = ("node", "_source_dir")
+    __slots__ = ("node",)
 
     def __init__(self, node: Node) -> None:
         self.node = node
-        self._source_dir: str | None = None
 
     @property
     def source(self) -> str:
@@ -976,18 +975,6 @@ class ExecutingStatement:
     def line_no(self) -> int:
         return self.node.span.start_line
 
-    @property
-    def source_name(self) -> str:
-        return Path(self.node.span.file).name
-
-    @property
-    def source_dir(self) -> str:
-        # resolve() touches the filesystem, so it is done once per statement
-        # object rather than on every read.
-        if self._source_dir is None:
-            self._source_dir = str(Path(self.node.span.file).resolve().parent) + os.sep
-        return self._source_dir
-
     @property
     def command_type(self) -> str:
         return "sql" if isinstance(self.node, SqlStatement) else "cmd"
@@ -1004,12 +991,6 @@ class ExecutingStatement:
     def __repr__(self) -> str:
         return f"ExecutingStatement({self.source}:{self.line_no}, {self.command_type})"
 
-    def current_script_line(self) -> tuple[str, int]:
-        return (self.source, self.line_no)
-
-    def commandline(self) -> str:
-        return cast(str, self.command.commandline())
-
 
 # ---------------------------------------------------------------------------
 # Node type/text helpers for profiling

execsql/script/variables.py

@@ -17,6 +17,42 @@ from execsql.exceptions import ErrInfo
 __all__ = ["CounterVars", "SubVarSet", "LocalSubVarSet", "ScriptArgSubVarSet"]
 
 
+def _after_escape_string_prefix(command: str, start: int) -> bool:
+    """Whether the ``!'!`` token at *start* follows an ``E`` that makes it a PostgreSQL escape string (``E!'!v!'!``).
+
+    The ``E`` must stand alone: in ``TYPE!'!v!'!`` it ends a word.
+    """
+    if start < 1 or command[start - 1] not in "Ee":
+        return False
+    return start < 2 or not (command[start - 2].isalnum() or command[start - 2] == "_")
+
+
+def _sql_string_literal(value: str, *, escape_string: bool = False) -> str:
+    """*value* as the string literal ``!'!var!'!`` substitutes, in the current connection's form.
+
+    An apostrophe is doubled everywhere; a backslash only where the DBMS
+    reads it as an escape (MySQL/MariaDB), or inside an escape string the
+    script wrote as ``E!'!var!'!`` (*escape_string*), so ``C:\\data`` is
+    stored as written in every case.  Without a connection, the standard SQL
+    form.  (Upstream doubled backslashes only on Windows, to protect
+    ``re.sub``'s replacement template, not the SQL.)
+    """
+    if escape_string:
+        return "'" + value.replace("\\", "\\\\").replace("'", "''") + "'"
+    db = None
+    try:
+        import execsql.state as _state
+
+        dbs = _state.dbs
+        if dbs is not None and dbs.current_db is not None:
+            db = dbs.current()
+    except Exception:
+        db = None
+    if db is not None:
+        return db.quote_literal(value)
+    return "'" + value.replace("'", "''") + "'"
+
+
 # ---------------------------------------------------------------------------
 # CounterVars
 # ---------------------------------------------------------------------------
@@ -253,13 +289,10 @@ class SubVarSet:
                     )
                 quote = m.group("q")
                 if quote == "'":
-                    # B07a/F002: wrap in single quotes, doubling embedded
-                    # apostrophes AND escaping backslashes so MySQL default
-                    # mode and PostgreSQL E-string literals can't end the
-                    # quoted region via ``\'``. The previous Windows-only
-                    # branch (``os.name != 'posix'``) applied the escape on
-                    # the wrong axis — host OS vs target DBMS.
-                    sub = "'" + sub.replace("\\", "\\\\").replace("'", "''") + "'"
+                    sub = _sql_string_literal(
+                        sub,
+                        escape_string=_after_escape_string_prefix(command_str, m.start()),
+                    )
                 elif quote == '"':
                     # B07a/F001: wrap in double quotes, doubling embedded
                     # ``"`` so a value containing ``"; DROP TABLE x; --``
@@ -306,13 +339,12 @@ class SubVarSet:
             if idx != -1:
                 _check_nul(varname, sub)
                 return command_str[:idx] + sub + command_str[idx + len(token) :], True
-            # Single-quote-wrapped token: !'!varname!'! — escape ``\`` and
-            # double embedded ``'`` (see substitute_one for rationale).
+            # Single-quote-wrapped token: !'!varname!'! — a string literal.
             tokenq = f"!'!{varname}!'!"
             idxq = cmd_lower.find(tokenq)
             if idxq != -1:
                 _check_nul(varname, sub)
-                wrapped = "'" + sub.replace("\\", "\\\\").replace("'", "''") + "'"
+                wrapped = _sql_string_literal(sub, escape_string=_after_escape_string_prefix(command_str, idxq))
                 return (
                     command_str[:idxq] + wrapped + command_str[idxq + len(tokenq) :],
                     True,

execsql/state.py

@@ -89,8 +89,6 @@ class ExecFrame:
 
 
 if TYPE_CHECKING:
-    import multiprocessing as _mp
-
     from execsql.config import ConfigData, StatObj, WriteHooks
     from execsql.db.base import DatabasePool
     from execsql.exporters.base import ExportMetadata, WriteSpec
@@ -230,6 +228,7 @@ _CONTEXT_ATTRS: frozenset[str] = frozenset(
         "manifest",
         "halt_error",
         "halt_output_error",
+        "cd_from",
         # Lazy singletons
         "counters",
         "timer",
@@ -288,6 +287,7 @@ class RuntimeContext:
         "manifest",
         "halt_error",
         "halt_output_error",
+        "cd_from",
         # Lazy singletons
         "counters",
         "timer",
@@ -344,6 +344,9 @@ class RuntimeContext:
         self.halt_error: ErrInfo | None = None
         # File output lost when the run halted (set by ``exit_now``), or None.
         self.halt_output_error: ErrInfo | None = None
+        # The working directory before this run's first CD, or None: the
+        # library's run() returns its caller there.
+        self.cd_from: str | None = None
 
         # Lazy singletons
         self.counters: CounterVars | None = None
@@ -356,7 +359,7 @@ class RuntimeContext:
 
         # GUI
         self.gui_console: Any = None
-        self.gui_manager_queue: _mp.Queue | None = None
+        self.gui_manager_queue: Any = None  # a queue.Queue or a _TkinterSyncQueue; only put() is used
         self.gui_manager_thread: threading.Thread | None = None
 
         # Profiling — None means profiling is disabled; a list means it is enabled.

execsql/state.pyi

@@ -59,6 +59,7 @@ filewriter: FileWriter | None
 manifest: RunManifest | None
 halt_error: ErrInfo | None
 halt_output_error: ErrInfo | None
+cd_from: str | None
 counters: CounterVars
 timer: Timer
 dbs: DatabasePool
@@ -97,6 +98,7 @@ class RuntimeContext:
     manifest: RunManifest | None
     halt_error: ErrInfo | None
     halt_output_error: ErrInfo | None
+    cd_from: str | None
     counters: CounterVars | None
     timer: Timer | None
     dbs: DatabasePool | None

execsql/types.py

@@ -884,6 +884,14 @@ dbt_oracle.name_datatype(DT_TimestampTZ, "TIMESTAMP WITH TIME ZONE")
 dbt_oracle.name_datatype(DT_Timestamp, "TIMESTAMP", casting_name="TIMESTAMP")
 dbt_oracle.name_datatype(DT_Date, "DATE", casting_name="DATE")
 dbt_oracle.name_datatype(DT_Time_Oracle, "VARCHAR2", True, casting_name="VARCHAR(20)")
+# Oracle has no time-of-day type, and oracledb cannot bind a datetime.time: a
+# time column is stored as its ISO text (at most 15 characters, HH:MM:SS.ffffff).
+dbt_oracle.name_datatype(
+    DT_Time,
+    "VARCHAR2(15)",
+    casting_name="VARCHAR(20)",
+    conv_mod_fn=lambda x: x.isoformat() if x is not None else None,
+)
 dbt_oracle.name_datatype(DT_Integer, "NUMBER")
 dbt_oracle.name_datatype(DT_Long, "NUMBER")
 dbt_oracle.name_datatype(DT_Float, "FLOAT")

execsql/utils/errors.py

@@ -6,8 +6,6 @@ Error handling and reporting utilities for execsql.
 Provides the functions that form the error-reporting pipeline used
 throughout the codebase:
 
-- :func:`exception_info` — extracts type, value, and source location
-  from the current exception.
 - :func:`exception_desc` — ``Type: message`` for the exception being
   handled, as shown on screen.
 - :func:`error_origin` / :func:`logged_error` — where in execsql an error
@@ -28,7 +26,6 @@ import execsql.state as _state
 from execsql.exceptions import ErrInfo
 
 __all__ = [
-    "exception_info",
     "error_origin",
     "exception_desc",
     "logged_error",
@@ -56,43 +53,29 @@ def install_hint(extra: str) -> str:
     )
 
 
-def exception_info() -> tuple:
-    # Returns the exception type, value, source file name, source line number, and source line text.
-    strace = traceback.extract_tb(sys.exc_info()[2])[-1:]
-    traces = traceback.extract_tb(sys.exc_info()[2])
-    xline = 0
-    for trace in traces:
-        if "execsql" in trace[0]:
-            xline = trace[1]
-    exc_message = ""
-    exc_param = sys.exc_info()[1]
-    if isinstance(exc_param, str):
-        exc_message = exc_param
-    elif exc_param is not None:
-        message = getattr(exc_param, "message", None)
-        value = getattr(exc_param, "value", None)
-        if isinstance(message, str) and len(message) > 0:
-            exc_message = message
-        elif isinstance(value, str) and len(value) > 0:
-            exc_message = value
-        else:
-            exc_message = str(exc_param)
-    try:
-        exc_message = str(exc_message)
-    except Exception:
-        exc_message = repr(exc_message)
-    xinfo = sys.exc_info()[0]
-    xname = getattr(xinfo, "__name__", "")
-    return xname, exc_message, strace[0][0], xline, strace[0][3]
-
-
 def exception_desc() -> str:
     """``Type: message`` for the exception being handled, as shown to the person running the script.
 
-    Where in execsql it was raised is for the log: see :func:`error_origin`.
+    The message is the exception's ``message`` or ``value`` attribute when it
+    has a non-empty string one (as some drivers' exceptions do), else its
+    ``str()``.  Where in execsql it was raised is for the log: see
+    :func:`error_origin`.
     """
-    exc_type, exc_strval, _filename, _lineno, _linetext = exception_info()
-    return f"{exc_type}: {exc_strval}"
+    exc_type, exc = sys.exc_info()[:2]
+    if isinstance(exc, str):
+        message = exc
+    elif exc is None:
+        message = ""
+    else:
+        attr = next(
+            (v for v in (getattr(exc, "message", None), getattr(exc, "value", None)) if isinstance(v, str) and v),
+            None,
+        )
+        try:
+            message = attr if attr is not None else str(exc)
+        except Exception:
+            message = repr(exc)
+    return f"{getattr(exc_type, '__name__', '')}: {message}"
 
 
 def error_origin(exc: BaseException) -> str | None:

execsql/utils/fileio.py

@@ -34,7 +34,6 @@ import threading
 import time
 import weakref
 from collections.abc import Callable
-from encodings.aliases import aliases as codec_dict
 from typing import Any, NamedTuple, cast
 
 from execsql.exceptions import ErrInfo
@@ -47,14 +46,11 @@ __all__ = [
     "EncodedFile",
     "Logger",
     "TempFileMgr",
-    "list_encodings",
     "filewriter_filestatus",
     "filewriter_write",
     "filewriter_open_as_new",
     "filewriter_close",
     "filewriter_close_all_after_write",
-    "filewriter_closeall",
-    "filewriter_shutdown",
     "filewriter_end",
     "redact",
     "register_secret",
@@ -216,9 +212,8 @@ class FileWriter(threading.Thread):
         CMD_OPEN_AS_NEW,
         CMD_CLOSE_ALL_AFTER_WRITE,
         CMD_CLOSED_STATUS,
-        CMD_PING,
         CMD_OPEN_FAILURES,
-    ) = range(10)
+    ) = range(9)
 
     class FileControl:
         STATUS_OPEN, STATUS_WAITING, STATUS_UNOPENED, STATUS_CLOSED, STATUS_OPENFAILURE, STATUS_WRITEFAILURE = range(6)
@@ -375,7 +370,6 @@ class FileWriter(threading.Thread):
             self.open_as_new,
             self.close_all_after_write,
             self.closed_status,
-            self.ping,
             self.open_failures,
         )
 
@@ -417,10 +411,6 @@ class FileWriter(threading.Thread):
             if fc.status != self.FileControl.STATUS_CLOSED and fc.status not in fc.FAILED:
                 self._on_file(fc, fc.clean_close)
 
-    def ping(self, token: object) -> None:
-        """Echo *token* back on the return queue — used to synchronize callers."""
-        self.return_msg_queue.put(token)
-
     def retry_waiting(self) -> None:
         """Re-attempt opening every file still waiting on a lock.
 
@@ -526,7 +516,7 @@ class FileWriter(threading.Thread):
         the rest, so one bad command cannot stop the thread (and with it
         every later write, to any file).
         """
-        filename = argtuple[0] if command != self.CMD_PING and argtuple and isinstance(argtuple[0], str) else ""
+        filename = argtuple[0] if argtuple and isinstance(argtuple[0], str) else ""
         lost = LostOutput(filename, 0, str(exc), "writer")
         if command == self.CMD_OPEN_FAILURES:
             self.return_msg_queue.put([lost])
@@ -535,7 +525,6 @@ class FileWriter(threading.Thread):
         replies: dict[int, Any] = {
             self.CMD_GET_STATUS: self.FileControl.STATUS_CLOSED,
             self.CMD_CLOSED_STATUS: self.FileControl.STATUS_CLOSED,
-            self.CMD_PING: argtuple[0] if argtuple else None,
         }
         if command in replies:
             self.return_msg_queue.put(replies[command])
@@ -745,20 +734,6 @@ def _lost_output_message(lost: LostOutput, open_timeout: int) -> str:
     return f"{cause}; {lost.dropped} line(s) of output to it were discarded" if lost.dropped else cause
 
 
-def filewriter_closeall() -> None:
-    fw = _active_writer()
-    if fw is None:
-        return
-    fw.input_queue.put((FileWriter.CMD_CLOSE_ALL, ()))
-
-
-def filewriter_shutdown() -> None:
-    fw = _active_writer()
-    if fw is None:
-        return
-    fw.input_queue.put((FileWriter.CMD_SHUTDOWN, ()))
-
-
 def filewriter_end(writer: FileWriter | None = None) -> None:
     """Close every file and stop *writer*, or the active run's writer if omitted.
 
@@ -894,6 +869,8 @@ class Logger:
         self.server_name = server_name
         self.cmdline_options = cmdline_options
         self._redaction_values: list[str] = []
+        # Of those, the -a / --var values: masked in the log, not in the manifest.
+        self._argument_values: set[str] = set()
         if log_file_name:
             self.log_file_name = log_file_name
         else:
@@ -956,9 +933,9 @@ class Logger:
         )
         self.writelog(self._redact(msg) or "")
         if server_name:
-            msg = f"run_db_server\t{self.run_id}\t{server_name}\t{db_name}\n"
+            msg = f"run_db_server\t{self.run_id}\t{self._redact(server_name)}\t{self._redact(db_name)}\n"
         else:
-            msg = f"run_db_file\t{self.run_id}\t{db_name}\n"
+            msg = f"run_db_file\t{self.run_id}\t{self._redact(db_name)}\n"
         self.writelog(msg)
         self.seq_no = 0
         atexit.register(self.close)
@@ -974,20 +951,41 @@ class Logger:
 
         return _datetime.datetime.now().isoformat(timespec="seconds")
 
-    def add_redaction_value(self, value: str | None) -> None:
+    def add_redaction_value(self, value: str | None, *, argument: bool = False) -> None:
+        """Mask *value* in every later log record.
+
+        *argument* marks an ``-a`` / ``--var`` value: it may be a secret, so
+        the log masks it, but it is just as often part of a path, so the
+        ``--manifest`` JSON (``redact(..., arguments=False)``) does not.  A
+        value registered both ways is a secret.
+        """
         if value is None:
             return
         value = str(value)
-        if not value or value in self._redaction_values:
+        if not value:
+            return
+        if not argument:
+            self._argument_values.discard(value)
+        if value in self._redaction_values:
             return
         self._redaction_values.append(value)
+        if argument:
+            self._argument_values.add(value)
+
+    def _redact(self, msg: str | None, *, arguments: bool = True) -> str | None:
+        """*msg* with registered secrets and common secret shapes replaced by ``***``.
 
-    def _redact(self, msg: str | None) -> str | None:
+        Every record applies it to its free-text fields (messages, names,
+        paths), never to a whole line: a registered value can be as short as
+        a ``-a 2024`` argument, which would otherwise mask timestamps and
+        sequence numbers.
+        """
         if msg is None:
             return None
         redacted = str(msg)
         for value in sorted(self._redaction_values, key=len, reverse=True):
-            redacted = redacted.replace(value, "***")
+            if arguments or value not in self._argument_values:
+                redacted = redacted.replace(value, "***")
         for pattern in self._COMMON_SECRET_PATTERNS:
             if pattern.pattern.startswith("(?i)(://"):
                 redacted = pattern.sub(r"\1***\3", redacted)
@@ -1026,12 +1024,13 @@ class Logger:
 
     def log_db_connect(self, db: Any) -> None:
         self.seq_no += 1
-        msg = f"connect\t{self.run_id}\t{self.seq_no}\t{self._ts()}\t{db.name()}\n"
+        msg = f"connect\t{self.run_id}\t{self.seq_no}\t{self._ts()}\t{self._redact(db.name())}\n"
         self.writelog(msg)
 
     def log_action_export(self, line_no: int, query_name: str, export_file_name: str) -> None:
         self.seq_no += 1
-        msg = f"action\t{self.run_id}\t{self.seq_no}\t{self._ts()}\texport\t{line_no}\tQuery {query_name} exported to {export_file_name}\n"
+        description = self._redact(f"Query {query_name} exported to {export_file_name}")
+        msg = f"action\t{self.run_id}\t{self.seq_no}\t{self._ts()}\texport\t{line_no}\t{description}\n"
         self.writelog(msg)
 
     def log_status_exception(self, msg: str | None) -> None:
@@ -1087,7 +1086,7 @@ class Logger:
         self.exit_type = "halt"
         self.exit_scriptfile = script_file_name
         self.exit_lno = line_no
-        self.exit_description = msg
+        self.exit_description = None if not msg else msg.replace("\n", "")
 
     def log_exit_interrupted(self) -> None:
         # Save values to be used by exit() function triggered on program exit
@@ -1121,9 +1120,9 @@ class Logger:
         wmsg = "exit\t{}\t{}\t{}({})\t{}\t{:.1f}s\n".format(
             self.run_id,
             self.exit_type,
-            self.exit_scriptfile or "",
+            self._redact(self.exit_scriptfile) or "",
             str(self.exit_lno or ""),
-            self.exit_description or "",
+            self._redact(self.exit_description) or "",  # a HALT MESSAGE can hold any variable's value
             elapsed,
         )
         self.writelog(wmsg)
@@ -1144,12 +1143,16 @@ def register_secret(value: str | None) -> None:
         add(value)
 
 
-def redact(text: str) -> str:
-    """*text* with the active run's registered secrets and common secret shapes replaced by ``***``."""
+def redact(text: str, *, arguments: bool = True) -> str:
+    """*text* with the active run's registered secrets and common secret shapes replaced by ``***``.
+
+    With *arguments* false, ``-a`` / ``--var`` values are left as they are
+    (see :meth:`Logger.add_redaction_value`).
+    """
     import execsql.state as _state
 
     redactor = getattr(_state.exec_log, "_redact", None)
-    return redactor(text) if redactor is not None else text
+    return (redactor(text, arguments=arguments) or "") if redactor is not None else text
 
 
 class TempFileMgr:
@@ -1188,10 +1191,3 @@ _live_tempfile_mgrs: weakref.WeakSet[TempFileMgr] = weakref.WeakSet()
 def _remove_all_temp_files() -> None:
     for mgr in list(_live_tempfile_mgrs):
         mgr.remove_all()
-
-
-def list_encodings() -> None:
-    enc = list(codec_dict.keys())
-    enc.sort()
-    msg = f"Encodings: {', '.join(enc)}\n"
-    print(msg)

execsql/utils/regex.py

@@ -16,7 +16,6 @@ import os
 
 __all__ = [
     "ins_rxs",
-    "ins_quoted_rx",
     "ins_schema_rxs",
     "ins_table_rxs",
     "ins_table_list_rxs",
@@ -42,10 +41,6 @@ def ins_rxs(rx_list: tuple[str, ...], fragment1: object, fragment2: object) -> t
     return tuple(rv)
 
 
-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[str, ...]:
     schema_exprs: tuple[str, ...] = (
         r'"(?P<schema>[A-Za-z0-9_\- ]+)"',

{execsql2-2.28.0.dist-info → execsql2-2.30.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.28.0
+Version: 2.30.0
 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
@@ -83,7 +83,6 @@ Provides-Extra: auth-plaintext
 Requires-Dist: keyring>=25.0; extra == 'auth-plaintext'
 Requires-Dist: keyrings-alt>=5.0; extra == 'auth-plaintext'
 Provides-Extra: dev
-Requires-Dist: build>=1.2.2.post1; extra == 'dev'
 Requires-Dist: bump-my-version>=1.2.7; extra == 'dev'
 Requires-Dist: defusedxml>=0.7; extra == 'dev'
 Requires-Dist: jinja2>=3.1; extra == 'dev'
@@ -104,7 +103,6 @@ Requires-Dist: ruff>=0.4; extra == 'dev'
 Requires-Dist: sqlglot<30.22,>=30.21.0; extra == 'dev'
 Requires-Dist: tables>=3.10; extra == 'dev'
 Requires-Dist: tox-uv>=1.13.1; extra == 'dev'
-Requires-Dist: twine>=6.1.0; extra == 'dev'
 Requires-Dist: xlrd>=2.0; extra == 'dev'
 Requires-Dist: zensical==0.0.67; extra == 'dev'
 Provides-Extra: duckdb
@@ -466,7 +464,7 @@ execsql format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.28.0
+    rev: v2.30.0
     hooks:
       - id: execsql-format
       - id: execsql-lint