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

execsql/exporters/delimited.py

@@ -16,21 +16,22 @@ Provides:
 """
 
 import copy
-import csv
-import codecs
-import io
-import os
 import re
 import sys
-from typing import Any, Optional, List
+from typing import Any
 
 from execsql.utils.fileio import EncodedFile
-from execsql.exporters.zip import WriteableZipfile, ZipWriter
+from execsql.exporters.zip import ZipWriter
 import execsql.state as _state
+from execsql.exceptions import ErrInfo
+from execsql.models import DataTable
+from execsql.utils.errors import exception_desc
+from execsql.utils.fileio import filewriter_close
+from execsql.utils.strings import clean_words, fold_words
 
 
 class LineDelimiter:
-    def __init__(self, delim: Optional[str], quote: Optional[str], escchar: Optional[str]) -> None:
+    def __init__(self, delim: str | None, quote: str | None, escchar: str | None) -> None:
         self.delimiter = delim
         self.joinchar = delim if delim else ""
         self.quotechar = quote
@@ -78,7 +79,7 @@ class LineDelimiter:
 
 
 class DelimitedWriter:
-    def __init__(self, outfile: Any, delim: Optional[str], quote: Optional[str], escchar: Optional[str]) -> None:
+    def __init__(self, outfile: Any, delim: str | None, quote: str | None, escchar: str | None) -> None:
         self.outfile = outfile
         self.line_delimiter = LineDelimiter(delim, quote, escchar)
 
@@ -98,16 +99,16 @@ class CsvWriter:
         self,
         filename: str,
         file_encoding: str,
-        delim: Optional[str],
-        quote: Optional[str],
-        escchar: Optional[str],
+        delim: str | None,
+        quote: str | None,
+        escchar: str | None,
         append: bool = False,
     ) -> None:
         mode = "wt" if not append else "at"
         if filename.lower() == "stdout":
             self.output = sys.stdout
         else:
-            _state.filewriter_close(filename)
+            filewriter_close(filename)
             self.output = EncodedFile(filename, file_encoding).open(mode)
         self.dwriter = DelimitedWriter(self.output, delim, quote, escchar)
 
@@ -144,11 +145,11 @@ class CsvFile(EncodedFile):
     def openclean(self, mode: str) -> Any:
         # Returns an opened file object with junk headers stripped.
         f = self.open(mode)
-        for l in range(self.junk_header_lines):
+        for _ in range(self.junk_header_lines):
             f.readline()
         return f
 
-    def lineformat(self, delimiter: Optional[str], quotechar: Optional[str], escapechar: Optional[str]) -> None:
+    def lineformat(self, delimiter: str | None, quotechar: str | None, escapechar: str | None) -> None:
         # Specifies the format of a line.
         self.delimiter = delimiter
         self.quotechar = quotechar
@@ -166,9 +167,10 @@ class CsvFile(EncodedFile):
         def __str__(self) -> str:
             return "; ".join(
                 [
-                    "Text: <<%s>>" % self.text,
-                    "Delimiter counts: <<%s>>"
-                    % ", ".join(["%s: %d" % (k, self.delim_counts[k]) for k in self.delim_counts.keys()]),
+                    f"Text: <<{self.text}>>",
+                    "Delimiter counts: <<{}>>".format(
+                        ", ".join([f"{k}: {self.delim_counts[k]}" for k in self.delim_counts]),
+                    ),
                 ],
             )
 
@@ -212,7 +214,7 @@ class CsvFile(EncodedFile):
         def record_format_error(self, pos_no: int, errmsg: str) -> None:
             self.item_errors.append(f"{errmsg} in position {pos_no}.")
 
-        def items(self, delim: Optional[str], qchar: Optional[str]) -> Any:
+        def items(self, delim: str | None, qchar: str | None) -> Any:
             # Parses the line into a list of items, breaking it at delimiters that are not
             # within quoted stretches.
             self.item_errors = []
@@ -308,26 +310,26 @@ class CsvFile(EncodedFile):
 
             exec_vector = [in_quoted, escaped, quote_in_quoted, in_unquoted, between, delimited]
             state = _BETWEEN
-            for i, c in enumerate(self.text):
+            for i, c in enumerate(self.text):  # noqa: B007
                 state = exec_vector[state]()
             if len(esc_buf[0]) > 0:
                 current_element[0] += esc_buf[0]
             if len(current_element[0]) > 0:
                 elements.append(current_element[0])
             if len(self.item_errors) > 0:
-                raise _state.ErrInfo("error", other_msg=", ".join(self.item_errors))
+                raise ErrInfo("error", other_msg=", ".join(self.item_errors))
             return elements
 
-        def well_quoted_line(self, delim: Optional[str], qchar: Optional[str]):
+        def well_quoted_line(self, delim: str | None, qchar: str | None):
             # Returns a tuple of boolean, int, and boolean
             wq = [self._well_quoted(el, qchar) for el in self.items(delim, qchar)]
-            return (all([b[0] for b in wq]), sum([b[1] for b in wq]), any([b[2] for b in wq]))
+            return (all(b[0] for b in wq), sum([b[1] for b in wq]), any(b[2] for b in wq))
 
     def diagnose_delim(
         self,
         linestream: Any,
-        possible_delimiters: Optional[List[str]] = None,
-        possible_quotechars: Optional[List[str]] = None,
+        possible_delimiters: list[str] | None = None,
+        possible_quotechars: list[str] | None = None,
     ):
         # Returns a tuple consisting of the delimiter, quote character, and escape
         # character for quote characters within elements of a line.  All may be None.
@@ -337,7 +339,7 @@ class CsvFile(EncodedFile):
         if not possible_quotechars:
             possible_quotechars = ['"', "'"]
         lines = []
-        for i in range(conf.scan_lines if conf.scan_lines and conf.scan_lines > 0 else 1000000):
+        for _i in range(conf.scan_lines if conf.scan_lines and conf.scan_lines > 0 else 1000000):
             try:
                 ln = next(linestream)
             except StopIteration:
@@ -349,7 +351,7 @@ class CsvFile(EncodedFile):
             if len(ln) > 0:
                 lines.append(self.CsvLine(ln))
         if len(lines) == 0:
-            raise _state.ErrInfo(type="error", other_msg="CSV diagnosis error: no lines read")
+            raise ErrInfo(type="error", other_msg="CSV diagnosis error: no lines read")
         for ln in lines:
             for d in possible_delimiters:
                 ln.count_delim(d)
@@ -366,11 +368,11 @@ class CsvFile(EncodedFile):
             del delim_stats[k]
 
         def all_well_quoted(delim, qchar):
-            wq = [l.well_quoted_line(delim, qchar) for l in lines]
+            wq = [ln.well_quoted_line(delim, qchar) for ln in lines]
             return (
-                all([b[0] for b in wq]),
+                all(b[0] for b in wq),
                 sum([b[1] for b in wq]),
-                self.CsvLine.escchar if any([b[2] for b in wq]) else None,
+                self.CsvLine.escchar if any(b[2] for b in wq) else None,
             )
 
         def eval_quotes(delim):
@@ -385,20 +387,19 @@ class CsvFile(EncodedFile):
                 max_use = max([v[0] for v in ok_quotes.values()])
                 if max_use == 0:
                     return (delim, None, None)
-                for q in ok_quotes.keys():
+                for q in ok_quotes:
                     if ok_quotes[q][0] == max_use:
                         return (delim, q, ok_quotes[q][1])
 
         if len(delim_stats) == 0:
             return eval_quotes(None)
         else:
-            if len(delim_stats) > 1:
-                if " " in delim_stats:
-                    del delim_stats[" "]
+            if len(delim_stats) > 1 and " " in delim_stats:
+                del delim_stats[" "]
             if len(delim_stats) == 1:
                 return eval_quotes(list(delim_stats)[0])
             delim_wts = {}
-            for d in delim_stats.keys():
+            for d in delim_stats:
                 delim_wts[d] = delim_stats[d][0] ** 2 * delim_stats[d][1]
             delim_order = sorted(delim_wts, key=delim_wts.get, reverse=True)
             for d in delim_order:
@@ -406,7 +407,7 @@ class CsvFile(EncodedFile):
                 if quote_check[0] and quote_check[1]:
                     return quote_check
             return (delim_order[0], None, None)
-        raise _state.ErrInfo(
+        raise ErrInfo(
             type="error",
             other_msg="CSV diagnosis coding error: an untested set of conditions are present",
         )
@@ -420,7 +421,7 @@ class CsvFile(EncodedFile):
     def _record_format_error(self, pos_no: int, errmsg: str) -> None:
         self.parse_errors.append(f"{errmsg} in position {pos_no}")
 
-    def read_and_parse_line(self, f: Any) -> List:
+    def read_and_parse_line(self, f: Any) -> list:
         # Returns a list of line elements, parsed according to the established delimiter and quotechar.
         elements = []
         eat_multiple_delims = self.delimiter == " "
@@ -562,7 +563,7 @@ class CsvFile(EncodedFile):
                 state = exec_vector[state]()
         end()
         if len(self.parse_errors) > 0:
-            raise _state.ErrInfo("error", other_msg=", ".join(self.parse_errors))
+            raise ErrInfo("error", other_msg=", ".join(self.parse_errors))
         return elements
 
     def reader(self) -> Any:
@@ -574,8 +575,8 @@ class CsvFile(EncodedFile):
             line_no += 1
             try:
                 elements = self.read_and_parse_line(f)
-            except _state.ErrInfo as e:
-                raise _state.ErrInfo("error", other_msg=f"{e.other} on line {line_no}.")
+            except ErrInfo as e:
+                raise ErrInfo("error", other_msg=f"{e.other} on line {line_no}.") from e
             except:
                 raise
             if len(elements) > 0:
@@ -592,20 +593,20 @@ class CsvFile(EncodedFile):
     def writer(self, append: bool = False) -> CsvWriter:
         return CsvWriter(self.filename, self.encoding, self.delimiter, self.quotechar, self.escapechar, append)
 
-    def _colhdrs(self, inf: Any) -> List[str]:
+    def _colhdrs(self, inf: Any) -> list[str]:
         conf = _state.conf
         try:
             colnames = next(inf)
-        except _state.ErrInfo as e:
+        except ErrInfo as e:
             e.other = f"Can't read column header line from {self.filename}.  {e.other or ''}"
-            raise e
-        except:
-            raise _state.ErrInfo(
+            raise
+        except Exception:
+            raise ErrInfo(
                 type="exception",
-                exception_msg=_state.exception_desc(),
+                exception_msg=exception_desc(),
                 other_msg=f"Can't read column header line from {self.filename}",
             )
-        if any([x is None or len(x) == 0 for x in colnames]):
+        if any(x is None or len(x) == 0 for x in colnames):
             if conf.del_empty_cols:
                 self.blank_cols = [
                     i for i in range(len(colnames)) if colnames[i] is None or len(colnames[i].strip()) == 0
@@ -620,19 +621,19 @@ class CsvFile(EncodedFile):
                         if colnames[i] is None or len(colnames[i]) == 0:
                             colnames[i] = f"Col{i + 1}"
                 else:
-                    raise _state.ErrInfo(
+                    raise ErrInfo(
                         type="error",
                         other_msg=f"The input file {self.csvfname} has missing column headers.",
                     )
         if conf.clean_col_hdrs:
-            colnames = _state.clean_words(colnames)
+            colnames = clean_words(colnames)
         if conf.fold_col_hdrs != "no":
-            colnames = _state.fold_words(colnames, conf.fold_col_hdrs)
+            colnames = fold_words(colnames, conf.fold_col_hdrs)
         if conf.dedup_col_hdrs:
             colnames = _state.dedup_words(colnames)
         return colnames
 
-    def column_headers(self) -> List[str]:
+    def column_headers(self) -> list[str]:
         if not self.lineformat_set:
             self.evaluate_line_format()
         inf = self.reader()
@@ -648,20 +649,20 @@ class CsvFile(EncodedFile):
             self.evaluate_line_format()
         inf = self.reader()
         colnames = self._colhdrs(inf)
-        self.table_data = _state.DataTable(colnames, inf)
+        self.table_data = DataTable(colnames, inf)
 
-    def create_table(self, database_type: Any, schemaname: Optional[str], tablename: str, pretty: bool = False) -> str:
+    def create_table(self, database_type: Any, schemaname: str | None, tablename: str, pretty: bool = False) -> str:
         return self.table_data.create_table(database_type, schemaname, tablename, pretty)
 
 
 def write_delimited_file(
     outfile: str,
     filefmt: str,
-    column_headers: List[str],
+    column_headers: list[str],
     rowsource: Any,
     file_encoding: str = "utf8",
     append: bool = False,
-    zipfile: Optional[str] = None,
+    zipfile: str | None = None,
 ) -> None:
     delim = None
     quote = None
@@ -696,7 +697,7 @@ def write_delimited_file(
         fdesc = f"{outfile} in {zipfile}"
     else:
         fmode = "w" if not append else "a"
-        _state.filewriter_close(outfile)
+        filewriter_close(outfile)
         ofile = EncodedFile(outfile, file_encoding).open(mode=fmode)
         fdesc = outfile
     if not (filefmt.lower() == "plain" or (append and zipfile is None)):
@@ -706,11 +707,11 @@ def write_delimited_file(
         try:
             datarow = line_delimiter.delimited(rec)
             ofile.write(datarow)
-        except _state.ErrInfo:
+        except ErrInfo:
             raise
-        except:
-            raise _state.ErrInfo(
+        except Exception:
+            raise ErrInfo(
                 "exception",
-                exception_msg=_state.exception_desc(),
+                exception_msg=exception_desc(),
                 other_msg=f"Can't write output to file {fdesc}.",
             )

execsql/exporters/duckdb.py

@@ -9,16 +9,16 @@ Requires the ``execsql2[duckdb]`` extra.
 """
 
 import math
