execsql2 2.0.1__py3-none-any.whl → 2.1.2__py3-none-any.whl

execsql/utils/errors.py

@@ -15,12 +15,12 @@ throughout the codebase:
 - :func:`fatal_error` — logs a fatal error and calls :func:`exit_now`.
 """
 
-import datetime
 import os
 import sys
 import time
 import traceback
-from typing import Any, Optional
+from pathlib import Path
+from typing import Any
 
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
@@ -59,7 +59,7 @@ def exception_desc() -> str:
     return f"{exc_type}: {exc_strval} in {exc_filename} on line {exc_lineno} of execsql."
 
 
-def exit_now(exit_status: int, errinfo: Optional[ErrInfo], logmsg: Optional[str] = None) -> None:
+def exit_now(exit_status: int, errinfo: ErrInfo | None, logmsg: str | None = None) -> None:
     em = None
     if errinfo is not None:
         em = errinfo.write()
@@ -67,18 +67,19 @@ def exit_now(exit_status: int, errinfo: Optional[ErrInfo], logmsg: Optional[str]
             try:
                 _state.err_halt_writespec.write()
             except Exception:
-                _state.exec_log.log_status_error("Failed to write the ON ERROR_HALT WRITE message.")
-    if exit_status == 2:
-        # User canceled
-        if _state.cancel_halt_writespec is not None:
-            try:
-                _state.cancel_halt_writespec.write()
-            except Exception:
+                if _state.exec_log is not None:
+                    _state.exec_log.log_status_error("Failed to write the ON ERROR_HALT WRITE message.")
+    # User canceled
+    if exit_status == 2 and _state.cancel_halt_writespec is not None:
+        try:
+            _state.cancel_halt_writespec.write()
+        except Exception:
+            if _state.exec_log is not None:
                 _state.exec_log.log_status_error("Failed to write the ON CANCEL_HALT WRITE message.")
     # Defer import to avoid circular dependencies
     from execsql.utils.gui import gui_console_isrunning, gui_console_wait_user, gui_console_off
 
-    if gui_console_isrunning():
+    if gui_console_isrunning() and _state.conf is not None:
         if errinfo is not None:
             if _state.conf.gui_wait_on_error_halt:
                 gui_console_wait_user("Script error; close the console window to exit execsql.")
@@ -92,31 +93,36 @@ def exit_now(exit_status: int, errinfo: Optional[ErrInfo], logmsg: Optional[str]
         try:
             _state.err_halt_email.send()
         except Exception:
-            _state.exec_log.log_status_error("Failed to send the ON ERROR_HALT EMAIL message.")
+            if _state.exec_log is not None:
+                _state.exec_log.log_status_error("Failed to send the ON ERROR_HALT EMAIL message.")
     if errinfo is not None and _state.err_halt_exec is not None:
+        from execsql.script import runscripts  # deferred: errors.py ↔ script.py circular dep
+
         errexec = _state.err_halt_exec
         _state.err_halt_exec = None
         _state.commandliststack = []
         errexec.execute()
-        _state.runscripts()
+        runscripts()
     if exit_status == 2 and _state.cancel_halt_mailspec is not None:
         try:
             _state.cancel_halt_mailspec.send()
         except Exception:
-            _state.exec_log.log_status_error("Failed to send the ON CANCEL_HALT EMAIL message.")
+            if _state.exec_log is not None:
+                _state.exec_log.log_status_error("Failed to send the ON CANCEL_HALT EMAIL message.")
     if exit_status == 2 and _state.cancel_halt_exec is not None:
+        from execsql.script import runscripts  # deferred: errors.py ↔ script.py circular dep
+
         cancelexec = _state.cancel_halt_exec
         _state.cancel_halt_exec = None
         _state.commandliststack = []
         cancelexec.execute()
-        _state.runscripts()
-    if exit_status > 0:
-        if _state.exec_log:
-            if logmsg:
-                _state.exec_log.log_exit_error(logmsg)
-            else:
-                if em:
-                    _state.exec_log.log_exit_error(em)
+        runscripts()
+    if exit_status > 0 and _state.exec_log:
+        if logmsg:
+            _state.exec_log.log_exit_error(logmsg)
+        else:
+            if em:
+                _state.exec_log.log_exit_error(em)
     if _state.exec_log is not None:
         _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
         _state.exec_log.close()
@@ -126,19 +132,20 @@ def exit_now(exit_status: int, errinfo: Optional[ErrInfo], logmsg: Optional[str]
     sys.exit(exit_status)
 
 
-def fatal_error(error_msg: Optional[str] = None) -> None:
+def fatal_error(error_msg: str | None = None) -> None:
     exit_now(1, ErrInfo("error", other_msg=error_msg))
 
 
 def write_warning(warning_msg: str) -> None:
-    _state.exec_log.log_status_warning(warning_msg)
-    if _state.conf.write_warnings:
+    if _state.exec_log is not None:
+        _state.exec_log.log_status_warning(warning_msg)
+    if _state.conf is not None and _state.conf.write_warnings and _state.output is not None:
         _state.output.write_err(f"**** Warning {warning_msg}")
 
 
 def file_size_date(filename: str) -> tuple:
     # Returns the file size and date (as string) of the given file.
-    s_file = os.path.abspath(filename)
+    s_file = str(Path(filename).resolve())
     f_stat = os.stat(s_file)
     return f_stat.st_size, time.strftime("%Y-%m-%d %H:%M", time.gmtime(f_stat.st_mtime))
 
@@ -154,8 +161,6 @@ def chainfuncs(*funcs: Any) -> Any:
 
 
 def as_none(item: Any) -> Any:
-    if isinstance(item, str) and len(item) == 0:
-        return None
-    elif isinstance(item, int) and item == 0:
+    if isinstance(item, str) and len(item) == 0 or isinstance(item, int) and item == 0:
         return None
     return item

execsql/utils/fileio.py

@@ -26,30 +26,29 @@ import errno
 import io
 import multiprocessing
 import os
-import os.path
 import queue
+from pathlib import Path
 import stat
 import sys
 import tempfile
-import threading
 import time
 from encodings.aliases import aliases as codec_dict
-from typing import Any, Dict, Optional
+from typing import Any
 
 from execsql.exceptions import ErrInfo
 
 
 def make_export_dirs(outfile: str) -> None:
     if outfile.lower() != "stdout":
-        output_dir = os.path.dirname(outfile)
+        output_dir = str(Path(outfile).parent)
         if output_dir != "":
-            output_dir = os.path.normpath(output_dir)
+            output_dir = str(Path(output_dir))
             emsg = f"Can't create, or can't access, the directory {output_dir} to use for exported data."
             try:
                 os.makedirs(output_dir)
             except OSError as e:
                 if e.errno != errno.EEXIST:
-                    raise ErrInfo("exception", exception_msg=emsg)
+                    raise ErrInfo("exception", exception_msg=emsg) from e
             except Exception:
                 raise ErrInfo("exception", exception_msg=emsg)
 
@@ -62,8 +61,8 @@ def check_dir(filename: str) -> None:
         if conf.make_export_dirs:
             make_export_dirs(filename)
         else:
-            dn = os.path.dirname(filename)
-            if dn != "" and not os.path.exists(dn):
+            dn = str(Path(filename).parent)
+            if dn != "" and not Path(dn).exists():
                 raise ErrInfo(type="error", other_msg=f"The directory for file '{filename}' does not exist.")
 
 
@@ -122,7 +121,7 @@ class FileWriter(multiprocessing.Process):
                     self.open_start_time = time.time()
                 if time.time() - self.open_start_time < self.open_timeout:
                     try:
-                        self.handle = io.open(
+                        self.handle = open(  # noqa: SIM115
                             file=self.filename,
                             mode=self.openmode,
                             encoding=self.encoding,
@@ -130,10 +129,11 @@ class FileWriter(multiprocessing.Process):
                         )
                     except Exception:
                         self.status = self.STATUS_WAITING
-                    self.status = self.STATUS_OPEN
-                    self.openmode = "a"  # Return to default for next open command.
-                    self.open_start_time = None
-                    self.fail_message_written = False
+                    else:
+                        self.status = self.STATUS_OPEN
+                        self.openmode = "a"  # Return to default for next open command.
+                        self.open_start_time = None
+                        self.fail_message_written = False
                 else:
                     self.status = self.STATUS_OPENFAILURE
                     if not self.fail_message_written:
@@ -164,7 +164,7 @@ class FileWriter(multiprocessing.Process):
         def write(self, content: str) -> None:
             self.output_queue.appendleft(content)
             self.try_open()
-            if self.STATUS_OPEN:
+            if self.status == self.STATUS_OPEN:
                 self.write_queue()
 
     def __init__(
@@ -176,7 +176,7 @@ class FileWriter(multiprocessing.Process):
     ) -> None:
         # open_timeout is the maximum time, in seconds, that opening will be retried
         # if a file cannot be initially opened for writing.
-        super(FileWriter, self).__init__()
+        super().__init__()
         self.input_queue = input_queue
         self.return_msg_queue = return_msg_queue
         self.file_encoding = file_encoding
@@ -200,11 +200,11 @@ class FileWriter(multiprocessing.Process):
         self.close_all()
 
     def close_all(self) -> None:
-        for fc in self.files.values():
+        for fc in getattr(self, "files", {}).values():
             fc.close()
 
     def close_if_open(self, fn: str) -> None:
-        filename = os.path.abspath(fn)
+        filename = str(Path(fn).resolve())
         if filename in self.files:
             fc = self.files[filename]
             fc.close()
@@ -228,7 +228,7 @@ class FileWriter(multiprocessing.Process):
         self.return_msg_queue.put(token)
 
     def open_as_new(self, fn: str) -> None:
-        filename = os.path.abspath(fn)
+        filename = str(Path(fn).resolve())
         if filename not in self.files:
             self.files[filename] = self.FileControl(
                 filename,
@@ -239,14 +239,14 @@ class FileWriter(multiprocessing.Process):
         fc.open_as_new()
 
     def status(self, fn: str) -> None:
-        filename = os.path.abspath(fn)
+        filename = str(Path(fn).resolve())
         if filename in self.files:
             self.return_msg_queue.put(self.files[filename].status)
         else:
             self.return_msg_queue.put(self.FileControl.STATUS_UNOPENED)
 
     def write(self, fn: str, content: str) -> None:
-        filename = os.path.abspath(fn)
+        filename = str(Path(fn).resolve())
         if filename not in self.files:
             self.files[filename] = self.FileControl(
                 filename,
@@ -277,7 +277,7 @@ class FileWriter(multiprocessing.Process):
 
 # Subprocess objects for asynchronous writing to text files.
 # filewriter is initialized in main(), so it can take configurable arguments.
-filewriter: Optional[FileWriter] = None
+filewriter: FileWriter | None = None
 fw_input: multiprocessing.Queue = multiprocessing.Queue()
 fw_output: multiprocessing.Queue = multiprocessing.Queue()
 
@@ -328,7 +328,7 @@ def filewriter_end() -> None:
         filewriter_shutdown()
         filewriter.join()
     except Exception:
-        pass
+        pass  # Best-effort cleanup at interpreter shutdown.
 
 
 class EncodedFile:
@@ -345,7 +345,7 @@ class EncodedFile:
         def detect_by_bom(path: str, default_enc: str) -> tuple:
             # Detect whether a file starts with a BOM, and if it does, return the encoding.
             # Otherwise, return the default encoding specified.
-            with io.open(path, "rb") as f:
+            with open(path, "rb") as f:
                 raw = f.read(4)
             for enc, boms, bom_len in (
                 ("utf-8-sig", (codecs.BOM_UTF8,), 3),
@@ -356,7 +356,7 @@ class EncodedFile:
                     return enc, bom_len
             return default_enc, 0
 
-        if os.path.exists(filename):
+        if Path(filename).exists():
             self.encoding, self.bom_length = detect_by_bom(filename, file_encoding)
         self.fo = None
 
@@ -364,7 +364,7 @@ class EncodedFile:
         import execsql.state as _state
 
         conf = _state.conf
-        self.fo = io.open(
+        self.fo = open(  # noqa: SIM115
             file=self.filename,
             mode=mode,
             encoding=self.encoding,
@@ -389,10 +389,10 @@ class Logger:
         self,
         script_file_name: str,
         db_name: str,
-        server_name: Optional[str],
+        server_name: str | None,
         cmdline_options: dict,
         user_logfile: bool = False,
-        log_file_name: Optional[str] = None,
+        log_file_name: str | None = None,
     ) -> None:
         import getpass
         from execsql.utils.errors import exception_desc, exit_now, file_size_date
@@ -406,10 +406,11 @@ class Logger:
             self.log_file_name = log_file_name
         else:
             if user_logfile:
-                self.log_file_name = os.path.expanduser(r"~/execsql.log")
+                self.log_file_name = str(Path("~/execsql.log").expanduser())
             else:
-                self.log_file_name = os.path.join(os.getcwd(), "execsql.log")
-        f_exists = os.path.isfile(self.log_file_name)
+                self.log_file_name = str(Path(os.getcwd()) / "execsql.log")
+        self._rotate_if_needed()
+        f_exists = Path(self.log_file_name).is_file()
         if f_exists:
             try:
                 os.chmod(self.log_file_name, os.stat(self.log_file_name).st_mode | stat.S_IWRITE)
@@ -432,16 +433,23 @@ class Logger:
             )
         import datetime as _datetime
 
-        self.run_id = _datetime.datetime.now().strftime("%Y%m%d_%H%M_%S")
+        _now = _datetime.datetime.now()
+        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, dt = file_size_date(script_file_name)
+        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())
+        else:
+            sz, dt = 0, ""
+            abs_script = script_file_name or "<inline>"
         msg = "run\t{}\t{}\t{}\t{}\t{}\t{}\n".format(
             self.run_id,
-            os.path.abspath(script_file_name),
+            abs_script,
             dt,
             sz,
             self.user,
-            ", ".join([f"{k}: {cmdline_options[k]}" for k in cmdline_options.keys()]),
+            ", ".join([f"{k}: {cmdline_options[k]}" for k in cmdline_options]),
         )
         self.writelog(msg)
         if server_name:
@@ -451,12 +459,35 @@ class Logger:
         self.writelog(msg)
         self.seq_no = 0
         atexit.register(self.close)
-        self.exit_type = None
+        self.exit_type = "unknown"
         self.exit_scriptfile = None
         self.exit_lno = None
         self.exit_description = None
         atexit.register(self.log_exit)
 
+    def _ts(self) -> str:
+        import datetime as _datetime
+
+        return _datetime.datetime.now().isoformat(timespec="seconds")
+
+    def _rotate_if_needed(self) -> None:
+        try:
+            import execsql.state as _state
+
+            max_mb = getattr(_state.conf, "max_log_size_mb", 0) if _state.conf else 0
+        except Exception:
+            max_mb = 0
+        if max_mb > 0 and Path(self.log_file_name).is_file():
+            size_mb = Path(self.log_file_name).stat().st_size / (1024 * 1024)
+            if size_mb >= max_mb:
+                rotated = self.log_file_name + ".1"
+                try:
+                    if Path(rotated).exists():
+                        os.remove(rotated)
+                    os.rename(self.log_file_name, rotated)
+                except Exception:
+                    pass  # Log rotation is best-effort; file may be locked.
+
     def writelog(self, msg: str) -> None:
         if self.log_file is not None:
             self.log_file.write(msg)
@@ -468,61 +499,61 @@ 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{db.name()}\n"
+        msg = f"connect\t{self.run_id}\t{self.seq_no}\t{self._ts()}\t{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}\texport\t{line_no}\tQuery {query_name} exported to {export_file_name}\n"
+        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"
         self.writelog(msg)
 
-    def log_action_prompt_quit(self, line_no: int, do_quit: bool, msg: Optional[str]) -> None:
+    def log_action_prompt_quit(self, line_no: int, do_quit: bool, msg: str | None) -> None:
         # 'do_quit' is Boolean: True to quit, False if not.
         msg = None if not msg else msg.replace("\n", "")
         self.seq_no += 1
         descrip = '{} after prompt "{}"'.format("Quitting" if do_quit else "Continuing", msg)
-        wmsg = f"action\t{self.run_id}\t{self.seq_no}\tprompt_quit\t{str(line_no) or ''}\t{descrip}\n"
+        wmsg = f"action\t{self.run_id}\t{self.seq_no}\t{self._ts()}\tprompt_quit\t{str(line_no) or ''}\t{descrip}\n"
         self.writelog(wmsg)
 
-    def log_status_exception(self, msg: Optional[str]) -> None:
+    def log_status_exception(self, msg: str | None) -> None:
         msg = None if not msg else msg.replace("\n", "")
         self.seq_no += 1
-        wmsg = f"status\t{self.run_id}\t{self.seq_no}\texception\t{msg or ''}\n"
+        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: Optional[str]) -> None:
+    def log_status_error(self, msg: str | None) -> None:
         msg = None if not msg else msg.replace("\n", "")
         self.seq_no += 1
-        wmsg = f"status\t{self.run_id}\t{self.seq_no}\terror\t{msg or ''}\n"
+        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: Optional[str]) -> None:
+    def log_status_info(self, msg: str | None) -> None:
         msg = None if not msg else msg.replace("\n", "")
         self.seq_no += 1
-        wmsg = f"status\t{self.run_id}\t{self.seq_no}\tinfo\t{msg or ''}\n"
+        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: Optional[str]) -> None:
+    def log_status_warning(self, msg: str | None) -> None:
         msg = None if not msg else msg.replace("\n", "")
         self.seq_no += 1
-        wmsg = f"status\t{self.run_id}\t{self.seq_no}\twarning\t{msg or ''}\n"
+        wmsg = f"status\t{self.run_id}\t{self.seq_no}\t{self._ts()}\twarning\t{msg or ''}\n"
         self.writelog(wmsg)
 
-    def log_user_msg(self, msg: Optional[str]) -> None:
+    def log_user_msg(self, msg: str | None) -> None:
         msg = 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}\tinfo\t{msg}\n"
+            wmsg = f"user_msg\t{self.run_id}\t{self.seq_no}\t{self._ts()}\tinfo\t{msg}\n"
             self.writelog(wmsg)
 
-    def log_exit_end(self, script_file_name: Optional[str] = None, line_no: Optional[int] = None) -> None:
+    def log_exit_end(self, script_file_name: str | None = None, line_no: int | None = None) -> None:
         # Save values to be used by exit() function triggered on program exit
         self.exit_type = "end_of_script"
         self.exit_scriptfile = script_file_name
         self.exit_lno = line_no
         self.exit_description = None
 
-    def log_exit_halt(self, script_file_name: str, line_no: int, msg: Optional[str] = None) -> None:
+    def log_exit_halt(self, script_file_name: str, line_no: int, msg: str | None = None) -> None:
         # Save values to be used by exit() function triggered on program exit
         self.exit_type = "halt"
         self.exit_scriptfile = script_file_name
@@ -536,7 +567,7 @@ class Logger:
         self.exit_lno = None
         self.exit_description = msg.replace("\n", "")
 
-    def log_exit_error(self, msg: Optional[str]) -> None:
+    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
@@ -544,12 +575,16 @@ class Logger:
         self.exit_description = None if not msg else msg.replace("\n", "")
 
     def log_exit(self) -> None:
-        wmsg = "exit\t{}\t{}\t{}({})\t{}\n".format(
+        import datetime as _datetime
+
+        elapsed = (_datetime.datetime.now() - self.run_start).total_seconds()
+        wmsg = "exit\t{}\t{}\t{}({})\t{}\t{:.1f}s\n".format(
             self.run_id,
             self.exit_type,
             self.exit_scriptfile or "",
             str(self.exit_lno or ""),
             self.exit_description or "",
+            elapsed,
         )
         self.writelog(wmsg)
 
@@ -565,13 +600,13 @@ class TempFileMgr:
 
     def new_temp_fn(self) -> str:
         # Get a file object, get its name, and throw away the object
-        fn = tempfile.NamedTemporaryFile().name
+        fn = tempfile.NamedTemporaryFile().name  # noqa: SIM115
         self.temp_file_names.append(fn)
         return fn
 
     def remove_all(self) -> None:
         for fn in self.temp_file_names:
-            if os.path.exists(fn):
+            if Path(fn).exists():
                 try:
                     # This may fail if the user has it open; let it go.
                     os.unlink(fn)

execsql/utils/gui.py

@@ -19,7 +19,7 @@ their bodies to avoid circular imports.
 from __future__ import annotations
 
 import sys
-from typing import Any, Optional
+from typing import Any
 
 # ---------------------------------------------------------------------------
 # GUI command constants — used to identify request types in the GUI queue.
@@ -125,14 +125,14 @@ class EntrySpec:
         varname: str,
         label: str,
         required: bool = False,
-        initial_value: Optional[str] = None,
-        default_width: Optional[int] = None,
-        default_height: Optional[int] = None,
-        lookup_list: Optional[list] = None,
-        form_column: Optional[int] = None,
-        validation_regex: Optional[str] = None,
-        validation_key_regex: Optional[str] = None,
-        entry_type: Optional[str] = None,
+        initial_value: str | None = None,
+        default_width: int | None = None,
+        default_height: int | None = None,
+        lookup_list: list | None = None,
+        form_column: int | None = None,
+        validation_regex: str | None = None,
+        validation_key_regex: str | None = None,
+        entry_type: str | None = None,
     ) -> None:
         self.varname = varname
         self.name = varname  # alias used by prompt.py result processing
@@ -146,7 +146,7 @@ class EntrySpec:
         self.validation_regex = validation_regex
         self.validation_key_regex = validation_key_regex
         self.entry_type = entry_type
-        self.value: Optional[str] = None  # populated by the backend after user input
+        self.value: str | None = None  # populated by the backend after user input
 
 
 # ---------------------------------------------------------------------------
@@ -283,7 +283,7 @@ def gui_console_show() -> None:
         _active_backend.console_show()
 
 
-def gui_console_progress(num: float, total: Optional[float] = None) -> None:
+def gui_console_progress(num: float, total: float | None = None) -> None:
     """Update the progress indicator in the console."""
     if _active_backend is not None:
         _active_backend.console_progress(num, total)
@@ -330,8 +330,8 @@ def gui_console_height() -> int:
 def gui_connect(
     alias: str,
     message: str,
-    help_url: Optional[str] = None,
-    cmd: Optional[str] = None,
+    help_url: str | None = None,
+    cmd: str | None = None,
 ) -> None:
     """Prompt the user to select a database connection.
 
