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

execsql/metacommands/prompt.py

@@ -81,7 +81,7 @@ def x_prompt(**kwargs: Any) -> None:
     cmd = f"select * from {sq_name};"
     colnames, rows = db.select_data(cmd)
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": table,
         "message": message,
@@ -117,7 +117,7 @@ def x_prompt_enter(**kwargs: Any) -> None:
     else:
         hdrs, rows = None, None
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": "Enter a value",
         "message": message,
@@ -289,7 +289,7 @@ def x_prompt_entryform(**kwargs: Any) -> None:
         sq_name = db.schema_qualified_table_name(display_schema, display_table)
         colnames, rows = db.select_data(f"select * from {sq_name};")
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": "Entry",
         "message": message,
@@ -304,18 +304,20 @@ def x_prompt_entryform(**kwargs: Any) -> None:
     entries = user_response["return_value"]
     script, line_no = current_script_line()
     if btn:
-        for e in entries:
-            if e.value:
-                value = str(e.value)
+        assert entries is not None
+        assert subvar is not None
+        for entry in entries:
+            if entry.value:
+                value = str(entry.value)
                 subvarset = _state.subvars if subvar[0] != "~" else _state.current_localvars()
-                subvarset.add_substitution(e.name, value)
+                subvarset.add_substitution(entry.name, value)
                 _state.exec_log.log_status_info(
-                    f"Substitution variable {e.name} set to {{{value}}} on line {line_no} of {script}",
+                    f"Substitution variable {entry.name} set to {{{value}}} on line {line_no} of {script}",
                 )
             else:
-                if _state.subvars.sub_exists(e.name):
+                if _state.subvars.sub_exists(entry.name):
                     _state.exec_log.log_status_info(
-                        f"Substitution variable {e.name} removed on line {line_no} of {script}",
+                        f"Substitution variable {entry.name} removed on line {line_no} of {script}",
                     )
     else:
         if _state.status.cancel_halt:
@@ -340,7 +342,7 @@ def x_prompt_pause(**kwargs: Any) -> None:
     if timeunit and timeunit.lower() == "minutes":
         maxtime_secs = maxtime_secs * 60
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": f"Script {current_script_line()[0]}",
         "message": msg,
@@ -401,7 +403,7 @@ def prompt_compare(button_list: list, **kwargs: Any) -> Any:
             other_msg=f"Specified primary key columns do not exist in PROMPT COMPARE metacommand on line {line_no} of {script}.",
         )
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": "Compare data",
         "message": msg,
@@ -458,7 +460,7 @@ def x_prompt_ask(**kwargs: Any) -> None:
     else:
         colnames, rows = None, None
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": script,
         "message": kwargs["question"],
@@ -499,7 +501,7 @@ def x_prompt_map(**kwargs: Any) -> None:
     cmd = f"select * from {sq_name};"
     colnames, rows = db.select_data(cmd)
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": table,
         "message": message,
@@ -590,7 +592,7 @@ def x_prompt_action(**kwargs: Any) -> None:
         sq_name = db.schema_qualified_table_name(display_schema, display_table)
         colnames, rows = db.select_data(f"select * from {sq_name};")
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": "Actions",
         "message": message,
@@ -624,7 +626,7 @@ def x_prompt_savefile(**kwargs: Any) -> None:
         script, lno = current_script_line()
         working_dir = startdir if startdir is not None else str(Path(script).resolve().parent)
         enable_gui()
-        return_queue = _queue.Queue()
+        return_queue: _queue.Queue[Any] = _queue.Queue()
         gui_args = {"working_dir": working_dir, "script": script}
         _state.gui_manager_queue.put(GuiSpec(GUI_SAVEFILE, gui_args, return_queue))
         user_response = return_queue.get(block=True)
@@ -697,7 +699,7 @@ def x_prompt_openfile(**kwargs: Any) -> None:
         script, lno = current_script_line()
         working_dir = startdir if startdir is not None else str(Path(script).resolve().parent)
         enable_gui()
-        return_queue = _queue.Queue()
+        return_queue: _queue.Queue[Any] = _queue.Queue()
         gui_args = {"working_dir": working_dir, "script": script}
         _state.gui_manager_queue.put(GuiSpec(GUI_OPENFILE, gui_args, return_queue))
         user_response = return_queue.get(block=True)
