execsql2 2.24.0__py3-none-any.whl → 2.25.0__py3-none-any.whl

execsql/db/oracle.py

@@ -15,14 +15,42 @@ from execsql.db.base import Database
 from execsql.db.tiers import SupportTier
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
-from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["OracleDatabase"]
 
 
+def _oracle_driver() -> Any:
+    """The Oracle driver module: python-oracledb, or else the legacy cx_Oracle.
+
+    ``execsql2[oracle]`` installs oracledb.  cx_Oracle, the driver it replaced
+    (same ``makedsn`` / ``connect`` calls), is used only when it is the one
+    installed.  ``None`` if neither is.
+    """
+    try:
+        import oracledb
+
+        return oracledb
+    except ImportError:
+        pass
+    try:
+        import cx_Oracle
+
+        return cx_Oracle
+    except ImportError:
+        return None
+
+
 class OracleDatabase(Database):
-    """Oracle adapter using the cx_Oracle (python-oracledb) driver."""
+    """Oracle adapter using the python-oracledb driver."""
 
     #: Oracle commits every DDL statement at once, together with everything
     #: before it, including CREATE GLOBAL TEMPORARY TABLE.
@@ -46,11 +74,9 @@ class OracleDatabase(Database):
         encoding: str | None = "UTF8",
         password: str | None = None,
     ) -> None:
-        try:
-            import cx_Oracle  # noqa: F401
-        except Exception:
+        if _oracle_driver() is None:
             fatal_error(
-                "The cx-Oracle module is required to connect to Oracle.   See https://pypi.org/project/cx-Oracle/",
+                'The oracledb module is required to connect to Oracle. Install it with: pip install "execsql2[oracle]"',
             )
         from execsql.types import dbt_oracle
 
@@ -64,7 +90,6 @@ class OracleDatabase(Database):
         self.type = dbt_oracle
         self.password = password
         self.encoding = encoding or "UTF8"
-        self.encode_commands = False
         self.paramstr = ":1"
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
@@ -77,39 +102,45 @@ class OracleDatabase(Database):
 
     def open_db(self) -> None:
         """Open a connection to the Oracle database."""
-        import cx_Oracle
+        driver = _oracle_driver()
 
         def db_conn(db: OracleDatabase, db_name: str):
-            dsn = cx_Oracle.makedsn(db.server_name, db.port, service_name=db_name)
+            dsn = driver.makedsn(db.server_name, db.port, service_name=db_name)
             if db.user and db.password:
-                return cx_Oracle.connect(user=db.user, password=db.password, dsn=dsn)
+                return driver.connect(user=db.user, password=db.password, dsn=dsn)
             else:
-                return cx_Oracle.connect(dsn=dsn)
+                return driver.connect(dsn=dsn)
 
         if self.conn is None:
             try:
+                begin_login()
                 if self.user and self.need_passwd and not self.password:
                     self.password = get_password(
                         "Oracle",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                     )
                 try:
                     self.conn = db_conn(self, self.db_name)
-                except Exception:
-                    if not password_from_keyring():
+                except Exception as e:
+                    # Only a rejected password means the stored one is stale;
+                    # a timeout or a missing database leaves it alone.
+                    if not (password_from_keyring() and is_login_failure(e)):
                         raise
-                    clear_stored_password("Oracle", self.db_name, self.user, self.server_name)
+                    clear_stored_password("Oracle", self.db_name, self.user, self.server_name, port=self.port)
                     self.password = get_password(
                         "Oracle",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                         skip_keyring=True,
                         other_msg="(stored credential failed — enter current password)",
                     )
                     self.conn = db_conn(self, self.db_name)
+                remember_password("Oracle", self.db_name, self.user, self.server_name, port=self.port)
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -153,6 +184,9 @@ class OracleDatabase(Database):
 
         raise DatabaseNotImplementedError(self.name(), "schema_exists")
 
