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

execsql/metacommands/io.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from execsql.exceptions import ErrInfo
 
 """
 Input/output metacommand handlers for execsql.
@@ -17,10 +18,60 @@ metacommands:
 
 import os
 import sys
+from pathlib import Path
 from shutil import copyfileobj
 from typing import Any
 
 import execsql.state as _state
+from execsql.exporters.base import ExportRecord
+from execsql.exporters.delimited import CsvFile, write_delimited_file
+from execsql.exporters.duckdb import write_query_to_duckdb
+from execsql.exporters.feather import write_query_to_feather, write_query_to_hdf5
+from execsql.exporters.parquet import write_query_to_parquet
+from execsql.exporters.html import write_query_to_cgi_html, write_query_to_html
+from execsql.exporters.json import write_query_to_json, write_query_to_json_ts
+from execsql.exporters.latex import write_query_to_latex
+from execsql.exporters.ods import OdsFile, write_queries_to_ods, write_query_to_ods
+from execsql.exporters.pretty import prettyprint_query, prettyprint_rowset
+from execsql.exporters.raw import write_query_b64, write_query_raw
+from execsql.exporters.sqlite import write_query_to_sqlite
+from execsql.exporters.templates import report_query
+from execsql.exporters.values import write_query_to_values
+from execsql.exporters.xls import XlsFile, XlsxFile
+from execsql.exporters.xml import write_query_to_xml
+from execsql.importers.base import import_data_table
+from execsql.importers.csv import importfile, importtable
+from execsql.importers.feather import import_feather, import_parquet
+from execsql.importers.ods import importods, ods_data
+from execsql.importers.xls import importxls, xls_data
+from execsql.models import DataTable
+from execsql.script import current_script_line, read_sqlfile, substitute_vars
+from execsql.types import dbt_firebird
+from execsql.utils.errors import exception_desc
+from execsql.utils.fileio import check_dir, filewriter_close, filewriter_open_as_new, filewriter_write
+from execsql.utils.gui import ConsoleUIError
+from execsql.utils.strings import clean_words, fold_words, unquoted
+
+
+def _apply_output_dir(path: str) -> str:
+    """Prepend the configured --output-dir to *path* if it is a relative path.
+
+    If ``conf.export_output_dir`` is set and *path* is not absolute (and not
+    ``stdout``), the base directory is joined to *path* so that all EXPORT
+    output lands in the same directory without requiring scripts to hard-code
+    absolute paths.
+    """
+    output_dir = getattr(_state.conf, "export_output_dir", None)
+    if not output_dir:
+        return path
+    if path.lower() == "stdout":
+        return path
+    if Path(path).is_absolute():
+        return path
+    # Windows drive-letter paths are also absolute
+    if len(path) > 1 and path[1] == ":":
+        return path
+    return str(Path(output_dir) / path)
 
 
 def x_export(**kwargs: Any) -> None:
@@ -28,40 +79,42 @@ def x_export(**kwargs: Any) -> None:
     table = kwargs["table"]
     queryname = _state.dbs.current().schema_qualified_table_name(schema, table)
     select_stmt = f"select * from {queryname};"
-    outfile = kwargs["filename"]
+    outfile = _apply_output_dir(kwargs["filename"])
     description = kwargs["description"]
     tee = kwargs["tee"]
-    tee = False if not tee else True
+    tee = bool(tee)
     append = kwargs["append"]
-    append = True if append else False
+    append = bool(append)
     filefmt = kwargs["format"].lower()
-    zipfilename = kwargs["zipfilename"]
+    zipfilename = _apply_output_dir(kwargs["zipfilename"]) if kwargs["zipfilename"] else None
     if zipfilename is not None:
         if outfile.lower() == "stdout":
-            raise _state.ErrInfo("error", other_msg="Cannot write stdout to a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot write stdout to a zipfile.")
         elif len(outfile) > 1 and outfile[1] == ":":
-            raise _state.ErrInfo("error", other_msg="Cannot use a drive letter for a file path within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot use a drive letter for a file path within a zipfile.")
         if filefmt == "duckdb":
-            raise _state.ErrInfo("error", other_msg="Cannot export to the DuckDB format within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot export to the DuckDB format within a zipfile.")
         if filefmt == "sqlite":
-            raise _state.ErrInfo("error", other_msg="Cannot export to the SQLite format within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot export to the SQLite format within a zipfile.")
         if filefmt == "latex":
-            raise _state.ErrInfo("error", other_msg="Cannot export to the LaTeX format within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot export to the LaTeX format within a zipfile.")
         if filefmt == "feather":
-            raise _state.ErrInfo("error", other_msg="Cannot export to the feather format within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot export to the feather format within a zipfile.")
+        if filefmt == "parquet":
+            raise ErrInfo("error", other_msg="Cannot export to the parquet format within a zipfile.")
         if filefmt == "hdf5":
-            raise _state.ErrInfo("error", other_msg="Cannot export to the HDF5 format within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot export to the HDF5 format within a zipfile.")
         if filefmt == "ods":
-            raise _state.ErrInfo("error", other_msg="Cannot export to an ODS workbook within a zipfile.")
-    notype = True if kwargs.get("notype") else False
+            raise ErrInfo("error", other_msg="Cannot export to an ODS workbook within a zipfile.")
+    notype = bool(kwargs.get("notype"))
     if zipfilename is not None:
-        _state.check_dir(zipfilename)
+        check_dir(zipfilename)
     else:
-        _state.check_dir(outfile)
+        check_dir(outfile)
     if tee and outfile.lower() != "stdout":
-        _state.prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False, desc=description)
+        prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False, desc=description)
     if filefmt in ("txt", "text"):
-        _state.prettyprint_query(
+        prettyprint_query(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -70,7 +123,7 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt in ("txt-and", "text-and"):
-        _state.prettyprint_query(
+        prettyprint_query(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -80,7 +133,7 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "ods":
-        _state.write_query_to_ods(
+        write_query_to_ods(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -89,11 +142,11 @@ def x_export(**kwargs: Any) -> None:
             desc=description,
         )
     elif filefmt == "duckdb":
-        _state.write_query_to_duckdb(select_stmt, _state.dbs.current(), outfile, append, tablename=queryname)
+        write_query_to_duckdb(select_stmt, _state.dbs.current(), outfile, append, tablename=queryname)
     elif filefmt == "sqlite":
-        _state.write_query_to_sqlite(select_stmt, _state.dbs.current(), outfile, append, tablename=queryname)
+        write_query_to_sqlite(select_stmt, _state.dbs.current(), outfile, append, tablename=queryname)
     elif filefmt == "xml":
-        _state.write_query_to_xml(
+        write_query_to_xml(
             select_stmt,
             table,
             _state.dbs.current(),
@@ -103,7 +156,7 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "json":
-        _state.write_query_to_json(
+        write_query_to_json(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -112,7 +165,7 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt in ("json_ts", "json_tableschema"):
-        _state.write_query_to_json_ts(
+        write_query_to_json_ts(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -122,7 +175,7 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "values":
-        _state.write_query_to_values(
+        write_query_to_values(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -131,7 +184,7 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "html":
-        _state.write_query_to_html(
+        write_query_to_html(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -140,7 +193,7 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "cgi-html":
-        _state.write_query_to_cgi_html(
+        write_query_to_cgi_html(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -149,7 +202,7 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "latex":
-        _state.write_query_to_latex(
+        write_query_to_latex(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -158,23 +211,25 @@ def x_export(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "hdf5":
-        _state.write_query_to_hdf5(table, select_stmt, _state.dbs.current(), outfile, append, desc=description)
+        write_query_to_hdf5(table, select_stmt, _state.dbs.current(), outfile, append, desc=description)
     else:
         try:
             hdrs, rows = _state.dbs.current().select_rowsource(select_stmt)
-        except _state.ErrInfo:
+        except ErrInfo:
             raise
         except Exception:
-            raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+            raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
         if filefmt == "raw":
-            _state.write_query_raw(outfile, rows, _state.dbs.current().encoding, append, zipfile=zipfilename)
+            write_query_raw(outfile, rows, _state.dbs.current().encoding, append, zipfile=zipfilename)
         elif filefmt == "b64":
-            _state.write_query_b64(outfile, rows, append)
+            write_query_b64(outfile, rows, append)
         elif filefmt == "feather":
-            _state.write_query_to_feather(outfile, hdrs, rows)
+            write_query_to_feather(outfile, hdrs, rows)
+        elif filefmt == "parquet":
+            write_query_to_parquet(outfile, hdrs, rows)
         else:
-            _state.write_delimited_file(outfile, filefmt, hdrs, rows, _state.conf.output_encoding, append, zipfilename)
-    _state.export_metadata.add(_state.ExportRecord(queryname, outfile, zipfilename, description))
+            write_delimited_file(outfile, filefmt, hdrs, rows, _state.conf.output_encoding, append, zipfilename)
+    _state.export_metadata.add(ExportRecord(queryname, outfile, zipfilename, description))
     return None
 
 
@@ -183,30 +238,32 @@ def x_export_query(**kwargs: Any) -> None:
     outfile = kwargs["filename"]
     description = kwargs["description"]
     tee = kwargs["tee"]
-    tee = False if not tee else True
+    tee = bool(tee)
     append = kwargs["append"]
-    append = True if append else False
+    append = bool(append)
     filefmt = kwargs["format"].lower()
     zipfilename = kwargs["zipfilename"]
     if zipfilename is not None:
         if outfile == "stdout":
-            raise _state.ErrInfo("error", other_msg="Cannot write stdout to a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot write stdout to a zipfile.")
         elif len(outfile) > 1 and outfile[1] == ":":
-            raise _state.ErrInfo("error", other_msg="Cannot use a drive letter for a file path within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot use a drive letter for a file path within a zipfile.")
         if filefmt == "latex":
-            raise _state.ErrInfo("error", other_msg="Cannot export to the LaTeX format within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot export to the LaTeX format within a zipfile.")
         if filefmt == "feather":
-            raise _state.ErrInfo("error", other_msg="Cannot export to the feather format within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot export to the feather format within a zipfile.")
+        if filefmt == "parquet":
+            raise ErrInfo("error", other_msg="Cannot export to the parquet format within a zipfile.")
         if filefmt == "hdf5":
-            raise _state.ErrInfo("error", other_msg="Cannot export to the HDF5 format within a zipfile.")
+            raise ErrInfo("error", other_msg="Cannot export to the HDF5 format within a zipfile.")
         if filefmt == "ods":
-            raise _state.ErrInfo("error", other_msg="Cannot export to an ODS workbook within a zipfile.")
-    notype = True if kwargs.get("notype") else False
-    _state.check_dir(outfile)
+            raise ErrInfo("error", other_msg="Cannot export to an ODS workbook within a zipfile.")
+    notype = bool(kwargs.get("notype"))
+    check_dir(outfile)
     if tee and outfile.lower() != "stdout":
-        _state.prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False, desc=description)
+        prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False, desc=description)
     if filefmt in ("txt", "text"):
-        _state.prettyprint_query(
+        prettyprint_query(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -215,7 +272,7 @@ def x_export_query(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt in ("txt-and", "text-and"):
-        _state.prettyprint_query(
+        prettyprint_query(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -225,8 +282,8 @@ def x_export_query(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "ods":
-        script_name, lno = _state.current_script_line()
-        _state.write_query_to_ods(
+        script_name, lno = current_script_line()
+        write_query_to_ods(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -235,7 +292,7 @@ def x_export_query(**kwargs: Any) -> None:
             desc=description,
         )
     elif filefmt == "json":
-        _state.write_query_to_json(
+        write_query_to_json(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -244,7 +301,7 @@ def x_export_query(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt in ("json_ts", "json_tableschema"):
-        _state.write_query_to_json_ts(
+        write_query_to_json_ts(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -254,7 +311,7 @@ def x_export_query(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "values":
-        _state.write_query_to_values(
+        write_query_to_values(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -263,7 +320,7 @@ def x_export_query(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "html":
-        _state.write_query_to_html(
+        write_query_to_html(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -272,7 +329,7 @@ def x_export_query(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "cgi-html":
-        _state.write_query_to_cgi_html(
+        write_query_to_cgi_html(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -281,7 +338,7 @@ def x_export_query(**kwargs: Any) -> None:
             zipfile=zipfilename,
         )
     elif filefmt == "latex":
-        _state.write_query_to_latex(
+        write_query_to_latex(
             select_stmt,
             _state.dbs.current(),
             outfile,
@@ -292,18 +349,20 @@ def x_export_query(**kwargs: Any) -> None:
     else:
         try:
             hdrs, rows = _state.dbs.current().select_rowsource(select_stmt)
-        except _state.ErrInfo:
+        except ErrInfo:
             raise
         except Exception:
-            raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+            raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
         if filefmt == "raw":
-            _state.write_query_raw(outfile, rows, _state.dbs.current().encoding, append, zipfile=zipfilename)
+            write_query_raw(outfile, rows, _state.dbs.current().encoding, append, zipfile=zipfilename)
         elif filefmt == "b64":
-            _state.write_query_b64(outfile, rows, append, zipfile=zipfilename)
+            write_query_b64(outfile, rows, append, zipfile=zipfilename)
         elif filefmt == "feather":
-            _state.write_query_to_feather(outfile, hdrs, rows)
+            write_query_to_feather(outfile, hdrs, rows)
+        elif filefmt == "parquet":
+            write_query_to_parquet(outfile, hdrs, rows)
         else:
-            _state.write_delimited_file(
+            write_delimited_file(
                 outfile,
                 filefmt,
                 hdrs,
@@ -312,7 +371,7 @@ def x_export_query(**kwargs: Any) -> None:
                 append,
                 zipfile=zipfilename,
             )
-    _state.export_metadata.add(_state.ExportRecord(select_stmt, outfile, zipfilename, description))
+    _state.export_metadata.add(ExportRecord(select_stmt, outfile, zipfilename, description))
     return None
 
 
@@ -321,15 +380,15 @@ def x_export_query_with_template(**kwargs: Any) -> None:
     outfile = kwargs["filename"]
     template_file = kwargs["template"]
     tee = kwargs["tee"]
-    tee = False if not tee else True
+    tee = bool(tee)
     append = kwargs["append"]
-    append = True if append else False
+    append = bool(append)
     zipfilename = kwargs["zipfilename"]
-    _state.check_dir(outfile)
+    check_dir(outfile)
     if tee and outfile.lower() != "stdout":
-        _state.prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False)
-    _state.report_query(select_stmt, _state.dbs.current(), outfile, template_file, append, zipfile=zipfilename)
-    _state.export_metadata.add(_state.ExportRecord(select_stmt, outfile, zipfilename))
+        prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False)
+    report_query(select_stmt, _state.dbs.current(), outfile, template_file, append, zipfile=zipfilename)
+    _state.export_metadata.add(ExportRecord(select_stmt, outfile, zipfilename))
     return None
 
 
@@ -341,15 +400,15 @@ def x_export_with_template(**kwargs: Any) -> None:
     outfile = kwargs["filename"]
     template_file = kwargs["template"]
     tee = kwargs["tee"]
-    tee = False if not tee else True
+    tee = bool(tee)
     append = kwargs["append"]
-    append = True if append else False
+    append = bool(append)
     zipfilename = kwargs["zipfilename"]
-    _state.check_dir(outfile)
+    check_dir(outfile)
     if tee and outfile.lower() != "stdout":
-        _state.prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False)
-    _state.report_query(select_stmt, _state.dbs.current(), outfile, template_file, append, zipfile=zipfilename)
-    _state.export_metadata.add(_state.ExportRecord(queryname, outfile, zipfilename))
+        prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False)
+    report_query(select_stmt, _state.dbs.current(), outfile, template_file, append, zipfile=zipfilename)
+    _state.export_metadata.add(ExportRecord(queryname, outfile, zipfilename))
     return None
 
 
@@ -358,11 +417,11 @@ def x_export_ods_multiple(**kwargs: Any) -> None:
     outfile = kwargs["filename"]
     description = kwargs["description"]
     tee = kwargs["tee"]
-    tee = False if not tee else True
+    tee = bool(tee)
     append = kwargs["append"]
-    append = False if append is None else True
-    _state.check_dir(outfile)
-    _state.write_queries_to_ods(table_list, _state.dbs.current(), outfile, append, tee, desc=description)
+    append = append is not None
+    check_dir(outfile)
+    write_queries_to_ods(table_list, _state.dbs.current(), outfile, append, tee, desc=description)
 
 
 def x_export_metadata(**kwargs: Any) -> None:
@@ -376,11 +435,11 @@ def x_export_metadata(**kwargs: Any) -> None:
     else:
         hdrs, rows = _state.export_metadata.get()
     if outfile.lower() != "stdout":
-        _state.check_dir(outfile)
+        check_dir(outfile)
     if filefmt in ("txt", "text"):
-        _state.prettyprint_rowset(hdrs, rows, outfile, append, and_val="", zipfile=zipfilename)
+        prettyprint_rowset(hdrs, rows, outfile, append, and_val="", zipfile=zipfilename)
     else:
-        _state.write_delimited_file(outfile, filefmt, hdrs, rows, _state.conf.output_encoding, append, zipfilename)
+        write_delimited_file(outfile, filefmt, hdrs, rows, _state.conf.output_encoding, append, zipfilename)
 
 
 def x_export_metadata_table(**kwargs: Any) -> None:
@@ -396,7 +455,7 @@ def x_export_metadata_table(**kwargs: Any) -> None:
         hdrs, rows = _state.export_metadata.get_all()
     else:
         hdrs, rows = _state.export_metadata.get()
-    _state.import_data_table(_state.dbs.current(), schemaname, tablename, is_new, hdrs, rows)
+    import_data_table(_state.dbs.current(), schemaname, tablename, is_new, hdrs, rows)
 
 
 def x_import(**kwargs: Any) -> None:
@@ -409,9 +468,9 @@ def x_import(**kwargs: Any) -> None:
     tablename = kwargs["table"]
     filename = kwargs["filename"]
     if len(filename) > 1 and filename[0] == "~" and filename[1] == os.sep:
-        filename = os.path.join(os.path.expanduser(r"~"), filename[2:])
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+        filename = str(Path.home() / filename[2:])
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Input file {filename} does not exist",
@@ -436,7 +495,7 @@ def x_import(**kwargs: Any) -> None:
     sz, dt = file_size_date(filename)
     _state.exec_log.log_status_info(f"IMPORTing {filename} ({sz}, {dt})")
     try:
-        _state.importtable(
+        importtable(
             _state.dbs.current(),
             schemaname,
             tablename,
@@ -448,12 +507,12 @@ def x_import(**kwargs: Any) -> None:
             encoding=enc,
             junk_header_lines=junk_hdrs,
         )
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo(
+        raise ErrInfo(
             "exception",
-            exception_msg=_state.exception_desc(),
+            exception_msg=exception_desc(),
             other_msg=f"Can't import data from tabular text file {filename}",
         )
     return None
@@ -464,8 +523,8 @@ def x_import_file(**kwargs: Any) -> None:
     tablename = kwargs["table"]
     columnname = kwargs["columnname"]
     filename = kwargs["filename"]
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Input file {filename} does not exist",
@@ -475,13 +534,13 @@ def x_import_file(**kwargs: Any) -> None:
     sz, dt = file_size_date(filename)
     _state.exec_log.log_status_info(f"IMPORTing_FILE {filename} ({sz}, {dt})")
     try:
-        _state.importfile(_state.dbs.current(), schemaname, tablename, columnname, filename)
-    except _state.ErrInfo:
+        importfile(_state.dbs.current(), schemaname, tablename, columnname, filename)
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo(
+        raise ErrInfo(
             "exception",
-            exception_msg=_state.exception_desc(),
+            exception_msg=exception_desc(),
             other_msg=f"Can't import file {filename}",
         )
     return None
@@ -502,20 +561,20 @@ def x_import_ods(**kwargs: Any) -> None:
         hdr_rows = 0
     else:
         hdr_rows = int(hdr_rows)
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg="Input file does not exist",
         )
     try:
-        _state.importods(_state.dbs.current(), schemaname, tablename, is_new, filename, sheetname, hdr_rows)
-    except _state.ErrInfo:
+        importods(_state.dbs.current(), schemaname, tablename, is_new, filename, sheetname, hdr_rows)
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo(
+        raise ErrInfo(
             "exception",
-            exception_msg=_state.exception_desc(),
+            exception_msg=exception_desc(),
             other_msg=f"Can't import data from ODS file {filename}",
         )
     return None
@@ -537,35 +596,35 @@ def x_import_ods_pattern(**kwargs: Any) -> None:
         hdr_rows = 0
     else:
         hdr_rows = int(hdr_rows)
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg="Input file does not exist",
         )
-    wbk = _state.OdsFile()
+    wbk = OdsFile()
     try:
         wbk.open(filename)
     except Exception:
-        raise _state.ErrInfo(type="cmd", other_msg=f"{filename} is not a valid OpenDocument spreadsheet.")
+        raise ErrInfo(type="cmd", other_msg=f"{filename} is not a valid OpenDocument spreadsheet.")
     sheets = wbk.sheetnames()
     impsheets = [s for s in sheets if rx.search(s)]
     tables = list(impsheets)
     if _state.conf.clean_col_hdrs:
-        tables = _state.clean_words(tables)
+        tables = clean_words(tables)
     if _state.conf.fold_col_hdrs != "no":
-        tables = _state.fold_words(tables, _state.conf.fold_col_hdrs)
+        tables = fold_words(tables, _state.conf.fold_col_hdrs)
     for ix in range(len(impsheets)):
         sheetname = impsheets[ix]
         tablename = tables[ix]
         try:
-            _state.importods(_state.dbs.current(), schemaname, tablename, is_new, filename, sheetname, hdr_rows)
-        except _state.ErrInfo:
+            importods(_state.dbs.current(), schemaname, tablename, is_new, filename, sheetname, hdr_rows)
+        except ErrInfo:
             raise
         except Exception:
-            raise _state.ErrInfo(
+            raise ErrInfo(
                 "exception",
-                exception_msg=_state.exception_desc(),
+                exception_msg=exception_desc(),
                 other_msg=f"Can't import data from ODS file {filename}",
             )
     _state.subvars.add_substitution("$SHEETS_IMPORTED", ",".join(impsheets))
@@ -593,20 +652,20 @@ def x_import_xls(**kwargs: Any) -> None:
         junk_hdrs = 0
     else:
         junk_hdrs = int(junk_hdrs)
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg="Input file does not exist",
         )
     try:
-        _state.importxls(_state.dbs.current(), schemaname, tablename, is_new, filename, sheetname, junk_hdrs, encoding)
-    except _state.ErrInfo:
+        importxls(_state.dbs.current(), schemaname, tablename, is_new, filename, sheetname, junk_hdrs, encoding)
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo(
+        raise ErrInfo(
             "exception",
-            exception_msg=_state.exception_desc(),
+            exception_msg=exception_desc(),
             other_msg=f"Can't import data from Excel file {filename}",
         )
     return None
@@ -629,37 +688,37 @@ def x_import_xls_pattern(**kwargs: Any) -> None:
         hdr_rows = 0
     else:
         hdr_rows = int(hdr_rows)
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg="Input file does not exist",
         )
     if len(filename) < 4:
-        raise _state.ErrInfo(type="cmd", other_msg=f"{filename} is not a recognizable Excel spreadsheet name.")
+        raise ErrInfo(type="cmd", other_msg=f"{filename} is not a recognizable Excel spreadsheet name.")
     ext3 = filename[-3:].lower()
     if ext3 == "xls":
-        wbk = _state.XlsFile()
+        wbk = XlsFile()
     elif ext3 == "lsx":
-        wbk = _state.XlsxFile()
+        wbk = XlsxFile()
     else:
-        raise _state.ErrInfo(type="cmd", other_msg=f"{filename} is not a recognizable Excel spreadsheet name.")
+        raise ErrInfo(type="cmd", other_msg=f"{filename} is not a recognizable Excel spreadsheet name.")
     try:
         wbk.open(filename, encoding, read_only=True)
     except Exception:
-        raise _state.ErrInfo(type="cmd", other_msg=f"{filename} is not a valid Excel spreadsheet.")
+        raise ErrInfo(type="cmd", other_msg=f"{filename} is not a valid Excel spreadsheet.")
     sheets = wbk.sheetnames()
     impsheets = [s for s in sheets if rx.search(s)]
     tables = list(impsheets)
     if _state.conf.clean_col_hdrs:
-        tables = _state.clean_words(tables)
+        tables = clean_words(tables)
     if _state.conf.fold_col_hdrs != "no":
-        tables = _state.fold_words(tables, _state.conf.fold_col_hdrs)
+        tables = fold_words(tables, _state.conf.fold_col_hdrs)
     for ix in range(len(impsheets)):
         sheetname = impsheets[ix]
         tablename = tables[ix]
         try:
-            _state.importxls(
+            importxls(
                 _state.dbs.current(),
                 schemaname,
                 tablename,
@@ -669,12 +728,12 @@ def x_import_xls_pattern(**kwargs: Any) -> None:
                 hdr_rows,
                 encoding,
             )
-        except _state.ErrInfo:
+        except ErrInfo:
             raise
         except Exception:
-            raise _state.ErrInfo(
+            raise ErrInfo(
                 "exception",
-                exception_msg=_state.exception_desc(),
+                exception_msg=exception_desc(),
                 other_msg=f"Can't import data from ODS file {filename}",
             )
     _state.subvars.add_substitution("$SHEETS_IMPORTED", ",".join(impsheets))
@@ -696,9 +755,9 @@ def x_import_parquet(**kwargs: Any) -> None:
     tablename = kwargs["table"]
     filename = kwargs["filename"]
     if len(filename) > 1 and filename[0] == "~" and filename[1] == os.sep:
-        filename = os.path.join(os.path.expanduser(r"~"), filename[2:])
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+        filename = str(Path.home() / filename[2:])
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Input file {filename} does not exist",
@@ -708,13 +767,13 @@ def x_import_parquet(**kwargs: Any) -> None:
     sz, dt = file_size_date(filename)
     _state.exec_log.log_status_info(f"IMPORTing from Parquet file {filename} ({sz}, {dt})")
     try:
-        _state.import_parquet(_state.dbs.current(), schemaname, tablename, filename, is_new)
-    except _state.ErrInfo:
+        import_parquet(_state.dbs.current(), schemaname, tablename, filename, is_new)
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo(
+        raise ErrInfo(
             "exception",
-            exception_msg=_state.exception_desc(),
+            exception_msg=exception_desc(),
             other_msg=f"Can't import data from Parquet data file {filename}",
         )
     return None
@@ -730,9 +789,9 @@ def x_import_feather(**kwargs: Any) -> None:
     tablename = kwargs["table"]
     filename = kwargs["filename"]
     if len(filename) > 1 and filename[0] == "~" and filename[1] == os.sep:
-        filename = os.path.join(os.path.expanduser(r"~"), filename[2:])
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+        filename = str(Path.home() / filename[2:])
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Input file {filename} does not exist",
@@ -742,13 +801,13 @@ def x_import_feather(**kwargs: Any) -> None:
     sz, dt = file_size_date(filename)
     _state.exec_log.log_status_info(f"IMPORTing from Feather file {filename} ({sz}, {dt})")
     try:
-        _state.import_feather(_state.dbs.current(), schemaname, tablename, filename, is_new)
-    except _state.ErrInfo:
+        import_feather(_state.dbs.current(), schemaname, tablename, filename, is_new)
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo(
+        raise ErrInfo(
             "exception",
-            exception_msg=_state.exception_desc(),
+            exception_msg=exception_desc(),
             other_msg=f"Can't import data from Feather data file {filename}",
         )
     return None
@@ -767,25 +826,25 @@ def x_export_row_buffer(**kwargs: Any) -> None:
 def x_write(**kwargs: Any) -> None:
     msg = f"{kwargs['text']}\n"
     tee = kwargs["tee"]
-    tee = False if not tee else True
+    tee = bool(tee)
     outf = kwargs["filename"]
     if _state.conf.write_prefix is not None:
-        msg = _state.substitute_vars(_state.conf.write_prefix) + " " + msg
+        msg = substitute_vars(_state.conf.write_prefix) + " " + msg
     if _state.conf.write_suffix is not None:
-        msg = msg[:-1] + " " + _state.substitute_vars(_state.conf.write_suffix) + "\n"
+        msg = msg[:-1] + " " + substitute_vars(_state.conf.write_suffix) + "\n"
     if outf:
-        _state.check_dir(outf)
-        _state.filewriter_write(outf, msg)
+        check_dir(outf)
+        filewriter_write(outf, msg)
     if (not outf) or tee:
         try:
             _state.output.write(msg)
         except TypeError:
-            raise _state.ErrInfo(
+            raise ErrInfo(
                 type="other",
                 command_text=kwargs["metacommandline"],
                 other_msg="TypeError in 'write' metacommand.",
             )
-        except _state.ConsoleUIError as e:
+        except ConsoleUIError as e:
             _state.output.reset()
             _state.exec_log.log_status_info(f"Console UI write failed (message {{{e.value}}}); output reset to stdout.")
             _state.output.write(msg.encode(_state.conf.output_encoding))
@@ -796,8 +855,8 @@ def x_write(**kwargs: Any) -> None:
 
 def x_write_create_table(**kwargs: Any) -> None:
     filename = kwargs["filename"]
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg="Input file does not exist",
@@ -815,8 +874,8 @@ def x_write_create_table(**kwargs: Any) -> None:
         junk_hdrs = 0
     else:
         junk_hdrs = int(junk_hdrs)
-    enc = _state.conf.import_encoding if not encoding else encoding
-    inf = _state.CsvFile(filename, enc, junk_header_lines=junk_hdrs)
+    enc = encoding if encoding else _state.conf.import_encoding
+    inf = CsvFile(filename, enc, junk_header_lines=junk_hdrs)
     if quotechar and delimchar:
         inf.lineformat(delimchar, quotechar, None)
     inf.evaluate_column_types()
@@ -829,10 +888,10 @@ def x_write_create_table(**kwargs: Any) -> None:
         if outfile is None or outfile == "stdout":
             _state.output.write(txt)
         else:
-            _state.filewriter_write(outfile, txt)
+            filewriter_write(outfile, txt)
 
     if outfile:
-        _state.check_dir(outfile)
+        check_dir(outfile)
     if comment:
         write(f"-- {comment}\n")
     write(f"{sql}\n")
@@ -850,20 +909,20 @@ def x_write_create_table_ods(**kwargs: Any) -> None:
         hdr_rows = int(hdr_rows)
     comment = kwargs["comment"]
     outfile = kwargs["outfile"]
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg="Input file does not exist",
         )
-    hdrs, data = _state.ods_data(filename, sheetname, hdr_rows)
-    tablespec = _state.DataTable(hdrs, data)
+    hdrs, data = ods_data(filename, sheetname, hdr_rows)
+    tablespec = DataTable(hdrs, data)
     sql = tablespec.create_table(_state.dbs.current().type, schemaname, tablename, pretty=True)
     if outfile:
         if comment:
-            _state.filewriter_write(outfile, f"-- {comment}\n")
-        _state.filewriter_write(outfile, sql)
-        _state.filewriter_close(outfile)
+            filewriter_write(outfile, f"-- {comment}\n")
+        filewriter_write(outfile, sql)
+        filewriter_close(outfile)
     else:
         if comment:
             _state.output.write(f"-- {comment}\n")
@@ -877,27 +936,27 @@ def x_write_create_table_xls(**kwargs: Any) -> None:
     sheetname = kwargs["sheet"]
     junk_hdrs = kwargs["skip"]
     encoding = kwargs["encoding"]
-    enc = _state.conf.import_encoding if not encoding else encoding
+    enc = encoding if encoding else _state.conf.import_encoding
     if not junk_hdrs:
         junk_hdrs = 0
     else:
         junk_hdrs = int(junk_hdrs)
     comment = kwargs["comment"]
     outfile = kwargs["outfile"]
-    if not os.path.exists(filename):
-        raise _state.ErrInfo(
+    if not Path(filename).exists():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg="Input file does not exist",
         )
-    hdrs, data = _state.xls_data(filename, sheetname, junk_hdrs, enc)
-    tablespec = _state.DataTable(hdrs, data)
+    hdrs, data = xls_data(filename, sheetname, junk_hdrs, enc)
+    tablespec = DataTable(hdrs, data)
     sql = tablespec.create_table(_state.dbs.current().type, schemaname, tablename, pretty=True)
     if outfile:
         if comment:
-            _state.filewriter_write(outfile, f"-- {comment}\n")
-        _state.filewriter_write(outfile, sql)
-        _state.filewriter_close(outfile)
+            filewriter_write(outfile, f"-- {comment}\n")
+        filewriter_write(outfile, sql)
+        filewriter_close(outfile)
     else:
         if comment:
             _state.output.write(f"-- {comment}\n")
@@ -911,7 +970,7 @@ def x_write_create_table_alias(**kwargs: Any) -> None:
     comment = kwargs["comment"]
     outfile = kwargs["filename"]
     if alias not in _state.dbs.aliases():
-        raise _state.ErrInfo(
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Unrecognized database alias: {alias}.",
@@ -920,27 +979,27 @@ def x_write_create_table_alias(**kwargs: Any) -> None:
     tbl = db.schema_qualified_table_name(schema, table)
     try:
         if not db.table_exists(table, schema):
-            raise _state.ErrInfo(
+            raise ErrInfo(
                 type="cmd",
                 command_text=kwargs["metacommandline"],
                 other_msg=f"Table {tbl} does not exist",
             )
     except Exception:
-        pass
+        pass  # Best-effort check; some adapters lack information_schema.
     select_stmt = f"select * from {tbl};"
     try:
         hdrs, rows = db.select_rowsource(select_stmt)
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
-    tablespec = _state.DataTable(hdrs, rows)
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
+    tablespec = DataTable(hdrs, rows)
     sql = tablespec.create_table(_state.dbs.current().type, kwargs["schema1"], kwargs["table1"], pretty=True)
     if outfile:
         if comment:
-            _state.filewriter_write(outfile, f"-- {comment}\n")
-        _state.filewriter_write(outfile, sql)
-        _state.filewriter_close(outfile)
+            filewriter_write(outfile, f"-- {comment}\n")
+        filewriter_write(outfile, sql)
+        filewriter_close(outfile)
     else:
         if comment:
             _state.output.write(f"-- {comment}\n")
@@ -974,12 +1033,12 @@ def x_writescript(**kwargs: Any) -> None:
         if output_dest is None or output_dest == "stdout":
             _state.output.write(txt)
         else:
-            _state.filewriter_write(output_dest, txt)
+            filewriter_write(output_dest, txt)
 
     if output_dest is not None and output_dest != "stdout":
-        _state.check_dir(output_dest)
+        check_dir(output_dest)
         if not append:
-            _state.filewriter_open_as_new(output_dest)
+            filewriter_open_as_new(output_dest)
     script = _state.savedscripts[script_id]
     if script.paramnames is not None and len(script.paramnames) > 0:
         write(f"BEGIN SCRIPT {script_id} ({', '.join(script.paramnames)})\n")
@@ -994,15 +1053,15 @@ def x_writescript(**kwargs: Any) -> None:
 def x_include(**kwargs: Any) -> None:
     filename = kwargs["filename"]
     if len(filename) > 1 and filename[0] == "~" and filename[1] == os.sep:
-        filename = os.path.join(os.path.expanduser(r"~"), filename[2:])
+        filename = str(Path.home() / filename[2:])
     exists = kwargs["exists"]
     if exists is not None:
-        if os.path.isfile(filename):
-            _state.read_sqlfile(filename)
+        if Path(filename).is_file():
+            read_sqlfile(filename)
     else:
-        if not os.path.isfile(filename):
-            raise _state.ErrInfo(type="error", other_msg=f"File {filename} does not exist.")
-        _state.read_sqlfile(filename)
+        if not Path(filename).is_file():
+            raise ErrInfo(type="error", other_msg=f"File {filename} does not exist.")
+        read_sqlfile(filename)
     return None
 
 
@@ -1016,13 +1075,13 @@ def x_copy(**kwargs: Any) -> None:
     schema2 = kwargs["schema2"]
     table2 = kwargs["table2"]
     if alias1 not in _state.dbs.aliases():
-        raise _state.ErrInfo(
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Unrecognized database alias: {alias1}.",
         )
     if alias2 not in _state.dbs.aliases():
-        raise _state.ErrInfo(
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Unrecognized database alias: {alias2}.",
@@ -1033,29 +1092,29 @@ def x_copy(**kwargs: Any) -> None:
     tbl2 = db2.schema_qualified_table_name(schema2, table2)
     try:
         if not db1.table_exists(table1, schema1):
-            raise _state.ErrInfo(
+            raise ErrInfo(
                 type="cmd",
                 command_text=kwargs["metacommandline"],
                 other_msg=f"Table {tbl1} does not exist",
             )
     except Exception:
-        pass
+        pass  # Best-effort check; some adapters lack information_schema.
     if new_tbl2 and new_tbl2 == "new":
         try:
             if db2.table_exists(table2, schema2):
-                raise _state.ErrInfo(
+                raise ErrInfo(
                     type="cmd",
                     command_text=kwargs["metacommandline"],
                     other_msg=f"Table {tbl2} already exists",
                 )
         except Exception:
-            pass
+            pass  # Best-effort check; some adapters lack information_schema.
     select_stmt = f"select * from {tbl1};"
 
-    def get_ts() -> _state.DataTable:
+    def get_ts() -> DataTable:
         if get_ts.tablespec is None:
             hdrs, rows = db1.select_rowsource(select_stmt)
-            get_ts.tablespec = _state.DataTable(hdrs, rows)
+            get_ts.tablespec = DataTable(hdrs, rows)
         return get_ts.tablespec
 
     get_ts.tablespec = None
@@ -1069,21 +1128,21 @@ def x_copy(**kwargs: Any) -> None:
             except Exception:
                 _state.exec_log.log_status_info(f"Could not drop existing table ({tbl2}) for COPY metacommand")
         db2.execute(create_tbl)
-        if db2.type == _state.dbt_firebird:
+        if db2.type == dbt_firebird:
             db2.execute("COMMIT;")
     try:
         hdrs, rows = db1.select_rowsource(select_stmt)
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
     try:
         db2.populate_table(schema2, table2, rows, hdrs, get_ts)
         db2.commit()
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
 
 
 def x_copy_query(**kwargs: Any) -> None:
@@ -1095,13 +1154,13 @@ def x_copy_query(**kwargs: Any) -> None:
     schema2 = kwargs["schema"]
     table2 = kwargs["table"]
     if alias1 not in _state.dbs.aliases():
-        raise _state.ErrInfo(
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Unrecognized database alias: {alias1}.",
         )
     if alias2 not in _state.dbs.aliases():
-        raise _state.ErrInfo(
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Unrecognized database alias: {alias2}.",
@@ -1112,18 +1171,18 @@ def x_copy_query(**kwargs: Any) -> None:
     if new_tbl2 and new_tbl2 == "new":
         try:
             if db2.table_exists(table2, schema2):
-                raise _state.ErrInfo(
+                raise ErrInfo(
                     type="cmd",
                     command_text=kwargs["metacommandline"],
                     other_msg=f"Table {tbl2} already exists",
                 )
         except Exception:
-            pass
+            pass  # Best-effort check; some adapters lack information_schema.
 
-    def get_ts() -> _state.DataTable:
+    def get_ts() -> DataTable:
         if not get_ts.tablespec:
             hdrs, rows = db1.select_rowsource(select_stmt)
-            get_ts.tablespec = _state.DataTable(hdrs, rows)
+            get_ts.tablespec = DataTable(hdrs, rows)
         return get_ts.tablespec
 
     get_ts.tablespec = None
@@ -1131,11 +1190,11 @@ def x_copy_query(**kwargs: Any) -> None:
     if new_tbl2:
         try:
             hdrs, rows = db1.select_rowsource(select_stmt)
-        except _state.ErrInfo:
+        except ErrInfo:
             raise
         except Exception:
-            raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
-        get_ts.tablespec = _state.DataTable(hdrs, rows)
+            raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
+        get_ts.tablespec = DataTable(hdrs, rows)
         tbl_desc = get_ts.tablespec
         create_tbl = tbl_desc.create_table(db2.type, schema2, table2)
         if new_tbl2 == "replacement":
@@ -1144,21 +1203,21 @@ def x_copy_query(**kwargs: Any) -> None:
             except Exception:
                 _state.exec_log.log_status_info(f"Could not drop existing table ({tbl2}) for COPY metacommand")
         db2.execute(create_tbl)
-        if db2.type == _state.dbt_firebird:
+        if db2.type == dbt_firebird:
             db2.execute("COMMIT;")
     try:
         hdrs, rows = db1.select_rowsource(select_stmt)
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
     try:
         db2.populate_table(schema2, table2, rows, hdrs, get_ts)
         db2.commit()
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
     except Exception:
-        raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
 
 
 def x_zip(**kwargs: Any) -> None:
@@ -1172,7 +1231,7 @@ def x_zip(**kwargs: Any) -> None:
     zf = _zipfile.ZipFile(zipfile_name, mode=zmode, compression=_zipfile.ZIP_BZIP2, compresslevel=9)
     fnlist = _glob.glob(files)
     for f in fnlist:
-        if os.path.isfile(f):
+        if Path(f).is_file():
             zf.write(f)
     zf.close()
 
@@ -1188,8 +1247,8 @@ def x_rm_file(**kwargs: Any) -> None:
     fn = kwargs["filename"].strip(' "')
     fnlist = _glob.glob(fn)
     for f in fnlist:
-        if os.path.isfile(f):
-            _state.filewriter_close(f)
+        if Path(f).is_file():
+            filewriter_close(f)
             os.unlink(f)
 
 
@@ -1199,15 +1258,15 @@ def x_make_export_dirs(**kwargs: Any) -> None:
 
 
 def x_cd(**kwargs: Any) -> None:
-    new_dir = _state.unquoted(kwargs["dir"])
-    if not os.path.isdir(new_dir):
-        raise _state.ErrInfo(
+    new_dir = unquoted(kwargs["dir"])
+    if not Path(new_dir).is_dir():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg="Directory does not exist",
         )
     os.chdir(new_dir)
-    script, lno = _state.current_script_line()
+    script, lno = current_script_line()
     _state.exec_log.log_status_info(f"Current directory changed to {new_dir} at line {lno} of {script}")
     return None
 
@@ -1223,13 +1282,13 @@ def x_hdf5_text_len(**kwargs: Any) -> None:
 def x_serve(**kwargs: Any) -> None:
     infname = kwargs["filename"]
     fmt = kwargs["format"].lower()
-    if not os.path.isfile(infname):
-        raise _state.ErrInfo(
+    if not Path(infname).is_file():
+        raise ErrInfo(
             type="cmd",
             command_text=kwargs["metacommandline"],
             other_msg=f"Input file {infname} does not exist",
         )
-    fname = os.path.basename(infname)
+    fname = Path(infname).name
     if fmt == "binary":
         contenttype = "application/octet-stream"
     elif fmt == "csv":