@@ -756,7 +758,7 @@ def x_prompt_directory(**kwargs: Any) -> None:
         script, lno = current_script_line()
         working_dir = startdir if startdir is not None else str(Path(script).resolve().parent)
         enable_gui()
-        return_queue = _queue.Queue()
+        return_queue: _queue.Queue[Any] = _queue.Queue()
         gui_args = {"working_dir": working_dir, "script": script}
         _state.gui_manager_queue.put(GuiSpec(GUI_DIRECTORY, gui_args, return_queue))
         user_response = return_queue.get(block=True)
@@ -818,7 +820,7 @@ def prompt_select_rows(button_list: list, **kwargs: Any) -> Any:
     if len(missing_hdrs) > 0:
         raise ErrInfo("error", other_msg=f"Columns [{', '.join(missing_hdrs)}] are missing from {sq_name2}.")
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {
         "title": "Select rows",
         "message": msg,
@@ -867,7 +869,7 @@ def x_ask(**kwargs: Any) -> None:
     subvar = kwargs["match"]
     script, lno = current_script_line()
     if _state.gui_console:
-        return_queue = _queue.Queue()
+        return_queue: _queue.Queue[Any] = _queue.Queue()
         gui_args = {
             "title": script,
             "message": kwargs["question"],
@@ -919,7 +921,7 @@ def x_pause(**kwargs: Any) -> None:
         maxtime_secs = maxtime_secs * 60
     use_gui = False
     if _state.gui_manager_thread:
-        return_queue = _queue.Queue()
+        return_queue: _queue.Queue[Any] = _queue.Queue()
         _state.gui_manager_queue.put(GuiSpec(QUERY_CONSOLE, {}, return_queue))
         user_response = return_queue.get(block=True)
         use_gui = user_response["console_running"]
@@ -953,7 +955,7 @@ def x_msg(**kwargs: Any) -> None:
     message = kwargs["message"]
     current_script_line()
     enable_gui()
-    return_queue = _queue.Queue()
+    return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {"title": "Message", "message": message}
     _state.gui_manager_queue.put(GuiSpec(GUI_MSG, gui_args, return_queue))
     return_queue.get(block=True)

execsql/metacommands/system.py

@@ -49,7 +49,20 @@ def x_system_cmd(**kwargs: Any) -> None:
     filewriter_close_all_after_write()
     cmdlist = shlex.split(syscmd, posix=(os.name == "posix"))
     if cont is None:
-        result = subprocess.run(cmdlist)
+        timeout = getattr(_state.conf, "system_cmd_timeout", 0.0)
+        try:
+            if timeout and timeout > 0:
+                result = subprocess.run(cmdlist, timeout=timeout)
+            else:
+                result = subprocess.run(cmdlist)
+        except subprocess.TimeoutExpired as e:
+            _state.subvars.add_substitution("$SYSTEM_CMD_EXIT_STATUS", "124")
+            raise ErrInfo(
+                type="cmd",
+                command_text=kwargs.get("metacommandline", "SYSTEM_CMD"),
+                other_msg=f"SYSTEM_CMD timed out after {timeout:g} seconds.",
+                exception_msg=exception_desc(),
+            ) from e
         _state.subvars.add_substitution("$SYSTEM_CMD_EXIT_STATUS", str(result.returncode))
     else:
         proc = subprocess.Popen(cmdlist)

execsql/models.py

@@ -47,6 +47,8 @@ __all__ = [
     "to_json_type",
 ]
 
+ColumnType = tuple[str, type[DataType], int | None, bool, int | None, int | None]
+
 
 class Column:
     """Compile data-type match statistics for a single column of imported data."""
@@ -66,9 +68,11 @@ class Column:
             self.count = 0
             self.maxlen = 0
             self.varlen = False
-            self.maxprecision = None
-            self.scale = None
+            self.maxprecision: int | None = None
+            self.scale: int | None = None
             self.varscale = False
+            self.maxscale: int | None = None
+            self.max_int_digits: int | None = None
 
         def __repr__(self) -> str:
             return (
@@ -97,21 +101,35 @@ class Column:
                     if vlen > self.maxlen:
                         self.maxlen = vlen
                     if self.dt.precision is not None and self.dt.scale is not None:
+                        int_digits = self.dt.precision - self.dt.scale
                         if self.maxprecision is None:
                             self.maxprecision = self.dt.precision
-                        else:
-                            self.maxprecision = max(self.dt.precision, self.maxprecision)
-                        if self.scale is None:
                             self.scale = self.dt.scale
+                            self.maxscale = self.dt.scale
+                            self.max_int_digits = int_digits
                         else:
+                            assert self.maxscale is not None
+                            assert self.max_int_digits is not None
+                            self.maxprecision = max(self.dt.precision, self.maxprecision)
                             if self.dt.scale != self.scale:
                                 self.varscale = True
-                                self.failed = True
+                            self.maxscale = max(self.dt.scale, self.maxscale)
+                            self.max_int_digits = max(int_digits, self.max_int_digits)
                 else:
                     self.failed = True
 
-    def __init__(self, colname: str) -> None:
-        """Create a column characteriser for the named column."""
+    def __init__(self, colname: str, infer_strings: bool = True) -> None:
+        """Create a column characteriser for the named column.
+
+        Args:
+            colname: The name of the column to characterise.
+            infer_strings: When ``False``, string values are only tested
+                against string-typed accumulators (Character, Varchar, Text),
+                skipping numeric/date/boolean checks.  Set to ``False`` when
+                the row source already contains typed values (e.g. exported
+                from a DBMS cursor) so that a Python ``str`` that happens to
+                look like a date is not misclassified.
+        """
         from execsql.exceptions import ErrInfo
         import execsql.state as _state
 
@@ -126,6 +144,7 @@ class Column:
         self.nullrows = 0
         # The list of accumulators must be in order from most specific to least specific data type.
         conf = _state.conf
+        self.accums: tuple[Column.Accum, ...]
         if conf.only_strings:
             self.accums = (
                 self.Accum(DT_Character()),
@@ -148,10 +167,12 @@ class Column:
                 self.Accum(DT_Text()),
                 self.Accum(DT_Binary()),
             )
+        self.infer_strings = infer_strings
+        self.str_accums = tuple(ac for ac in self.accums if isinstance(ac.dt, (DT_Character, DT_Varchar, DT_Text)))
         self.dt_eval = False
         # self.dt is a tuple of: 0: column name; 1: data type class; 2: max length or None;
         # 3: bool indicating any null values; 4: precision or None; 5: scale or None.
-        self.dt = (None, None, None, None, None, None)
+        self.dt: ColumnType | None = None
 
     def __repr__(self) -> str:
         return f"Column({self.name!r})"
@@ -174,15 +195,20 @@ class Column:
         ):
             self.nullrows += 1
             return
-        for dt in self.accums:
-            dt.check(column_value)
+        if not self.infer_strings and isinstance(column_value, str):
+            for dt in self.str_accums:
+                dt.check(column_value)
+        else:
+            for dt in self.accums:
+                dt.check(column_value)
 
-    def column_type(self) -> tuple:
+    def column_type(self) -> ColumnType:
         """Return the inferred type of this column as a 6-tuple."""
         # Return the type of this column as a tuple of:
         #   column name, data type class, max length or None, bool for null values,
         #   precision or None, scale or None.
         if self.dt_eval:
+            assert self.dt is not None
             return self.dt
         sel_type = None  # Will be set to an Accum instance.
         if self.nullrows == self.rowcount:
@@ -213,8 +239,12 @@ class Column:
             sel_type.dt.__class__,
             None if not sel_type.dt.lenspec else sel_type.maxlen,
             self.nullrows > 0,
-            sel_type.maxprecision,
-            sel_type.scale,
+            (
+                sel_type.max_int_digits + sel_type.maxscale
+                if sel_type.max_int_digits is not None and sel_type.maxscale is not None
+                else sel_type.maxprecision
+            ),
+            sel_type.maxscale if sel_type.maxscale is not None else sel_type.scale,
         )
         self.dt_eval = True
         return self.dt
@@ -223,8 +253,17 @@ class Column:
 class DataTable:
     """Scan a row source and infer column types for CREATE TABLE generation."""
 
-    def __init__(self, column_names: list[str], rowsource: Any) -> None:
-        """Scan all rows from the source and infer a column type for each column."""
+    def __init__(self, column_names: list[str], rowsource: Any, infer_strings: bool = True) -> None:
+        """Scan all rows from the source and infer a column type for each column.
+
+        Args:
+            column_names: Ordered list of column names for the table.
+            rowsource: Iterable of row tuples (or lists) to scan.
+            infer_strings: Passed through to each :class:`Column`.  Set to
+                ``False`` when the row source originates from a DBMS cursor so
+                that Python ``str`` values that resemble dates or numbers are
+                not misclassified.
+        """
         import execsql.state as _state
 
         self.inputrows = 0  # Total number of rows in the row source.
@@ -232,7 +271,7 @@ class DataTable:
         self.shortrows = 0  # Number of rows without as many data values as column names.
         self.cols: list = []  # List of Column objects.
         for n in column_names:
-            self.cols.append(Column(n))
+            self.cols.append(Column(n, infer_strings=infer_strings))
         conf = _state.conf
         # Read and evaluate columns in the rowsource until done (or until an error).
         for datarow in rowsource:

execsql/parser.py

@@ -23,7 +23,7 @@ Classes:
 """
 
 import re
-from typing import Any
+from typing import Any, cast
 
 from execsql.exceptions import CondParserError, NumericParserError
 
@@ -154,18 +154,18 @@ class CondAstNode(CondTokens):
         if self.type == self.CONDITIONAL:
             exec_fn = self.left[0].exec_fn
             cmdargs = self.left[1]
-            return exec_fn(**cmdargs)
+            return bool(exec_fn(**cmdargs))
         if self.type == self.NOT:
             return not self.left.eval()
         lcond = self.left.eval()
         if self.type == self.AND:
             if not lcond:
                 return False
-            return self.right.eval()
+            return cast(bool, self.right.eval())
         if self.type == self.OR:
             if lcond:
                 return True
-            return self.right.eval()
+            return cast(bool, self.right.eval())
         raise CondParserError(f"Unknown conditional node type: {self.type}")
 
 
@@ -254,10 +254,10 @@ class CondParser(CondTokens):
         # conditionallist is a module-level global in the main execsql module
         import execsql.state as _state
 
-        m1 = self.cond_expr.match_metacommand(_state.conditionallist)
-        if m1 is not None:
-            m1[1]["metacommandline"] = self.condexpr
-            return CondAstNode(self.CONDITIONAL, m1, None)
+        matched_metacommand = self.cond_expr.match_metacommand(_state.conditionallist)
+        if matched_metacommand is not None:
+            matched_metacommand[1]["metacommandline"] = self.condexpr
+            return CondAstNode(self.CONDITIONAL, matched_metacommand, None)
         else:
             if self.cond_expr.match_str("(") is not None:
                 m1 = self.expression()

execsql/plugins.py

@@ -298,7 +298,7 @@ def _load_entry_points(group: str) -> list[tuple[str, Any]]:
     Errors during loading are logged and skipped — a broken plugin should
     not prevent execsql from starting.
     """
-    results = []
+    results: list[tuple[str, Any]] = []
     try:
         eps = entry_points(group=group)
     except Exception:

execsql/script/engine.py

@@ -28,7 +28,7 @@ import os
 import re
 import uuid
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
@@ -315,11 +315,11 @@ class ScriptCmd:
     def __repr__(self) -> str:
         return f"ScriptCmd({self.source!r}, {self.line_no!r}, {self.command_type!r}, {repr(self.command)!r})"
 
-    def current_script_line(self) -> tuple:
+    def current_script_line(self) -> tuple[str, int]:
         return (self.source, self.line_no)
 
     def commandline(self) -> str:
-        return self.command.statement if self.command_type == "sql" else "-- !x! " + self.command.statement
+        return cast(str, self.command.statement if self.command_type == "sql" else "-- !x! " + self.command.statement)
 
 
 # ---------------------------------------------------------------------------
@@ -505,7 +505,7 @@ def substitute_vars(command_str: str, localvars: SubVarSet | None = None, ctx: A
     return cmdstr
 
 
-def current_script_line() -> tuple:
+def current_script_line() -> tuple[str, int]:
     """Return ``(source_name, line_number)`` for the command currently executing.
 
     Reads from ``_state.last_command``, which the AST executor updates on

execsql/script/executor.py

@@ -47,7 +47,7 @@ import os
 import re
 import time as _time
 from pathlib import Path
-from typing import Any
+from typing import Any, cast
 
 from execsql.exceptions import ErrInfo
 from execsql.script.ast import (
@@ -98,7 +98,17 @@ def _stack_localvars(ctx: RuntimeContext) -> SubVarSet | None:
     localvars = scope.localvars
     if localvars is None:
         return None
-    return localvars.merge(scope.paramvals)
+    return cast(SubVarSet, localvars.merge(scope.paramvals))
+
+
+def _assert_command_runtime(ctx: RuntimeContext) -> None:
+    """Assert runtime singletons required by command execution are initialised."""
+    assert ctx.conf is not None
+    assert ctx.dbs is not None
+    assert ctx.metacommandlist is not None
+    assert ctx.output is not None
+    assert ctx.status is not None
+    assert ctx.subvars is not None
 
 
 def _push_frame(
@@ -192,6 +202,7 @@ def _eval_condition(
 
 def _set_command_vars(ctx: RuntimeContext, source: str, line_no: int) -> None:
     """Set per-command system variables (current script, line, time)."""
+    assert ctx.subvars is not None
     now = datetime.datetime.now()
     ctx.subvars.add_substitution("$CURRENT_TIME", now.strftime("%Y-%m-%d %H:%M"))
     ctx.subvars.add_substitution("$CURRENT_DATE", now.strftime("%Y-%m-%d"))
@@ -219,9 +230,21 @@ def _exec_sql(
     commit: bool = True,
 ) -> None:
     """Execute a SQL statement against the current database."""
-    ctx.status.sql_error = False
-    if ctx.status.batch.in_batch():
-        ctx.status.batch.using_db(ctx.dbs.current())
+    _assert_command_runtime(ctx)
+    conf = ctx.conf
+    dbs = ctx.dbs
+    output = ctx.output
+    status = ctx.status
+    subvars = ctx.subvars
+    assert conf is not None
+    assert dbs is not None
+    assert output is not None
+    assert status is not None
+    assert subvars is not None
+
+    status.sql_error = False
+    if status.batch.in_batch():
+        status.batch.using_db(dbs.current())
     # Build localvars from the command-list stack frame so that ~ and # vars
     # written by x_sub/get_subvarset are visible.  The stack frame is the
     # canonical source; the `localvars` parameter is kept for backward compat
@@ -229,13 +252,13 @@ def _exec_sql(
     effective_locals = _stack_localvars(ctx) or localvars
     cmd = substitute_vars(text, effective_locals, ctx=ctx)
     if _VARLIKE.search(cmd):
-        ctx.output.write(
+        output.write(
             f"Warning: There is a potential un-substituted variable in the command\n     {cmd}\n",
         )
     e = None
     try:
-        db = ctx.dbs.current()
-        if ctx.conf.log_sql and ctx.exec_log:
+        db = dbs.current()
+        if conf.log_sql and ctx.exec_log:
             ctx.exec_log.log_sql_query(cmd, db.name(), line_no)
         db.execute(cmd)
         if commit:
@@ -248,15 +271,16 @@ def _exec_sql(
         e = ErrInfo(type="exception", exception_msg=exception_desc())
     if e:
         stamp_errinfo(e)
-        ctx.subvars.add_substitution("$LAST_ERROR", cmd)
-        ctx.subvars.add_substitution("$ERROR_MESSAGE", e.errmsg())
-        ctx.status.sql_error = True
+        subvars.add_substitution("$LAST_ERROR", cmd)
+        subvars.add_substitution("$ERROR_MESSAGE", e.errmsg())
+        status.sql_error = True
         if ctx.exec_log is not None:
             ctx.exec_log.log_status_info(f"SQL error: {e.errmsg()}")
-        if ctx.status.halt_on_err:
+        if status.halt_on_err:
             exit_now(1, e)
+        status.error_history.append((source, line_no, cmd, e.errmsg()))
         return
-    ctx.subvars.add_substitution("$LAST_SQL", cmd)
+    subvars.add_substitution("$LAST_SQL", cmd)
 
 
 # ---------------------------------------------------------------------------
@@ -277,13 +301,23 @@ def _exec_metacommand(
     increments, ``$RANDOM``, ``$UUID``) are evaluated exactly once per
     metacommand reference.
     """
+    _assert_command_runtime(ctx)
+    metacommandlist = ctx.metacommandlist
+    output = ctx.output
+    status = ctx.status
+    subvars = ctx.subvars
+    assert metacommandlist is not None
+    assert output is not None
+    assert status is not None
+    assert subvars is not None
+
     if _VARLIKE.search(cmd):
-        ctx.output.write(
+        output.write(
             f"Warning: There is a potential un-substituted variable in the command\n     {cmd}\n",
         )
     e = None
     try:
-        applies, result = ctx.metacommandlist.eval(cmd)
+        applies, result = metacommandlist.eval(cmd)
         if applies:
             return result
     except ErrInfo as errinfo:
@@ -294,16 +328,17 @@ def _exec_metacommand(
         e = ErrInfo(type="exception", exception_msg=exception_desc())
     if e:
         stamp_errinfo(e)
-        ctx.status.metacommand_error = True
-        ctx.subvars.add_substitution("$LAST_ERROR", cmd)
-        ctx.subvars.add_substitution("$ERROR_MESSAGE", e.errmsg())
+        status.metacommand_error = True
+        subvars.add_substitution("$LAST_ERROR", cmd)
+        subvars.add_substitution("$ERROR_MESSAGE", e.errmsg())
         if ctx.exec_log is not None:
             ctx.exec_log.log_status_info(f"Metacommand error: {e.errmsg()}")
-        if ctx.status.halt_on_metacommand_err:
+        if status.halt_on_metacommand_err:
             raise e
+        status.error_history.append((source, line_no, cmd, e.errmsg()))
         return None
     # No handler matched — truly unknown metacommand
-    ctx.status.metacommand_error = True
+    status.metacommand_error = True
     raise ErrInfo(type="cmd", command_text=cmd, other_msg="Unknown metacommand")
 
 
@@ -345,7 +380,9 @@ def _execute_nodes(
             elapsed = _time.perf_counter() - t0
             cmd_type = _node_cmd_type(node)
             cmd_text = _node_cmd_text(node)[:100]
-            ctx.profile_data.append(
+            profile_data = ctx.profile_data
+            assert profile_data is not None
+            profile_data.append(
                 (node.span.file, node.span.start_line, cmd_type, elapsed, cmd_text),
             )
 
@@ -360,6 +397,7 @@ def _execute_node(
     in_loop: bool = False,
 ) -> None:
     """Execute a single AST node."""
+    assert ctx.status is not None
     if isinstance(node, SqlStatement):
         text = node.text
         if in_loop:
@@ -528,7 +566,9 @@ def _execute_batch(
     """Execute a BEGIN BATCH / END BATCH block."""
     from execsql.state import ExecFrame
 
-    ctx.status.batch.new_batch()
+    status = ctx.status
+    assert status is not None
+    status.batch.new_batch()
     _push_block_frame(
         ctx,
         ExecFrame(kind="batch", label="", source=node.span.file, line=node.span.start_line),
@@ -537,8 +577,8 @@ def _execute_batch(
         _execute_nodes(ctx, node.body, node.span.file, localvars, in_loop=in_loop)
     finally:
         ctx.ast_exec_stack.pop()
-        if ctx.status.batch.in_batch():
-            ctx.status.batch.end_batch()
+        if status.batch.in_batch():
+            status.batch.end_batch()
 
 
 def _pre_register_scripts(ctx: RuntimeContext, nodes: list[Node]) -> None:
@@ -716,7 +756,8 @@ def _execute_script_native(
 
         # Handle WHILE/UNTIL loops
         # Convert deferred vars once — node.loop_condition is immutable after parsing
-        if node.loop_type is not None:
+        condition = ""
+        if node.loop_type is not None and node.loop_condition is not None:
             condition = _convert_deferred_vars(node.loop_condition)
 
         if node.loop_type == "WHILE":
@@ -818,7 +859,7 @@ def _execute_include_native(
         ctx.exec_log.log_status_info(f"Reading script file {target} (size: {sz}; date: {dt})")
 
     # Parse with AST parser
-    encoding = ctx.conf.script_encoding if ctx.conf else "utf-8"
+    encoding = ctx.conf.script_encoding if ctx.conf is not None else "utf-8"
     included_tree = parse_script(target, encoding=encoding)
 
     # Pre-register SCRIPT blocks in the included file so forward references work.
@@ -879,11 +920,11 @@ class _FakeScriptCmd:
         else:
             self.command = type("_cmd", (), {"statement": "", "commandline": lambda self: ""})()
 
-    def current_script_line(self) -> tuple:
+    def current_script_line(self) -> tuple[str, int]:
         return (self.source, self.line_no)
 
     def commandline(self) -> str:
-        return self.command.commandline()
+        return cast(str, self.command.commandline())
 
 
 # ---------------------------------------------------------------------------