+    def current_schema(self) -> str | None:
+        return self._query_current_schema("select sys_context('USERENV', 'CURRENT_SCHEMA') from dual")
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the Oracle database."""
         # Oracle folds unquoted identifiers to uppercase; normalise so a lookup
@@ -288,8 +322,7 @@ class OracleDatabase(Database):
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table with cascade constraints."""
-        tablename = self.type.quoted(tablename)
+        """Drop *tablename* (schema-qualified and quoted by the caller) with cascade constraints."""
         self.execute(f"drop table {tablename} cascade constraints")
 
     def paramsubs(self, paramcount: int) -> str:

execsql/db/postgres.py

@@ -16,7 +16,14 @@ from typing import Any
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
-from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 from execsql.utils.strings import encodings_match
 import execsql.state as _state
 
@@ -60,7 +67,6 @@ class PostgresDatabase(Database):
         self.type = dbt_postgres
         self.password = password
         self.new_db = new_db
-        self.encode_commands = False
         self.paramstr = "%s"
         self.connect_timeout = connect_timeout
         self.open_db()
@@ -123,31 +129,37 @@ class PostgresDatabase(Database):
 
         if self.conn is None:
             try:
+                begin_login()
                 if self.user and self.need_passwd and not self.password:
                     self.password = get_password(
                         "PostgreSQL",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                     )
                 if self.new_db:
                     create_db(self)
                 try:
                     self.conn = db_conn(self, self.db_name)
-                except (ErrInfo, Exception):
-                    if not password_from_keyring():
+                except (ErrInfo, Exception) as e:
+                    # Only a rejected password means the stored one is stale;
+                    # a timeout or a missing database leaves it alone.
+                    if not (password_from_keyring() and is_login_failure(e)):
                         raise
                     # Stored credential is stale — clear it and re-prompt.
-                    clear_stored_password("PostgreSQL", self.db_name, self.user, self.server_name)
+                    clear_stored_password("PostgreSQL", self.db_name, self.user, self.server_name, port=self.port)
                     self.password = get_password(
                         "PostgreSQL",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                         skip_keyring=True,
                         other_msg="(stored credential failed — enter current password)",
                     )
                     self.conn = db_conn(self, self.db_name)
+                remember_password("PostgreSQL", self.db_name, self.user, self.server_name, port=self.port)
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -178,6 +190,9 @@ class PostgresDatabase(Database):
             rows = curs.fetchall()
         return len(rows) > 0
 
+    # table_exists() without a schema looks only where CREATE TABLE puts a table: it searches the temp schema and the search path.
+    unqualified_lookup_is_scoped = True
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the PostgreSQL database."""
         if schema_name is not None:
@@ -336,6 +351,8 @@ class PostgresDatabase(Database):
             and not _state.conf.trim_strings
             and not _state.conf.replace_newlines
         ):
+            from execsql.exporters.delimited import blank_lines_as_empty_rows
+
             # Use Postgres' COPY FROM method via psycopg3's cursor.copy() context manager.
             rf = csv_file_obj.open("rt")
             if skipheader:
@@ -364,7 +381,14 @@ class PostgresDatabase(Database):
             with self._cursor() as curs:
                 try:
                     with curs.copy(copy_cmd) as copy:
-                        while chunk := rf.read(_state.conf.import_buffer):
+                        # COPY rejects a blank line; the row path reads it as an empty row.
+                        for chunk in blank_lines_as_empty_rows(
+                            rf,
+                            delim,
+                            csv_file_obj.quotechar,
+                            len(csv_file_cols),
+                            _state.conf.import_buffer,
+                        ):
                             copy.write(chunk)
                 except ErrInfo:
                     raise

execsql/db/sqlite.py

@@ -45,7 +45,6 @@ class SQLiteDatabase(Database):
             encoding="UTF-8",
         )
         self.type = dbt_sqlite
-        self.encode_commands = False
         self.timeout = timeout
         self.open_db()
 
@@ -95,6 +94,9 @@ class SQLiteDatabase(Database):
                 self.rollback()
                 raise
 
+    # table_exists() without a schema looks only where CREATE TABLE puts a table: one namespace.
+    unqualified_lookup_is_scoped = True
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the SQLite database."""
         # SQLite stores names as-created; match case-insensitively so a lookup