-import os
-from typing import Any, List, Optional
+from pathlib import Path
+from typing import Any
 
 from execsql.exceptions import ErrInfo
-import execsql.state as _state
+from execsql.types import dbt_duckdb
 
 
 def export_duckdb(
     outfile: str,
-    hdrs: List[str],
+    hdrs: list[str],
     rows: Any,
     append: bool,
     tablename: str,
@@ -32,13 +32,12 @@ def export_duckdb(
         return
 
     from execsql.models import DataTable
-    from execsql.utils.errors import exception_info
 
     chunksize = 10000
-    pre_exist = os.path.isfile(outfile)
+    pre_exist = Path(outfile).is_file()
     ddb = duckdb.connect(outfile, read_only=False)
     if pre_exist:
-        catalog = os.path.splitext(os.path.split(outfile)[1])[0]
+        catalog = Path(outfile).stem
         curs = ddb.cursor()
         res = curs.execute(
             f"select count(*) as rows from information_schema.tables "
@@ -49,14 +48,11 @@ def export_duckdb(
             if append:
                 raise ErrInfo(type="error", other_msg=f"The table {tablename} already exists in {outfile}.")
             else:
-                from execsql.utils.fileio import Logger
-
                 curs.execute(f"drop table {tablename};")
         curs.close()
     # Construct and run the CREATE TABLE statement
     rowdata = list(rows)
     tablespec = DataTable(hdrs, rowdata)
-    dbt_duckdb = _state.dbt_duckdb
     sql = tablespec.create_table(dbt_duckdb, schemaname=None, tablename=tablename)
     curs = ddb.cursor()
     curs.execute(sql)
@@ -83,12 +79,12 @@ def write_query_to_duckdb(
     append: bool,
     tablename: str,
 ) -> None:
-    from execsql.utils.errors import exception_info
+    from execsql.utils.errors import exception_desc
 
     try:
         hdrs, rows = db.select_rowsource(select_stmt)
     except ErrInfo:
         raise
     except Exception:
-        raise ErrInfo("db", select_stmt, exception_msg=exception_info())
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
     export_duckdb(outfile, hdrs, rows, append, tablename)

execsql/exporters/feather.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+from execsql.exceptions import ErrInfo
 
 """
 Apache Feather and HDF5 export for execsql.
@@ -9,24 +10,31 @@ and ``tables``).  Used by ``EXPORT … FORMAT feather`` and
 ``FORMAT hdf5``.  Both packages are optional dependencies.
 """
 
-from typing import Any, Optional, List
+from typing import Any
 
 import execsql.state as _state
+from execsql.models import DataTable
+from execsql.types import DT_Boolean, DT_Date, DT_Timestamp, DT_TimestampTZ
+from execsql.utils.errors import exception_desc
+from execsql.utils.fileio import filewriter_close
 
 
-def write_query_to_feather(outfile: str, headers: List[str], rows: Any) -> None:
+def write_query_to_feather(outfile: str, headers: list[str], rows: Any) -> None:
     try:
-        import pandas as pd
-        import pyarrow.feather
-    except:
-        raise _state.ErrInfo(
+        import polars as pl
+    except ImportError:
+        raise ErrInfo(
             "exception",
-            exception_msg=_state.exception_desc(),
-            other_msg="The pandas and pyarrow Python packages must be installed to export data to the feather format.",
+            exception_msg=exception_desc(),
+            other_msg="The polars Python package must be installed to export data to the feather format.",
         )
-    df = pd.DataFrame(rows, columns=headers)
-    _state.filewriter_close(outfile)
-    pyarrow.feather.write_feather(df, outfile)
+    rows_list = list(rows)
+    if rows_list:
+        df = pl.DataFrame(rows_list, schema=headers, orient="row")
+    else:
+        df = pl.DataFrame({h: [] for h in headers})
+    filewriter_close(outfile)
+    df.write_ipc(outfile)
 
 
 def write_query_to_hdf5(
@@ -35,22 +43,22 @@ def write_query_to_hdf5(
     db: Any,
     outfile: str,
     append: bool = False,
-    desc: Optional[str] = None,
+    desc: str | None = None,
 ) -> None:
     try:
         import tables
-    except:
-        raise _state.ErrInfo(
+    except ImportError:
+        raise ErrInfo(
             "exception",
-            exception_msg=_state.exception_desc(),
+            exception_msg=exception_desc(),
             other_msg="The tables Python library must be installed to export data to the HDF5 format.",
         )
     try:
         hdrs, rows = db.select_rowsource(select_stmt)
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
-    except:
-        raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+    except Exception:
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
 
     def h5type(datatype, size):
         if datatype in (_state.DT_Varchar, _state.DT_Text):
@@ -65,29 +73,29 @@ def write_query_to_hdf5(
         elif datatype in (_state.DT_Float, _state.DT_Decimal):
             t = tables.Float64Col()
             do_cast = False
-        elif datatype == _state.DT_Boolean:
+        elif datatype == DT_Boolean:
             t = tables.BoolCol()
             do_cast = False
-        elif datatype in (_state.DT_TimestampTZ, _state.DT_Timestamp, _state.DT_Date, _state.DT_Time):
+        elif datatype in (DT_TimestampTZ, DT_Timestamp, DT_Date, _state.DT_Time):
             t = tables.StringCol(50)
             do_cast = True
         else:
-            raise _state.ErrInfo("error", other_msg=f"Invalid data type for export to HDF5: {repr(datatype)}")
+            raise ErrInfo("error", other_msg=f"Invalid data type for export to HDF5: {repr(datatype)}")
         return t, do_cast
 
     # Create a dictionary of column names with the HDF5 data types
-    tbl_desc = _state.DataTable(hdrs, rows)
+    tbl_desc = DataTable(hdrs, rows)
     h5type_dict = {}
     cast_flags = []
     # Iterate over hdrs instead of tbl_desc.cols to preserve column order.
-    for i, h in enumerate(hdrs):
+    for h in hdrs:
         dt = [col for col in tbl_desc.cols if col.name == h][0].dt
         # dt is a tuple of: 0: the column name; 1: the data type class; 2: the maximum length or None if NA; other info.
         h5typ, as_str = h5type(dt[1], dt[2])
         h5type_dict[h] = h5typ
         cast_flags.append(as_str)
     # Open the HDF5 table
-    _state.filewriter_close(outfile)
+    filewriter_close(outfile)
     h5file_mode = "a" if append else "w"
     h5file = tables.open_file(outfile, mode=h5file_mode)
     h5grp = h5file.create_group("/", table_name, title=desc)

execsql/exporters/html.py

@@ -11,25 +11,28 @@ CSS styling.
 
 import datetime
 import getpass
-import io
 import os
-import re
 import sys
 import tempfile
-from typing import Any, Optional, List
+from pathlib import Path
+from typing import Any
 
 import execsql.state as _state
 from execsql.exporters.zip import ZipWriter
+from execsql.exceptions import ErrInfo
+from execsql.script import current_script_line
+from execsql.utils.errors import exception_desc
+from execsql.utils.fileio import filewriter_close
 
 
 def export_html(
     outfile: str,
-    hdrs: List[str],
+    hdrs: list[str],
     rows: Any,
     append: bool = False,
-    querytext: Optional[str] = None,
-    desc: Optional[str] = None,
-    zipfile: Optional[str] = None,
+    querytext: str | None = None,
+    desc: str | None = None,
+    zipfile: str | None = None,
 ) -> None:
     conf = _state.conf
 
@@ -48,7 +51,7 @@ def export_html(
             f.write("</tr>\n")
         f.write("</tbody>\n</table>\n")
 
-    script, lno = _state.current_script_line()
+    script, lno = current_script_line()
     # If not append, write a complete HTML document with header and table.
     # If append and the file does not exist, write just the table.
     # If append and the file exists, R/W up to the </body> tag, write the table, write the remainder of the input.
@@ -57,7 +60,7 @@ def export_html(
             if outfile.lower() == "stdout":
                 f = sys.stdout
             else:
-                _state.filewriter_close(outfile)
+                filewriter_close(outfile)
                 from execsql.utils.fileio import EncodedFile
 
                 ef = EncodedFile(outfile, conf.output_encoding)
@@ -66,9 +69,9 @@ def export_html(
             f = ZipWriter(zipfile, outfile, append)
         f.write('<!DOCTYPE html>\n<html>\n<head>\n<meta charset="utf-8" />\n')
         if querytext:
-            descrip = f"Source: [{querytext}] with database {_state.dbs.current().name()} in script {os.path.abspath(script)}, line {lno}"
+            descrip = f"Source: [{querytext}] with database {_state.dbs.current().name()} in script {str(Path(script).resolve())}, line {lno}"
         else:
-            descrip = f"From database {_state.dbs.current().name()} in script {os.path.abspath(script)}, line {lno}"
+            descrip = f"From database {_state.dbs.current().name()} in script {str(Path(script).resolve())}, line {lno}"
         f.write(f'<meta name="description" content="{descrip}" />\n')
         datecontent = datetime.datetime.now().strftime("%Y-%m-%d")
         f.write(f'<meta name="created" content="{datecontent}" />\n')
@@ -104,7 +107,7 @@ def export_html(
         if outfile.lower() == "stdout":
             f = sys.stdout
             write_table(f)
-        elif not os.path.isfile(outfile):
+        elif not Path(outfile).is_file():
             from execsql.utils.fileio import EncodedFile
 
             ef = EncodedFile(outfile, conf.output_encoding)
@@ -112,7 +115,7 @@ def export_html(
             write_table(f)
             f.close()
         else:
-            _state.filewriter_close(outfile)
+            filewriter_close(outfile)
             from execsql.utils.fileio import EncodedFile
 
             ef = EncodedFile(outfile, conf.output_encoding)
@@ -144,12 +147,12 @@ def export_html(
 
 def export_cgi_html(
     outfile: str,
-    hdrs: List[str],
+    hdrs: list[str],
     rows: Any,
     append: bool = False,
-    querytext: Optional[str] = None,
-    desc: Optional[str] = None,
-    zipfile: Optional[str] = None,
+    querytext: str | None = None,
+    desc: str | None = None,
+    zipfile: str | None = None,
 ) -> None:
     conf = _state.conf
 
@@ -168,13 +171,13 @@ def export_cgi_html(
             f.write("</tr>\n")
         f.write("</tbody>\n</table>\n")
 
-    script, lno = _state.current_script_line()
-    if zipfile or not append or (append and not os.path.isfile(outfile)):
+    script, lno = current_script_line()
+    if zipfile or not append or (append and not Path(outfile).is_file()):
         if zipfile is None:
             if outfile.lower() == "stdout":
                 f = sys.stdout
             else:
-                _state.filewriter_close(outfile)
+                filewriter_close(outfile)
                 from execsql.utils.fileio import EncodedFile
 
                 ef = EncodedFile(outfile, conf.output_encoding)
@@ -203,15 +206,15 @@ def write_query_to_html(
     db: Any,
     outfile: str,
     append: bool = False,
-    desc: Optional[str] = None,
-    zipfile: Optional[str] = None,
+    desc: str | None = None,
+    zipfile: str | None = None,
 ) -> None:
     try:
         hdrs, rows = db.select_rowsource(select_stmt)
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
-    except:
-        raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+    except Exception:
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
     export_html(outfile, hdrs, rows, append, select_stmt, desc, zipfile=zipfile)
 
 
@@ -220,13 +223,13 @@ def write_query_to_cgi_html(
     db: Any,
     outfile: str,
     append: bool = False,
-    desc: Optional[str] = None,
-    zipfile: Optional[str] = None,
+    desc: str | None = None,
+    zipfile: str | None = None,
 ) -> None:
     try:
         hdrs, rows = db.select_rowsource(select_stmt)
-    except _state.ErrInfo:
+    except ErrInfo:
         raise
-    except:
-        raise _state.ErrInfo("db", select_stmt, exception_msg=_state.exception_desc())
+    except Exception:
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
     export_cgi_html(outfile, hdrs, rows, append, select_stmt, desc, zipfile=zipfile)