@@ -383,7 +383,6 @@ def _apply_connect_result(alias: str, result: dict) -> None:
     database = result.get("database")
     db_file = result.get("db_file")
     username = result.get("username")
-    conf = _state.conf
 
     if db_type == "p":
         db = db_Postgres(server, database, user=username, pw_needed=True)
@@ -411,9 +410,9 @@ def _apply_connect_result(alias: str, result: dict) -> None:
 
 def gui_credentials(
     message: str = "",
-    username: Optional[str] = None,
-    pwtext: Optional[str] = None,
-    cmd: Optional[str] = None,
+    username: str | None = None,
+    pwtext: str | None = None,
+    cmd: str | None = None,
 ) -> None:
     """Prompt the user for credentials.
 
@@ -479,9 +478,9 @@ def get_yn_win(prompt: str) -> bool:
 
 def pause(
     text: str,
-    action: Optional[str] = None,
-    countdown: Optional[float] = None,
-    timeunit: Optional[str] = None,
+    action: str | None = None,
+    countdown: float | None = None,
+    timeunit: str | None = None,
 ) -> int:
     """Display a pause message and wait for the user.
 
@@ -505,9 +504,9 @@ def pause(
 
 def pause_win(
     text: str,
-    action: Optional[str] = None,
-    countdown: Optional[float] = None,
-    timeunit: Optional[str] = None,
+    action: str | None = None,
+    countdown: float | None = None,
+    timeunit: str | None = None,
 ) -> int:
     """GUI pause dialog — falls back to terminal in headless mode."""
     return pause(text, action=action, countdown=countdown, timeunit=timeunit)