@@ -170,8 +172,7 @@ class SQLiteDatabase(Database):
         return False
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table from the SQLite database if it exists."""
-        tablename = self.type.quoted(tablename)
+        """Drop *tablename* (schema-qualified and quoted by the caller) if it exists."""
         self.execute(f"drop table if exists {tablename};")
 
     def populate_table(
@@ -237,14 +238,11 @@ class SQLiteDatabase(Database):
 
         last_line: list[Any] = []
         try:
-            for datalineno, line in enumerate(rowsource):
+            for line in rowsource:
                 # Skip empty rows.
                 if not (len(line) == 1 and line[0] is None):
-                    if len(line) < len(columns):
-                        raise ErrInfo(
-                            type="error",
-                            other_msg=f"Too few values on data line {datalineno} of input.",
-                        )
+                    # Trailing values left off the line are NULL.
+                    line = list(line) + [None] * (len(ts_colnames) - len(line))
                     if _state.conf.trim_strings or _state.conf.replace_newlines or not _state.conf.empty_strings:
                         for i in range(len(line)):
                             if line[i] is not None and isinstance(line[i], _state.stringtypes):

execsql/db/sqlserver.py

@@ -12,7 +12,14 @@ import re
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import fatal_error
-from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["SqlServerDatabase"]
@@ -47,11 +54,13 @@ class SqlServerDatabase(Database):
         self.type = dbt_sqlserver
         self.password = password
         self.encoding = encoding or "latin1"  # Default on installation of SQL Server
-        self.encode_commands = True
         self.paramstr = "?"
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 
+    def current_schema(self) -> str | None:
+        return self._query_current_schema("select schema_name()")
+
     def __repr__(self) -> str:
         return (
             f"SqlServerDatabase({self.server_name!r}, {self.db_name!r}, {self.user!r}, "
@@ -75,12 +84,14 @@ class SqlServerDatabase(Database):
         import pyodbc
 
         if self.conn is None:
+            begin_login()
             if self.user and self.need_passwd and not self.password:
                 self.password = get_password(
                     "SQL Server",
                     self.db_name,
                     self.user,
                     server_name=self.server_name,
+                    port=self.port,
                 )
             # Use pyodbc to connect.  Try different driver versions from newest to oldest.
             ssdrivers = (
@@ -94,6 +105,8 @@ class SqlServerDatabase(Database):
                 "SQL Server",
             )
 
+            errors: list[BaseException] = []
+
             def _try_drivers():
                 for drv in ssdrivers:
                     if self.user:
@@ -117,7 +130,8 @@ class SqlServerDatabase(Database):
                         # default; pyodbc treats `timeout` as the login-and-
                         # query timeout on the connection.
                         self.conn = pyodbc.connect(connstr, timeout=30)
-                    except Exception:
+                    except Exception as e:
+                        errors.append(e)
                         if _state.exec_log is not None:
                             _state.exec_log.log_status_info(
                                 f"Could not connect using: {re.sub(r'Pwd=[^;]*', 'Pwd=***', connstr)}",
@@ -130,18 +144,22 @@ class SqlServerDatabase(Database):
                         return True
                 return False
 
-            if not _try_drivers() and password_from_keyring():
-                # Stored credential is stale — clear it and re-prompt.
-                clear_stored_password("SQL Server", self.db_name, self.user, self.server_name)
+            # Only a rejected password means the stored one is stale; a
+            # timeout or a missing database leaves it alone.
+            if not _try_drivers() and password_from_keyring() and any(is_login_failure(e) for e in errors):
+                clear_stored_password("SQL Server", self.db_name, self.user, self.server_name, port=self.port)
                 self.password = get_password(
                     "SQL Server",
                     self.db_name,
                     self.user,
                     server_name=self.server_name,
+                    port=self.port,
                     skip_keyring=True,
                     other_msg="(stored credential failed — enter current password)",
                 )
                 _try_drivers()
+            if self.conn:
+                remember_password("SQL Server", self.db_name, self.user, self.server_name, port=self.port)
 
             if not self.conn:
                 raise ErrInfo(
@@ -193,9 +211,8 @@ class SqlServerDatabase(Database):
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table from the SQL Server database."""
+        """Drop *tablename*, schema-qualified and quoted by the caller."""
         # SQL Server and Firebird will throw an error if there are foreign keys to the table.
