execsql2 2.24.0__py3-none-any.whl → 2.25.0__py3-none-any.whl

execsql/state.py

@@ -101,6 +101,8 @@ if TYPE_CHECKING:
         SubVarSet,
     )
     from execsql.script.executor import ExecutingStatement
+    from execsql.exceptions import ErrInfo
+    from execsql.manifest import RunManifest
     from execsql.utils.fileio import FileWriter, Logger, TempFileMgr
     from execsql.utils.mail import MailSpec
     from execsql.utils.timer import Timer
@@ -225,6 +227,9 @@ _CONTEXT_ATTRS: frozenset[str] = frozenset(
         "output",
         "filewriter",
         "tier_notices_shown",
+        "manifest",
+        "halt_error",
+        "halt_output_error",
         # Lazy singletons
         "counters",
         "timer",
@@ -280,6 +285,9 @@ class RuntimeContext:
         "output",
         "filewriter",
         "tier_notices_shown",
+        "manifest",
+        "halt_error",
+        "halt_output_error",
         # Lazy singletons
         "counters",
         "timer",
@@ -330,6 +338,12 @@ class RuntimeContext:
         # DBMS names whose best-effort support notice has already been shown,
         # so repeated connections to the same backend announce it only once.
         self.tier_notices_shown: set[str] = set()
+        # ``--manifest`` recorder for this run, or None.
+        self.manifest: RunManifest | None = None
+        # The error that halted this run (set by ``exit_now``), or None.
+        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
 
         # Lazy singletons
         self.counters: CounterVars | None = None
@@ -364,9 +378,7 @@ class RuntimeContext:
         # nesting construct: top-level script, EXECUTE SCRIPT calls, INCLUDE'd
         # files, IF/ELSEIF/ELSE branches, LOOP iterations, BATCH blocks. See
         # :class:`ExecFrame` for frame structure. Read by the debug REPL's
-        # ``.stack`` command and ``DEBUG WRITE COMMANDLISTSTACK`` for genuine
-        # execution context — the legacy ``commandliststack`` only records
-        # SCRIPT call frames and is therefore insufficient for the debugger.
+        # ``.stack`` command and ``DEBUG WRITE COMMANDLISTSTACK``.
         self.ast_exec_stack: list[ExecFrame] = []
 
     # -----------------------------------------------------------------
@@ -552,7 +564,7 @@ def reset() -> None:
     """Reset all mutable state to initial values.
 
     Intended for use in tests.  Creates a fresh :class:`RuntimeContext`,
-    preserving only the ``filewriter`` subprocess (which is ``atexit``-managed
+    preserving only the ``filewriter`` thread (which is ``atexit``-managed
     and must not be discarded while alive).
     """
     ctx = _get_ctx()
@@ -594,8 +606,9 @@ def initialize(
     Note:
         ``subvars``, ``status``, ``output``, ``filewriter``, and ``exec_log``
         are **not** set here because they require CLI-specific arguments
-        (script path, subprocess queues, local class definitions).  Those are
-        assigned directly in ``_run()`` before and after this call.
+        (script path, output settings, local class definitions).  Those are
+        assigned directly in ``_run()`` (or :func:`execsql.api.run`) before
+        and after this call.
     """
     import execsql.db.base as _db_base
     import execsql.exporters.base as _exporters_base
@@ -614,10 +627,11 @@ def initialize(
     ctx.conditionallist = conditional_table
 
     # Discover and register metacommand plugins via entry points.
-    # Runs here (not at import time) to avoid I/O side effects during import.
-    from execsql.plugins import discover_metacommand_plugins
+    # Runs here (not at import time) to avoid I/O side effects during import,
+    # and only once per dispatch table: every run shares the table.
+    from execsql.plugins import register_metacommand_plugins_once
 
-    discover_metacommand_plugins(dispatch_table)
+    register_metacommand_plugins_once(dispatch_table)
 
 
 # ---------------------------------------------------------------------------

execsql/state.pyi

@@ -11,6 +11,8 @@ from execsql.config import ConfigData, StatObj
 from execsql.db.base import DatabasePool
 from execsql.exporters.base import ExportMetadata, WriteSpec
 from execsql.script import CounterVars, MetaCommandList, ScriptExecSpec, SubVarSet
+from execsql.exceptions import ErrInfo
+from execsql.manifest import RunManifest
 from execsql.utils.fileio import FileWriter, Logger, TempFileMgr
 from execsql.utils.mail import MailSpec
 from execsql.utils.timer import Timer
@@ -54,6 +56,9 @@ status: StatObj
 output: Any
 tier_notices_shown: set[str]
 filewriter: FileWriter | None
+manifest: RunManifest | None
+halt_error: ErrInfo | None
+halt_output_error: ErrInfo | None
 counters: CounterVars
 timer: Timer
 dbs: DatabasePool
@@ -89,6 +94,9 @@ class RuntimeContext:
     output: Any
     tier_notices_shown: set[str]
     filewriter: FileWriter | None
+    manifest: RunManifest | None
+    halt_error: ErrInfo | None
+    halt_output_error: ErrInfo | None
     counters: CounterVars | None
     timer: Timer | None
     dbs: DatabasePool | None

execsql/types.py

@@ -180,6 +180,10 @@ class DT_Timestamp(DataType):
         dt = parse_datetime(data)
         if not dt:
             raise DataTypeError(self.data_type_name, self._CONV_ERR % data)
+        # A written UTC offset makes it a timestamptz: stored in a timestamp
+        # column, the driver would shift it by the client's time zone.
+        if isinstance(data, str) and dt.tzinfo is not None:
+            raise DataTypeError(self.data_type_name, self._CONV_ERR % data)
         return dt
 
 
@@ -675,18 +679,6 @@ class DbType:
         # conv_mod_fn is a function that modifies the result of data_type().from_data(x).
         self.dialect[data_type] = (dbms_name, length_required, casting_name, conv_mod_fn, precision, scale)
 
-    def datatype_name(self, data_type: type[DataType]) -> str:
-        """Return the DBMS-specific SQL type name for the given DataType class."""
-        # A convenience function to simplify access to data type names.
-        try:
-            return self.dialect[data_type][0]
-        except Exception as e:
-            raise DbTypeError(
-                self.dbms_id,
-                data_type,
-                f"{self.dbms_id} DBMS type has no specification for data type {data_type.data_type_name}",
-            ) from e
-
     def quoted(self, dbms_object: str) -> str:
         """Quote a database identifier if it contains non-word characters."""
         if re.search(r"\W", dbms_object):
@@ -799,7 +791,24 @@ dbt_sqlserver.name_datatype(DT_Varchar, "varchar", True)
 dbt_sqlserver.name_datatype(DT_Text, "varchar(max)")
 dbt_sqlserver.name_datatype(DT_Binary, "varbinary(max)")
 
-dbt_access = DbType("Access")
+
+class _AccessDbType(DbType):
+    """Access dialect: decimal data becomes DOUBLE unless ``access_use_numeric`` is set.
+
+    Read from the run's config at use time, not applied to the shared
+    ``dt_xlate``, so one run's setting does not carry over to the next
+    ``execsql.run()`` in the same process.
+    """
+
+    def spec_type(self, data_type: type[DataType]) -> type[DataType]:
+        import execsql.state as _state
+
+        if data_type is DT_Decimal and getattr(_state.conf, "access_use_numeric", False):
+            return DT_Decimal
+        return super().spec_type(data_type)
+
+
+dbt_access = _AccessDbType("Access")
 dbt_access.name_datatype(DT_TimestampTZ, "VARCHAR", True)
 dbt_access.name_datatype(DT_Timestamp, "VARCHAR", True)
 dbt_access.name_datatype(DT_Date, "VARCHAR", True)

execsql/utils/auth.py

@@ -12,28 +12,76 @@ the same password is needed again within the same session.
 When the ``keyring`` package is installed, :func:`get_password` checks
 the OS credential store first (macOS Keychain, Windows Credential
 Manager, or Linux SecretService).  If a stored password is found it is
-returned without prompting.  After a successful interactive prompt the
-password is offered for storage in the keyring for future use (console
-mode only; GUI mode stores silently).
+returned without prompting.  A password typed at the prompt is stored
+only once the connection it was typed for succeeds: the adapter calls
+:func:`remember_password` after connecting.
 
-If the stored credential turns out to be stale (e.g. after a password
-change), callers should use :func:`password_from_keyring` to detect
-this, call :func:`clear_stored_password` to remove the bad entry, and
-re-prompt with ``skip_keyring=True``.
+If a stored password is rejected by the server (after a password
+change), callers check :func:`password_from_keyring` and
+:func:`is_login_failure`, call :func:`clear_stored_password`, and
+re-prompt with ``skip_keyring=True``.  Any other connection failure (a
+timeout, a closed port, a missing database) leaves the stored password
+alone and is raised.
 
 Keyring service names follow the pattern
-``execsql/<db_type>/<server_or_file>/<database>``.
+``execsql/<db_type>/<server>:<port>/<database>`` for server databases
+and ``execsql/<db_type>/local/<database>`` otherwise.  An entry stored by
+an earlier version, without the port, is read only for a connection on
+the DBMS's default port, and is saved under the new name once it works.
 """
 
 import getpass
+import threading
 from typing import Any, cast
 
 import execsql.state as _state
+from execsql.utils.fileio import register_secret
 
-__all__ = ["clear_stored_password", "get_password", "is_plaintext_keyring", "password_from_keyring"]
+__all__ = [
+    "begin_login",
+    "clear_stored_password",
+    "get_password",
+    "is_login_failure",
+    "is_plaintext_keyring",
+    "password_from_keyring",
+    "remember_password",
+]
 
-# Tracks whether the most recent get_password() call returned a keyring-stored value.
-_last_from_keyring: bool = False
+
+class _Login(threading.local):
+    """What the connection attempt in progress on this thread looked up.
+
+    Reset by :func:`begin_login` at the start of every attempt, so one
+    connection's answer never stands for another's, and per thread, so
+    concurrent ``execsql.run()`` calls never see each other's.
+    """
+
+    def __init__(self) -> None:
+        # Whether this attempt's get_password() returned a keyring-stored value.
+        self.from_keyring = False
+        # (service, user, password) to store once the connection succeeds: a
+        # password typed at the prompt, or one read under the pre-port name.
+        self.pending_store: tuple[str, str, str] | None = None
+
+
+_login = _Login()
+
+
+def begin_login() -> None:
+    """Start a connection attempt: forget what an earlier attempt looked up.
+
+    Every adapter calls this before deciding whether it needs
+    :func:`get_password`.  A connection handed its password by the caller
+    then never deletes or stores a keyring entry on the strength of an
+    earlier lookup for another server.
+    """
+    _login.from_keyring = False
+    _login.pending_store = None
+
+
+# The port each server DBMS uses when none is given.  Part of the keyring
+# service name, so two servers on one host do not share a stored password.
+_DEFAULT_PORTS = {"PostgreSQL": 5432, "MySQL": 3306, "SQL Server": 1433, "Oracle": 1521, "Firebird": 3050}
 
 # Tracks whether we've already warned about a plaintext keyring backend
 # this process — keyring is a one-shot warning, not a per-call nag.
@@ -81,12 +129,36 @@ def _warn_if_plaintext_keyring() -> None:
         pass
 
 
-def _keyring_service(dbms_name: str, database_name: str, server_name: str | None) -> str:
-    """Build a keyring service name from connection parameters."""
+def _keyring_service(
+    dbms_name: str,
+    database_name: str,
+    server_name: str | None,
+    port: int | None = None,
+) -> str:
+    """Build a keyring service name from connection parameters; a server database's name includes the port."""
     server_part = server_name or "local"
+    if server_name and dbms_name in _DEFAULT_PORTS:
+        server_part = f"{server_name}:{port or _DEFAULT_PORTS[dbms_name]}"
     return f"execsql/{dbms_name}/{server_part}/{database_name}"
 
 
+def _legacy_keyring_service(
+    dbms_name: str,
+    database_name: str,
+    server_name: str | None,
+    port: int | None,
+) -> str | None:
+    """The service name used before the port was part of it, if this connection may read it.
+
+    Such an entry does not say which port it was stored for, so it is only
+    offered to a connection on the DBMS's default port.
+    """
+    default = _DEFAULT_PORTS.get(dbms_name)
+    if not server_name or default is None or (port or default) != default:
+        return None
+    return f"execsql/{dbms_name}/{server_name}/{database_name}"
+
+
 def _keyring_get(service: str, username: str) -> str | None:
     """Try to retrieve a password from the OS keyring.  Returns None on failure."""
     try:
@@ -123,8 +195,8 @@ def _keyring_delete(service: str, username: str) -> bool:
 
 
 def password_from_keyring() -> bool:
-    """Return True if the last :func:`get_password` call used a keyring-stored value."""
-    return _last_from_keyring
+    """Return True if this connection attempt's :func:`get_password` call used a keyring-stored value."""
+    return _login.from_keyring
 
 
 def clear_stored_password(
@@ -132,10 +204,69 @@ def clear_stored_password(
     database_name: str,
     user_name: str,
     server_name: str | None = None,
+    port: int | None = None,
 ) -> bool:
-    """Remove a stored password from the OS keyring.  Returns True on success."""
-    service = _keyring_service(dbms_name, database_name, server_name)
-    return _keyring_delete(service, user_name)
+    """Remove a stored password from the OS keyring, under its current and pre-port names.  True if one was removed."""
+    removed = _keyring_delete(_keyring_service(dbms_name, database_name, server_name, port), user_name)
+    legacy = _legacy_keyring_service(dbms_name, database_name, server_name, port)
+    if legacy is not None:
+        removed = _keyring_delete(legacy, user_name) or removed
+    return removed
+
+
+def remember_password(
+    dbms_name: str,
+    database_name: str,
+    user_name: str,
+    server_name: str | None = None,
+    port: int | None = None,
+) -> None:
+    """Store the password :func:`get_password` typed (or read under the pre-port name) for this connection, now that it works.
+
+    A password typed for a connection that then failed is never stored,
+    even if another connection succeeds afterwards.
+    """
+    pending, _login.pending_store = _login.pending_store, None
+    if pending is not None and pending[:2] == (
+        _keyring_service(dbms_name, database_name, server_name, port),
+        user_name,
+    ):
+        _keyring_set(*pending)
+
+
+# Login failures, by driver: what each reports when the server rejects the
+# user name or password.  PostgreSQL gives no SQLSTATE for a failed
+# connection, so its message is matched.  Anything else (a timeout, a closed
+# port, a missing database) is not a login failure.
+_LOGIN_FAILURE_TEXT = (
+    "password authentication failed",  # PostgreSQL
+    "no password supplied",  # PostgreSQL
+    "ora-01017",  # Oracle: invalid username/password
+    "your user name and password are not defined",  # Firebird
+    "not a valid password",  # Access (DAO)
+)
+_MYSQL_ACCESS_DENIED = 1045
+_ODBC_INVALID_AUTHORIZATION = "28000"
+_ORACLE_INVALID_LOGON = 1017
+
+
+def is_login_failure(exc: BaseException) -> bool:
+    """True if *exc*, or an exception it was raised from, is the server rejecting the credentials."""
+    seen: set[int] = set()
+    current: BaseException | None = exc
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        first = current.args[0] if getattr(current, "args", None) else None
+        if first == _MYSQL_ACCESS_DENIED:  # pymysql: (errno, message)
+            return True
+        if first == _ODBC_INVALID_AUTHORIZATION:  # pyodbc: (SQLSTATE, message)
+            return True
+        if getattr(first, "code", None) == _ORACLE_INVALID_LOGON:  # oracledb / cx_Oracle error object
+            return True
+        if any(text in str(current).lower() for text in _LOGIN_FAILURE_TEXT):
+            return True
+        current = current.__cause__ or current.__context__
+    return False
 
 
 def get_password(
@@ -145,6 +276,7 @@ def get_password(
     server_name: str | None = None,
     other_msg: str | None = None,
     skip_keyring: bool = False,
+    port: int | None = None,
 ) -> str:
     """Prompt the user for a database password, using the GUI if available.
 
@@ -156,22 +288,34 @@ def get_password(
     skip_keyring:
         If True, bypass the keyring lookup and always prompt interactively.
         Useful when a previously stored password is known to be invalid.
+    port:
+        The server's port, part of the keyring entry's name.
+
+    A typed password is not stored here: :func:`remember_password` stores
+    it once the connection succeeds.
     """
-    global _last_from_keyring
     # Deferred imports to avoid circular dependencies at import time.
     from execsql.utils.errors import exit_now
 
-    _last_from_keyring = False
+    _login.from_keyring = False
+    _login.pending_store = None
 
     # --- Keyring lookup (before any prompting) ---
     conf = _state.conf
     use_keyring = conf is None or getattr(conf, "use_keyring", True)
-    service = _keyring_service(dbms_name, database_name, server_name)
+    service = _keyring_service(dbms_name, database_name, server_name, port)
     if use_keyring and not skip_keyring:
         stored = _keyring_get(service, user_name)
+        if stored is None:
+            legacy = _legacy_keyring_service(dbms_name, database_name, server_name, port)
+            if legacy is not None:
+                stored = _keyring_get(legacy, user_name)
+                if stored is not None:
+                    _login.pending_store = (service, user_name, stored)
         if stored is not None:
-            _last_from_keyring = True
+            _login.from_keyring = True
             _state.upass = stored
+            register_secret(stored)
             return stored
 
     script_name = ""
@@ -239,9 +383,10 @@ def get_password(
         passwd = getpass.getpass(str(prompt_text))
 
     _state.upass = passwd
+    register_secret(passwd)
 
-    # --- Offer to store in keyring after interactive prompt ---
+    # --- Stored once the connection succeeds (remember_password) ---
     if use_keyring and passwd:
-        _keyring_set(service, user_name, passwd)
+        _login.pending_store = (service, user_name, passwd)
 
     return passwd

execsql/utils/datetime.py

@@ -8,7 +8,9 @@ raw string data into Python :class:`datetime.datetime` objects.  Used by
 :class:`~execsql.types.DT_Timestamp`, :class:`~execsql.types.DT_TimestampTZ`,
 and related data-type classes when scanning imported data for type inference.
 
-Delegates to ``dateutil.parser.parse()`` for robust, format-agnostic parsing.
+Delegates to ``dateutil.parser.parse()`` for robust, format-agnostic parsing,
+but only accepts a full date: the year written out and nothing filled in from
+today's date.  ``1-2``, ``5/6`` and ``March 5`` are not timestamps.
 """
 
 import datetime
@@ -41,15 +43,56 @@ def _looks_time_only(s: str) -> bool:
     return bool(_TIME_ONLY.match(s.strip()))
 
 
-def parse_datetime(datestr: Any) -> datetime.datetime | None:
+# A year must be written out: four digits, or a two-digit year in the
+# month-first m/d/yy or m-d-yy form.  Without this, dateutil reads "1 2 3" as
+# 2003-01-02 and "3.5.7" as 2007-03-05.
+_FULL_YEAR = re.compile(r"(?<!\d)\d{4}(?!\d)")
+_SHORT_YEAR = re.compile(r"^\s*(?P<month>\d{1,2})(?P<sep>[/-])\d{1,2}(?P=sep)\d{2}(?!\d)")
+
+# dateutil fills fields missing from the string from its ``default``.  Two
+# defaults that differ in year, month and day expose any such filled-in field:
+# the two parses then disagree.
+_DEFAULT_A = datetime.datetime(2001, 1, 1)
+_DEFAULT_B = datetime.datetime(2002, 2, 2)
+
+
+def _parse(datestr: str, strict: bool) -> datetime.datetime | None:
+    """Parse *datestr* with dateutil; when *strict*, only a fully written date."""
+    try:
+        if not strict:
+            return cast(datetime.datetime, _dateutil_parser.parse(datestr))
+        if not _FULL_YEAR.search(datestr):
+            short = _SHORT_YEAR.match(datestr)
+            # Month first only: dateutil would read 13-05-24 day-first,
+            # giving one column two conventions.
+            if short is None or int(short["month"]) > 12:
+                return None
+        a = cast(datetime.datetime, _dateutil_parser.parse(datestr, default=_DEFAULT_A))
+        b = cast(datetime.datetime, _dateutil_parser.parse(datestr, default=_DEFAULT_B))
+    except (ValueError, OverflowError, TypeError):
+        return None
+    if (a.year, a.month, a.day) != (b.year, b.month, b.day):
+        return None
+    return a
+
+
+def parse_datetime(datestr: Any, *, strict: bool = True) -> datetime.datetime | None:
     """Parse a date/time string into a :class:`datetime.datetime`.
 
-    Accepts any format recognised by ``dateutil.parser.parse()``, including
-    ISO 8601, US date formats (month-first), European formats, and natural
-    language month names.  Returns ``None`` if the input cannot be parsed.
+    Accepts formats recognised by ``dateutil.parser.parse()``, including
+    ISO 8601, US date formats (month-first), European formats, and month
+    names.  Returns ``None`` if the input cannot be parsed.
+
+    With *strict* (the default, used for type inference and import), the
+    string must give a full date: a four-digit year (or month-first
+    ``m/d/yy`` / ``m-d-yy``) and a month and day, none filled in from
+    today's date.  ``"1-2"``, ``"5/6"``,
+    ``"March 5"`` and ``"Monday"`` return ``None``.  Pass ``strict=False``
+    for a date a user typed into a metacommand, where today's date is a
+    reasonable default.
 
-    Bare numeric strings (e.g. ``"1"``, ``"42"``, ``"2024"``) are rejected
-    to prevent type-inference false positives.
+    Bare numeric strings (e.g. ``"1"``, ``"42"``, ``"2024"``) and time-only
+    strings are always rejected to prevent type-inference false positives.
 
     If *datestr* is already a :class:`datetime.datetime`, it is returned as-is.
     Non-string inputs are stringified before parsing.
@@ -65,10 +108,7 @@ def parse_datetime(datestr: Any) -> datetime.datetime | None:
         return None
     if _looks_time_only(datestr):
         return None
-    try:
-        return cast(datetime.datetime, _dateutil_parser.parse(datestr))
-    except (ValueError, OverflowError, TypeError):
-        return None
+    return _parse(datestr, strict)
 
 
 def parse_datetimetz(data: Any) -> datetime.datetime | None:
@@ -79,7 +119,8 @@ def parse_datetimetz(data: Any) -> datetime.datetime | None:
     ``-0700``) and named timezones (``UTC``, ``EST``, etc.).
 
     If *data* is already a timezone-aware :class:`datetime.datetime`, it is
-    returned as-is.  Naive datetimes return ``None``.
+    returned as-is.  Naive datetimes return ``None``.  Like
+    :func:`parse_datetime`, only a full date is accepted.
     """
     if isinstance(data, datetime.datetime):
         if data.tzinfo is None or data.tzinfo.utcoffset(data) is None:
@@ -89,10 +130,7 @@ def parse_datetimetz(data: Any) -> datetime.datetime | None:
         return None
     if _looks_numeric(data):
         return None
-    try:
-        dt = cast(datetime.datetime, _dateutil_parser.parse(data))
-    except (ValueError, OverflowError, TypeError):
-        return None
-    if dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None:
+    dt = _parse(data, strict=True)
+    if dt is None or dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None:
         return None
     return dt