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

execsql/exporters/json.py

@@ -8,13 +8,14 @@ Provides :func:`write_query_to_json` (standard JSON array of objects) and
 both of which serialize a query result set to a file or stream.
 """
 
-import datetime
-import io
-import os
-from typing import Any, Optional, List
+from typing import Any
 
 import execsql.state as _state
 from execsql.exporters.zip import ZipWriter
+from execsql.exceptions import ErrInfo
+from execsql.models import DataTable
+from execsql.utils.errors import exception_desc
+from execsql.utils.fileio import filewriter_close
 
 
 def write_query_to_json(
@@ -22,8 +23,8 @@ def write_query_to_json(
     db: Any,
     outfile: str,
     append: bool = False,
-    desc: Optional[str] = None,
-    zipfile: Optional[str] = None,
+    desc: str | None = None,
+    zipfile: str | None = None,
 ) -> None:
     global json
     import json
@@ -31,12 +32,12 @@ def write_query_to_json(
     conf = _state.conf
     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())
     if zipfile is None:
-        _state.filewriter_close(outfile)
+        filewriter_close(outfile)
         from execsql.utils.fileio import EncodedFile
 
         ef = EncodedFile(outfile, conf.output_encoding)
@@ -69,19 +70,19 @@ def write_query_to_json_ts(
     outfile: str,
     append: bool = False,
     write_types: bool = True,
-    desc: Optional[str] = None,
-    zipfile: Optional[str] = None,
+    desc: str | None = None,
+    zipfile: str | None = None,
 ) -> None:
     conf = _state.conf
     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())
     max_col_idx = len(hdrs) - 1
     if zipfile is None:
-        _state.filewriter_close(outfile)
+        filewriter_close(outfile)
         from execsql.utils.fileio import EncodedFile
 
         ef = EncodedFile(outfile, conf.output_encoding)
@@ -98,7 +99,7 @@ def write_query_to_json_ts(
     f.write('  "fields": [\n')
     if write_types:
         # Scan the data to determine data types.
-        tbl_desc = _state.DataTable(hdrs, rows)
+        tbl_desc = DataTable(hdrs, rows)
         # Write the column descriptions to the header.
         # Iterate over hdrs instead of tbl_desc.cols to preserve column order.
         for i, h in enumerate(hdrs):

execsql/exporters/latex.py

@@ -8,11 +8,10 @@ set to a LaTeX ``tabular`` environment suitable for inclusion in a
 ``.tex`` document.
 """
 
-import io
 import os
-import re
 import tempfile
-from typing import Any, List, Optional
+from pathlib import Path
+from typing import Any
 
 from execsql.exceptions import ErrInfo
 from execsql.exporters.zip import WriteableZipfile
@@ -21,15 +20,14 @@ import execsql.state as _state
 
 def export_latex(
     outfile: str,
-    hdrs: List[str],
+    hdrs: list[str],
     rows: Any,
     append: bool = False,
-    querytext: Optional[str] = None,
-    desc: Optional[str] = None,
-    zipfile: Optional[Any] = None,
+    querytext: str | None = None,
+    desc: str | None = None,
+    zipfile: Any | None = None,
 ) -> None:
     from execsql.utils.fileio import EncodedFile
-    from execsql.utils.errors import exception_info
 
     def write_table(f: Any) -> None:
         f.write("\\begin{center}\n")