-        tablename = self.type.quoted(tablename)
         self.execute(f"drop table {tablename};")
 
     def import_entire_file(

execsql/exporters/delimited.py

@@ -28,7 +28,14 @@ from execsql.utils.errors import exception_desc
 from execsql.utils.fileio import filewriter_close
 from execsql.utils.strings import clean_words, dedup_words, fold_words
 
-__all__ = ["LineDelimiter", "CsvFile", "CsvWriter", "DelimitedWriter", "write_delimited_file"]
+__all__ = [
+    "LineDelimiter",
+    "CsvFile",
+    "CsvWriter",
+    "DelimitedWriter",
+    "blank_lines_as_empty_rows",
+    "write_delimited_file",
+]
 
 _SPACE_DELIM_RX = re.compile(r" +")
 
@@ -618,6 +625,9 @@ class CsvFile(EncodedFile):
                 prev_state = state
                 state = exec_vector[state]()
         end()
+        # An empty result is either a blank line or the end of the file; the
+        # reader needs to know which.
+        self._at_eof = c == ""
         if len(self.parse_errors) > 0:
             raise ErrInfo("error", other_msg=", ".join(self.parse_errors))
         return elements
@@ -653,48 +663,63 @@ class CsvFile(EncodedFile):
                 doublequote=True,
                 strict=False,
             )
-            for elements in csv_reader:
-                if len(elements) == 0:
-                    break
-                # Normalize empty strings to None for parity with the slow reader.
-                normalized_elements = [e if e != "" else None for e in elements]
-                if conf.del_empty_cols and len(self.blank_cols) > 0:
-                    blanks = copy.copy(self.blank_cols)
-                    while len(blanks) > 0:
-                        b = blanks.pop()
-                        del normalized_elements[b]
-                yield normalized_elements
+            # Normalize empty strings to None for parity with the slow reader.
+            raw = ([e if e != "" else None for e in elements] for elements in csv_reader)
+            yield from self._rows(raw, conf)
         finally:
             f.close()
 
     def _slow_reader(self, conf: Any) -> Any:
         """Read using the character-at-a-time state machine (fallback for non-standard formats)."""
         f = self.openclean("rt")
-        line_no = 0
-        try:
+
+        def raw() -> Any:
+            line_no = 0
             while True:
                 line_no += 1
                 try:
                     elements = self.read_and_parse_line(f)
                 except ErrInfo as e:
                     raise ErrInfo("error", other_msg=f"{e.other} on line {line_no}.") from e
-                except:
-                    raise
-                if len(elements) > 0:
-                    if conf.del_empty_cols and len(self.blank_cols) > 0:
-                        blanks = copy.copy(self.blank_cols)
-                        while len(blanks) > 0:
-                            b = blanks.pop()
-                            del elements[b]
-                    yield elements
-                else:
-                    break
+                if not elements and self._at_eof:
+                    return
+                yield elements
+
+        try:
+            yield from self._rows(raw(), conf)
         finally:
             f.close()
 
-    def writer(self, append: bool = False) -> CsvWriter:
-        """Return a :class:`CsvWriter` configured with this file's format settings."""
-        return CsvWriter(self.filename, self.encoding, self.delimiter, self.quotechar, self.escapechar, append)
+    def _rows(self, raw: Any, conf: Any) -> Any:
+        """Yield parsed rows, turning a blank line inside the data into an empty row.
+
+        A blank line (no fields at all) is an all-``None`` row as wide as the
+        header, so ``CONFIG EMPTY_ROWS`` decides whether it is loaded, as it
+        does for a row of empty fields.  Blank lines with no data after them
+        end the file, as they always have, so a trailing newline does not add
+        an empty row.
+        """
+        width = None
+        pending_blank = 0
+        for elements in raw:
+            if not elements:
+                if width is not None:
+                    pending_blank += 1
+                continue
+            if width is None:
+                width = len(elements)
+            for _ in range(pending_blank):
+                yield self._without_blank_cols([None] * width, conf)
+            pending_blank = 0
+            yield self._without_blank_cols(elements, conf)
+
+    def _without_blank_cols(self, elements: list, conf: Any) -> list:
+        if conf.del_empty_cols and len(self.blank_cols) > 0:
+            blanks = copy.copy(self.blank_cols)
+            while len(blanks) > 0:
+                b = blanks.pop()
+                del elements[b]
+        return elements
 
     def _colhdrs(self, inf: Any) -> list[str]:
         conf = _state.conf
@@ -764,6 +789,40 @@ class CsvFile(EncodedFile):
         return self.table_data.create_table(database_type, schemaname, tablename, pretty)
 
 