@@ -69,7 +67,7 @@ def export_latex(
         if outfile.lower() != "stdout":
             f.close()
     else:
-        if outfile.lower() == "stdout" or not os.path.isfile(outfile):
+        if outfile.lower() == "stdout" or not Path(outfile).is_file():
             if outfile.lower() == "stdout":
                 import sys
 
@@ -113,15 +111,15 @@ def write_query_to_latex(
     db: Any,
     outfile: str,
     append: bool = False,
-    desc: Optional[str] = None,
-    zipfile: Optional[Any] = None,
+    desc: str | None = None,
+    zipfile: Any | None = None,
 ) -> 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_latex(outfile, hdrs, rows, append, select_stmt, desc, zipfile=zipfile)

execsql/exporters/ods.py

@@ -11,13 +11,17 @@ Provides :func:`write_query_to_ods` (single-sheet export),
 
 import datetime
 import getpass
-import io
 import os
-import re
-from typing import Any, Optional, List
+from pathlib import Path
+from typing import Any
 
 import execsql.state as _state
 from execsql.exceptions import OdsFileError
+from execsql.exceptions import ErrInfo
+from execsql.script import current_script_line
+from execsql.utils.errors import exception_desc, fatal_error
+from execsql.utils.fileio import filewriter_close
+from execsql.utils.strings import unquoted
 
 
 class OdsFile:
@@ -27,20 +31,21 @@ class OdsFile:
     def __init__(self) -> None:
         global of
         try:
+            import of as of
             import of.opendocument
             import of.table
             import of.text
             import of.number
             import of.style
-        except:
-            _state.fatal_error("The odfpy library is needed to create OpenDocument spreadsheets.")
+        except ImportError:
+            fatal_error("The odfpy library is needed to create OpenDocument spreadsheets.")
         self.filename = None
         self.wbk = None
         self.cell_style_names = []
 
     def open(self, filename: str) -> None:
         self.filename = filename
-        if os.path.isfile(filename):
+        if Path(filename).is_file():
             self.wbk = of.opendocument.load(filename)
             # Get a list of all cell style names used, so as not to re-define them.
             for sty in self.wbk.automaticstyles.childNodes:
@@ -50,8 +55,8 @@ class OdsFile:
                         name = sty.getAttribute("name")
                         if name not in self.cell_style_names:
                             self.cell_style_names.append(name)
-                except:
-                    pass
+                except Exception:
+                    pass  # Skip nodes without expected attributes.
         else:
             self.wbk = of.opendocument.OpenDocumentSpreadsheet()
 
@@ -119,7 +124,7 @@ class OdsFile:
             self.wbk.automaticstyles.addElement(dts)
             self.cell_style_names.append(st_name)
 
-    def sheetnames(self) -> List[str]:
+    def sheetnames(self) -> list[str]:
         # Returns a list of the worksheet names in the specified ODS spreadsheet.
         return [sheet.getAttribute("name") for sheet in self.wbk.spreadsheet.getElementsByType(of.table.Table)]
 
@@ -133,7 +138,7 @@ class OdsFile:
                 sheet_no = int(sheetname)
                 if sheet_no < 1:
                     sheet_no = None
-            except:
+            except (ValueError, TypeError):
                 sheet_no = None
         if sheet_no is not None:
             for i, sheet in enumerate(self.wbk.spreadsheet.getElementsByType(of.table.Table)):
@@ -147,7 +152,7 @@ class OdsFile:
                     return sheet
         return None
 
-    def sheet_data(self, sheetname: Any, junk_header_rows: int = 0) -> List:
+    def sheet_data(self, sheetname: Any, junk_header_rows: int = 0) -> list:
         sheet = self.sheet_named(sheetname)
         if not sheet:
             raise OdsFileError(f"There is no sheet named {sheetname}")
@@ -166,19 +171,19 @@ class OdsFile:
                         repeat = spanned
                 ps = cell.getElementsByType(of.text.P)
                 if len(ps) == 0:
-                    for rr in range(int(repeat)):
+                    for _rr in range(int(repeat)):
                         p_content.append(None)
                 else:
                     for p in ps:
                         pval = str(p)
                         if len(pval) == 0:
-                            for rr in range(int(repeat)):
+                            for _rr in range(int(repeat)):
                                 p_content.append(None)
                         else:
-                            for rr in range(int(repeat)):
+                            for _rr in range(int(repeat)):
                                 p_content.append(pval)
                 if len(p_content) == 0:
-                    for rr in range(int(repeat)):
+                    for _rr in range(int(repeat)):
                         rowdata.append(None)
                 elif p_content[0] != "#":
                     rowdata.extend(p_content)
@@ -206,7 +211,7 @@ class OdsFile:
             if isinstance(item, bool):
                 # Booleans must be evaluated before numbers.
                 tc = of.table.TableCell(valuetype="boolean", value=1 if item else 0, stylename=style_name)
-            elif isinstance(item, float) or isinstance(item, int):
+            elif isinstance(item, (float, int)):
                 tc = of.table.TableCell(valuetype="float", value=item, stylename=style_name)
             elif isinstance(item, datetime.datetime):
                 self.define_iso_datetime_style()
@@ -245,9 +250,8 @@ class OdsFile:
         self.wbk.spreadsheet.addElement(of_table)
 
     def save_close(self) -> None:
-        ofile = io.open(self.filename, "wb")
-        self.wbk.write(ofile)
-        ofile.close()
+        with open(self.filename, "wb") as ofile:
+            self.wbk.write(ofile)
         self.filename = None
         self.wbk = None
 
@@ -258,16 +262,16 @@ class OdsFile:
 
 def export_ods(
     outfile: str,
-    hdrs: List[str],
+    hdrs: list[str],
     rows: Any,
     append: bool = False,
-    querytext: Optional[str] = None,
-    sheetname: Optional[str] = None,
-    desc: Optional[str] = None,
+    querytext: str | None = None,
+    sheetname: str | None = None,
+    desc: str | None = None,
 ) -> None:
     # If not given, determine the worksheet name to use.  The pattern is "Sheetx", where x is
     # the first integer for which there is not already a sheet name.
-    if append and os.path.isfile(outfile):
+    if append and Path(outfile).is_file():
         wbk = OdsFile()
         wbk.open(outfile)
         sheet_names = wbk.sheetnames()
@@ -282,8 +286,8 @@ def export_ods(
         wbk.close()
     else:
         sheet_name = sheetname or "Sheet1"
-        if os.path.isfile(outfile):
-            _state.filewriter_close(outfile)
+        if Path(outfile).is_file():
+            filewriter_close(outfile)
             os.unlink(outfile)
     wbk = OdsFile()
     wbk.open(outfile)
@@ -307,11 +311,11 @@ def export_ods(
     # Add information to the "Datasheets" sheet.
     datasheetlist = wbk.sheet_named(datasheet_name)
     if datasheetlist:
-        script, lno = _state.current_script_line()
+        script, lno = current_script_line()
         if querytext:
-            src = f"{querytext} with database {_state.dbs.current().name()}, with script {os.path.abspath(script)}, line {lno}"
+            src = f"{querytext} with database {_state.dbs.current().name()}, with script {str(Path(script).resolve())}, line {lno}"
         else:
-            src = f"From database {_state.dbs.current().name()}, with script {os.path.abspath(script)}, line {lno}"
+            src = f"From database {_state.dbs.current().name()}, with script {str(Path(script).resolve())}, line {lno}"
         wbk.add_row_to_sheet(
             (
                 sheet_name,
@@ -331,15 +335,15 @@ def write_query_to_ods(
     db: Any,
     outfile: str,
     append: bool = False,
-    sheetname: Optional[str] = None,
-    desc: Optional[str] = None,
+    sheetname: str | None = None,
+    desc: 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_ods(outfile, hdrs, rows, append, select_stmt, sheetname, desc)
 
 
@@ -349,7 +353,7 @@ def write_queries_to_ods(
     outfile: str,
     append: bool = False,
     tee: bool = False,
-    desc: Optional[str] = None,
+    desc: str | None = None,
 ) -> None:
     from execsql.exporters.pretty import prettyprint_query
     from execsql.exporters.base import ExportRecord
@@ -358,8 +362,8 @@ def write_queries_to_ods(
     if desc is not None:
         descriptions = [d.strip() for d in desc.split(",")]
         one_desc = len(descriptions) != len(tables)
-    if os.path.isfile(outfile) and not append:
-        _state.filewriter_close(outfile)
+    if Path(outfile).is_file() and not append:
+        filewriter_close(outfile)
         os.unlink(outfile)
     wbk = OdsFile()
     wbk.open(outfile)
@@ -377,13 +381,13 @@ def write_queries_to_ods(
         if "." in t:
             st = t.split(".")
             if len(st) != 2:
-                raise _state.ErrInfo("cmd", other_msg=f"Unrecognized table specification in <{t}>")
+                raise ErrInfo("cmd", other_msg=f"Unrecognized table specification in <{t}>")
             if len(st) == 1:
-                tblname = _state.unquoted(st[0])
+                tblname = unquoted(st[0])
             else:
-                tblname = _state.unquoted(st[1])
+                tblname = unquoted(st[1])
         else:
-            tblname = _state.unquoted(t)
+            tblname = unquoted(t)
         # Get next sheet number for sheet name
         sheet_names = wbk.sheetnames()
         sheet_name = tblname
@@ -397,10 +401,10 @@ def write_queries_to_ods(
         select_stmt = f"select * from {t};"
         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())
         # Add the data to a new sheet.
         tbl = wbk.new_sheet(sheet_name)
         wbk.add_row_to_sheet(hdrs, tbl, header=True)
@@ -418,8 +422,8 @@ def write_queries_to_ods(
                 d = descriptions[i]
         datasheetlist = wbk.sheet_named(inventory_name)
         if datasheetlist:
-            script, lno = _state.current_script_line()
-            src = f"From database {_state.dbs.current().name()}, with script {os.path.abspath(script)}, line {lno}"
+            script, lno = current_script_line()
+            src = f"From database {_state.dbs.current().name()}, with script {str(Path(script).resolve())}, line {lno}"
             wbk.add_row_to_sheet(
                 (
                     sheet_name,

execsql/exporters/parquet.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+"""
+Apache Parquet export for execsql.
+
+Provides :func:`write_query_to_parquet` (Parquet format via ``polars``).
+Used by ``EXPORT … FORMAT parquet``.  Polars is an optional dependency.
+"""
+
+from typing import Any
+
+from execsql.exceptions import ErrInfo
+from execsql.utils.errors import exception_desc
+from execsql.utils.fileio import filewriter_close
+
+
+def write_query_to_parquet(outfile: str, headers: list[str], rows: Any) -> None:
+    try:
+        import polars as pl
+    except ImportError:
+        raise ErrInfo(
+            "exception",
+            exception_msg=exception_desc(),
+            other_msg="The polars Python package must be installed to export data to the parquet format.",
+        )
+    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_parquet(outfile)

execsql/exporters/pretty.py

@@ -8,44 +8,45 @@ format a query result set as a fixed-width human-readable text table
 (column-aligned, with a header row and separator).
 """
 
-import io
-import os
-from typing import Any, Optional, List
+from typing import Any
 
 import execsql.state as _state
 from execsql.exporters.zip import ZipWriter
+from execsql.exceptions import ErrInfo
+from execsql.utils.errors import exception_desc
+from execsql.utils.fileio import filewriter_close
 
 
 def prettyprint_rowset(
-    colhdrs: List[str],
+    colhdrs: list[str],
     rows: Any,
     output_dest: str,
     append: bool = False,
     and_val: str = "",
-    desc: Optional[str] = None,
-    zipfile: Optional[str] = None,
+    desc: str | None = None,
+    zipfile: str | None = None,
 ) -> None:
     # Adapted from the pp() function by Aaron Watters,
     # posted to gadfly-rdbms@egroups.com 1999-01-18.
     def as_ucode(s):
         if s is None:
             return and_val
-        if isinstance(s, type("")):
+        if isinstance(s, str):
             return s
         if type(s) in (type(memoryview(b"")), bytes, bytearray):
             return f"Binary data ({len(s)} bytes)"
         else:
-            if type(s) == type(b""):
+            if isinstance(s, bytes):
                 return s.decode(_state.dbs.current().encoding)
         return str(s)
 
-    if type(rows) != "list":
+    if not isinstance(rows, list):
         try:
             rows = list(rows)
-        except:
-            raise _state.ErrInfo(
+        except Exception:
+            raise ErrInfo(
                 "exception",
-                exception_msg=_state.exception_desc(),
+                exception_msg=exception_desc(),
                 other_msg="Can't create a list in memory of the data to be displayed as formatted text.",
             )
     rcols = range(len(colhdrs))
@@ -68,7 +69,7 @@ def prettyprint_rowset(
         if zipfile is None:
             from execsql.utils.fileio import EncodedFile
 
-            _state.filewriter_close(output_dest)
+            filewriter_close(output_dest)
             if append:
                 ofile = EncodedFile(output_dest, _state.conf.output_encoding).open("a")
             else:
@@ -91,8 +92,8 @@ def prettyprint_query(
     outfile: str,
     append: bool = False,
     and_val: str = "",
-    desc: Optional[str] = None,
-    zipfile: Optional[str] = None,
+    desc: str | None = None,
+    zipfile: str | None = None,
 ) -> None:
     _state.status.sql_error = False
     names, rows = db.select_data(select_stmt)

execsql/exporters/raw.py

@@ -9,12 +9,10 @@ used by the ``EXPORT … FORMAT raw`` and ``FORMAT b64`` metacommand
 variants.
 """
 
-import io
-import os
-from typing import Any, Optional
+from typing import Any
 
-import execsql.state as _state
 from execsql.exporters.zip import ZipWriter
+from execsql.utils.fileio import filewriter_close
 
 
 def write_query_raw(
@@ -22,17 +20,17 @@ def write_query_raw(
     rowsource: Any,
     db_encoding: str,
     append: bool = False,
-    zipfile: Optional[str] = None,
+    zipfile: str | None = None,
 ) -> None:
     if zipfile is None:
-        _state.filewriter_close(outfile)
+        filewriter_close(outfile)
         mode = "wb" if not append else "ab"
-        of = io.open(outfile, mode)
+        of = open(outfile, mode)  # noqa: SIM115
     else:
         of = ZipWriter(zipfile, outfile, append)
     for row in rowsource:
         for col in row:
-            if type(col) == type(bytearray()):
+            if isinstance(col, bytearray):
                 of.write(col)
             else:
                 if isinstance(col, str):
@@ -42,14 +40,14 @@ def write_query_raw(
     of.close()
 
 
-def write_query_b64(outfile: str, rowsource: Any, append: bool = False, zipfile: Optional[str] = None) -> None:
+def write_query_b64(outfile: str, rowsource: Any, append: bool = False, zipfile: str | None = None) -> None:
     global base64
     import base64
 
     if zipfile is None:
-        _state.filewriter_close(outfile)
+        filewriter_close(outfile)
         mode = "wb" if not append else "ab"
-        of = io.open(outfile, mode)
+        of = open(outfile, mode)  # noqa: SIM115
     else:
         of = ZipWriter(zipfile, outfile, append)
     for row in rowsource:

execsql/exporters/sqlite.py

@@ -8,16 +8,16 @@ to a table in an SQLite database file.  Used by ``EXPORT … FORMAT sqlite``.
 """
 
 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_sqlite
 
 
 def export_sqlite(
     outfile: str,
-    hdrs: List[str],
+    hdrs: list[str],
     rows: Any,
     append: bool,
     tablename: str,
@@ -25,43 +25,43 @@ def export_sqlite(
     import sqlite3
 
     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()
     sdb = sqlite3.connect(outfile)
-    if pre_exist:
+    try:
+        if pre_exist:
+            curs = sdb.cursor()
+            res = curs.execute(
+                f"select name from sqlite_master where type='table' and name='{tablename}';",
+            )
+            rv = res.fetchone()
+            if not (rv is None or rv[0] == 0):
+                if append:
+                    raise ErrInfo(type="error", other_msg=f"The table {tablename} already exists in {outfile}.")
+                else:
+                    curs.execute(f"drop table {tablename};")
+            curs.close()
+        # Construct and run the CREATE TABLE statement
+        rowdata = list(rows)
+        tablespec = DataTable(hdrs, rowdata)
+        sql = tablespec.create_table(dbt_sqlite, schemaname=None, tablename=tablename)
         curs = sdb.cursor()
-        res = curs.execute(
-            f"select name from sqlite_master where type='table' and name='{tablename}';",
-        )
-        rv = res.fetchone()
-        if not (rv is None or rv[0] == 0):
-            if append:
-                raise ErrInfo(type="error", other_msg=f"The table {tablename} already exists in {outfile}.")
-            else:
-                curs.execute(f"drop table {tablename};")
+        curs.execute(sql)
+        # Export all rows of data
+        columns = [dbt_sqlite.quoted(col) for col in hdrs]
+        colspec = ",".join(columns)
+        paramspec = ",".join(("?",) * len(columns))
+        sql = f"insert into {tablename} ({colspec}) values ({paramspec});"
+        n_chunks = math.ceil(len(rowdata) / chunksize)
+        for i in range(n_chunks):
+            start = i * chunksize
+            end = start + chunksize
+            curs.executemany(sql, rowdata[start:end])
+        sdb.commit()
         curs.close()
-    # Construct and run the CREATE TABLE statement
-    rowdata = list(rows)
-    tablespec = DataTable(hdrs, rowdata)
-    dbt_sqlite = _state.dbt_sqlite
-    sql = tablespec.create_table(dbt_sqlite, schemaname=None, tablename=tablename)
-    curs = sdb.cursor()
-    curs.execute(sql)
-    # Export all rows of data
-    columns = [dbt_sqlite.quoted(col) for col in hdrs]
-    colspec = ",".join(columns)
-    paramspec = ",".join(("?",) * len(columns))
-    sql = f"insert into {tablename} ({colspec}) values ({paramspec});"
-    n_chunks = math.ceil(len(rowdata) / chunksize)
-    for i in range(n_chunks):
-        start = i * chunksize
-        end = start + chunksize
-        curs.executemany(sql, rowdata[start:end])
-    sdb.commit()
-    curs.close()
-    sdb.close()
+    finally:
+        sdb.close()
 
 
 def write_query_to_sqlite(
@@ -71,12 +71,12 @@ def write_query_to_sqlite(
     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_sqlite(outfile, hdrs, rows, append, tablename)