+def blank_lines_as_empty_rows(f: Any, delimiter: str, quotechar: str | None, columns: int, chunk_size: int) -> Any:
+    """Yield the text of *f* in chunks of about *chunk_size*, with each blank line inside the data made an empty row.
+
+    For a reader of the raw file, such as PostgreSQL's COPY, which rejects a
+    blank line.  The line becomes *columns* empty fields (``,,`` for three),
+    matching what the row-by-row reader loads; blank lines at the end of the
+    file are dropped, as there.  A blank line inside a quoted value is part
+    of that value and is kept: quote characters are counted, and a doubled
+    quote (the only escape a raw CSV reader is given) counts twice.
+    """
+    empty_row = delimiter * (columns - 1) + "\n"
+    in_quotes = False
+    pending_blank = 0
+    buf: list[str] = []
+    size = 0
+    for line in f:
+        if not in_quotes and line in ("\n", "\r\n"):
+            pending_blank += 1
+            continue
+        if pending_blank:
+            buf.append(empty_row * pending_blank)
+            size += len(empty_row) * pending_blank
+            pending_blank = 0
+        if quotechar and line.count(quotechar) % 2:
+            in_quotes = not in_quotes
+        buf.append(line)
+        size += len(line)
+        if size >= chunk_size:
+            yield "".join(buf)
+            buf, size = [], 0
+    if buf:
+        yield "".join(buf)
+
+
 def write_delimited_file(
     outfile: str,
     filefmt: str,

execsql/exporters/xlsx.py

@@ -38,7 +38,9 @@ def _require_openpyxl() -> Any:
 
         return openpyxl
     except ImportError:
-        fatal_error("The openpyxl library is needed to write Excel (.xlsx) spreadsheets (install execsql2[excel]).")
+        fatal_error(
+            "The openpyxl library is needed to write Excel (.xlsx) spreadsheets (install the formats extra, execsql2[formats]).",
+        )
 
 
 def _cell_value(item: Any) -> Any:
@@ -72,6 +74,19 @@ def _cell_value(item: Any) -> Any:
     return str(item)
 
 
+def _write_cell(ws: Any, row: int, column: int, value: Any) -> Any:
+    """Write *value* to a cell as data, never as a formula, and return the cell.
+
+    openpyxl stores any string that starts with ``=`` as a formula, so text
+    from the database such as ``=1+1`` or ``=HYPERLINK(...)`` would be
+    evaluated when the workbook is opened.  Such cells are stored as text.
+    """
+    cell = ws.cell(row=row, column=column, value=value)
+    if cell.data_type == "f":
+        cell.data_type = "s"
+    return cell
+
+
 # ---------------------------------------------------------------------------
 # Public API
 # ---------------------------------------------------------------------------
@@ -145,7 +160,7 @@ def write_query_to_xlsx(
             ("datasheet_name", "created_on", "created_by", "description", "source"),
             start=1,
         ):
-            cell = inv_ws.cell(row=1, column=col_idx, value=hdr)
+            cell = _write_cell(inv_ws, 1, col_idx, hdr)
             cell.font = bold_font
     else:
         inv_ws = wb[inventory_name]
@@ -158,13 +173,13 @@ def write_query_to_xlsx(
 
     # Header row
     for col_idx, hdr in enumerate(hdrs, start=1):
-        cell = ws.cell(row=1, column=col_idx, value=str(hdr))
+        cell = _write_cell(ws, 1, col_idx, str(hdr))
         cell.font = bold_font
 
     # Data rows
     for row_idx, row in enumerate(rows, start=2):
         for col_idx, item in enumerate(row, start=1):
-            ws.cell(row=row_idx, column=col_idx, value=_cell_value(item))
+            _write_cell(ws, row_idx, col_idx, _cell_value(item))
 
     # ------------------------------------------------------------------
     # Update inventory sheet
@@ -185,7 +200,7 @@ def write_query_to_xlsx(
         ),
         start=1,
     ):
-        inv_ws.cell(row=next_row, column=col_idx, value=value)
+        _write_cell(inv_ws, next_row, col_idx, value)
 
     wb.save(outfile)
     wb.close()
@@ -256,7 +271,7 @@ def write_queries_to_xlsx(
             ("datasheet_name", "created_on", "created_by", "description", "source"),
             start=1,
         ):
-            cell = inv_ws.cell(row=1, column=col_idx, value=hdr)
+            cell = _write_cell(inv_ws, 1, col_idx, hdr)
             cell.font = bold_font
     else:
         inv_ws = wb[inventory_name]
@@ -297,12 +312,12 @@ def write_queries_to_xlsx(
         ws = wb.create_sheet(sheet_name)
 
         for col_idx, hdr in enumerate(hdrs, start=1):
-            cell = ws.cell(row=1, column=col_idx, value=str(hdr))
+            cell = _write_cell(ws, 1, col_idx, str(hdr))
             cell.font = bold_font
 
         for row_idx, row in enumerate(rows, start=2):
             for col_idx, item in enumerate(row, start=1):
-                ws.cell(row=row_idx, column=col_idx, value=_cell_value(item))
+                _write_cell(ws, row_idx, col_idx, _cell_value(item))
 
         # Determine per-sheet description.
         if desc is None:
@@ -326,7 +341,7 @@ def write_queries_to_xlsx(
             ),
             start=1,
         ):
-            inv_ws.cell(row=next_row, column=col_idx, value=value)
+            _write_cell(inv_ws, next_row, col_idx, value)
 
         if tee and outfile.lower() != "stdout":
             prettyprint_query(select_stmt, db, "stdout", False, desc=d)

execsql/exporters/zip.py

@@ -54,8 +54,7 @@ class WriteableZipfile:
             date_time=time.localtime(time.time())[:6],
         )
         self.current_zinfo.compress_type = self.zf.compression
-        if sys.version_info.major >= 3 and sys.version_info.minor >= 7:
-            self.current_zinfo._compresslevel = self.zf.compresslevel  # type: ignore[attr-defined]
+        self.current_zinfo._compresslevel = self.zf.compresslevel  # type: ignore[attr-defined]
         # See https://stackoverflow.com/questions/434641/how-do-i-set-permissions-attributes-on-a-file-in-a-zip-file-using-pythons-zip
         self.current_zinfo.external_attr = 0o100755 << 16  # ?rw-rw-rw-
         if sys.platform.startswith("win"):