tradedangerous 11.5.2__py3-none-any.whl → 12.0.0__py3-none-any.whl

tradedangerous/csvexport.py

@@ -1,31 +1,31 @@
 from pathlib import Path
+from sqlalchemy import inspect, text
 from .tradeexcept import TradeException
 
+from .db import utils as db_utils
+
+
 import csv
 import os
-import sqlite3
 
 ######################################################################
 # TradeDangerous :: Modules :: CSV Exporter
 #
-# Generate a CSV files for a table of the database.
+# Generate CSV files for database tables.
 #
-# Note: This routine makes some assumptions about the structure
-#       of the database:
-#          * The table should only have one UNIQUE index
-#          * The referenced table must have one UNIQUE index
-#          * The FK columns must have the same name in both tables
-#          * One column primary keys will be handled by the database engine
+# Assumptions:
+#   * Each table has at most one UNIQUE index.
+#   * Referenced tables also have a UNIQUE index.
+#   * Only single-column foreign keys are supported.
+#   * Single-column primary keys are inferred automatically by SQLAlchemy.
 #
-######################################################################
-# CAUTION: If the database structure gets changed this script might
-#          need some corrections.
+# CAUTION: If the schema changes this module may require updates.
 ######################################################################
 
 ######################################################################
 # Default values
 
-# for some tables the first two columns will be reversed
+# For some tables the first two columns will be reversed
 reverseList = []
 
 ######################################################################
@@ -38,183 +38,194 @@ def search_keyList(items, val):
             return row
     return None
 
-def getUniqueIndex(conn, tableName):
-    """ return all unique columns """
-    idxCursor = conn.cursor()
+
+def getUniqueIndex(session, tableName):
+    """Return all unique columns via SQLAlchemy inspector."""
+    inspector = inspect(session.get_bind())
     unqIndex = []
-    for idxRow in idxCursor.execute("PRAGMA index_list('%s')" % tableName):
-        if idxRow['unique']:
-            # it's a unique index
-            unqCursor = conn.cursor()
-            for unqRow in unqCursor.execute("PRAGMA index_info('%s')" % idxRow['name']):
-                unqIndex.append(unqRow['name'])
+    for idx in inspector.get_indexes(tableName):
+        if idx.get("unique"):
+            unqIndex.extend(idx.get("column_names", []))
     return unqIndex
 
-def getFKeyList(conn, tableName):
-    """ get all single column FKs """
+
+def getFKeyList(session, tableName):
+    """Return all single-column foreign keys via SQLAlchemy inspector."""
+    inspector = inspect(session.get_bind())
     keyList = []
-    keyCount = -1
-    keyCursor = conn.cursor()
-    for keyRow in keyCursor.execute("PRAGMA foreign_key_list('%s')" % tableName):
-        if keyRow['seq'] == 0:
-            keyCount += 1
-            keyList.append( {'table': keyRow['table'],
-                             'from': keyRow['from'],
-                             'to': keyRow['to']}
-                          )
-        if keyRow['seq'] == 1:
-            # if there is a second column, remove it from the list
-            keyList.remove( keyList[keyCount] )
-            keyCount -= 1
-    
+    for fk in inspector.get_foreign_keys(tableName):
+        cols = fk.get("constrained_columns", [])
+        referred = fk.get("referred_columns", [])
+        if len(cols) == 1 and len(referred) == 1:
+            keyList.append({
+                "table": fk.get("referred_table"),
+                "from": cols[0],
+                "to": referred[0],
+            })
     return keyList
 
-def buildFKeyStmt(conn, tableName, key):
+
+def buildFKeyStmt(session, tableName, key):
     """
-        resolve the FK constrain with the UNIQUE index
-        multicolumn UNIQUEs are allowed as long as the last one
-        will be a single column one
+    Resolve the FK constraint against the UNIQUE index of the
+    referenced table.
+
+    Multicolumn UNIQUEs are allowed, but only the last column
+    may be treated as a single-column join target.
     """
-    unqIndex = getUniqueIndex(conn, key['table'])
-    keyList  = getFKeyList(conn, key['table'])
+    unqIndex = getUniqueIndex(session, key["table"])
+    keyList = getFKeyList(session, key["table"])
     keyStmt = []
+
     for colName in unqIndex:
-        # check if the column is a foreign key
+        # If this unique column is itself a foreign key, recurse
         keyKey = search_keyList(keyList, colName)
         if keyKey:
-            newStmt = buildFKeyStmt(conn, key['table'], keyKey)
-            for row in newStmt:
-                keyStmt.append(row)
+            keyStmt.extend(buildFKeyStmt(session, key["table"], keyKey))
         else:
             keyStmt.append({
-                'table': tableName,
-                'column': colName,
-                'joinTable': key['table'],
-                'joinColumn': key['to']
+                "table": tableName,
+                "column": colName,
+                "joinTable": key["table"],
+                "joinColumn": key["to"],
             })
-    
+
     return keyStmt
 
+
 ######################################################################
 # Code
 ######################################################################
 
-def exportTableToFile(tdb, tdenv, tableName, csvPath=None):
+def exportTableToFile(tdb_or_session, tdenv, tableName, csvPath=None):
     """
-        Generate the csv file for tableName in csvPath
-        returns lineCount, exportPath
+    Generate the CSV file for tableName in csvPath.
+    Returns (lineCount, exportPath).
+
+    Behaviour:
+    - Prefix unique columns with "unq:".
+    - Foreign keys are exported as "<col>@<joinTable>.<uniqueCol>".
+    - Datetime-like values for 'modified' columns are exported as
+      "YYYY-MM-DD HH:MM:SS" (no microseconds).
+
+    Compatible with either:
+      * a SQLAlchemy Session
+      * a TradeDB wrapper exposing .engine
     """
-    
-    # path for csv file
-    csvPath = csvPath or tdb.csvPath
-    if not csvPath.is_dir():
-        raise TradeException("Save location '{}' not found.".format(str(csvPath)))
-    
-    # connect to the database
-    conn = tdb.getDB()
-    conn.row_factory = sqlite3.Row
-    
-    # prefix for unique/ignore columns
+    from sqlalchemy.orm import Session
+
+    # --- Resolve a SQLAlchemy session ---
+    if hasattr(tdb_or_session, "engine"):
+        # Likely a TradeDB instance
+        engine = tdb_or_session.engine
+        session = Session(engine)
+    elif hasattr(tdb_or_session, "get_bind"):
+        # Already a Session
+        session = tdb_or_session
+    else:
+        raise TradeException(
+            f"Unsupported DB object passed to exportTableToFile: {type(tdb_or_session)}"
+        )
+
+    csvPath = csvPath or Path(tdenv.csvDir)
+    if not Path(csvPath).is_dir():
+        raise TradeException(f"Save location '{csvPath}' not found.")
+
     uniquePfx = "unq:"
-    ignorePfx = "!"
-    
-    # create CSV files
-    exportPath = (csvPath / Path(tableName)).with_suffix(".csv")
-    tdenv.DEBUG0("Export Table '{table}' to '{file}'".format(
-                    table=tableName, file=str(exportPath)
-                    ))
-    
+    exportPath = (Path(csvPath) / Path(tableName)).with_suffix(".csv")
+    tdenv.DEBUG0(f"Export Table '{tableName}' to '{exportPath}'")
+
+    def _fmt_ts(val):
+        if hasattr(val, "strftime"):
+            try:
+                return val.strftime("%Y-%m-%d %H:%M:%S")
+            except Exception:
+                pass
+        if isinstance(val, str):
+            s = val
+            if len(s) >= 19 and s[10] == "T":
+                s = s[:10] + " " + s[11:]
+            if len(s) >= 19 and s[4] == "-" and s[7] == "-" and s[10] == " " and s[13] == ":" and s[16] == ":":
+                return s[:19]
+        return val
+
     lineCount = 0
-    with exportPath.open("w", encoding='utf-8', newline="\n") as exportFile:
-        exportOut = csv.writer(exportFile, delimiter=",", quotechar="'", doublequote=True, quoting=csv.QUOTE_NONNUMERIC, lineterminator="\n")
-        
-        cur = conn.cursor()
-        
-        # check for single PRIMARY KEY
-        pkCount = 0
-        for columnRow in cur.execute("PRAGMA table_info('%s')" % tableName):
-            # count the columns of the primary key
-            if columnRow['pk'] > 0:
-                pkCount += 1
-        
-        # build column list
-        columnList = []
-        for columnRow in cur.execute("PRAGMA table_info('%s')" % tableName):
-            # if there is only one PK column, ignore it
-            # if columnRow['pk'] > 0 and pkCount == 1: continue
-            columnList.append(columnRow)
-        
-        if len(columnList) == 0:
-            raise TradeException("No columns to export for table '{}'.".format(tableName))
-        
-        # reverse the first two columns for some tables
-        if tableName in reverseList:
-            columnList[0], columnList[1] = columnList[1], columnList[0]
-        
-        # initialize helper lists
-        csvHead    = []
+    with exportPath.open("w", encoding="utf-8", newline="\n") as exportFile:
+        exportOut = csv.writer(
+            exportFile,
+            delimiter=",",
+            quotechar="'",
+            doublequote=True,
+            quoting=csv.QUOTE_NONNUMERIC,
+            lineterminator="\n",
+        )
+
+        bind = session.get_bind()
+        inspector = inspect(bind)
+
+        try:
+            unique_cols = db_utils.get_unique_columns(session, tableName)
+            fk_list = db_utils.get_foreign_keys(session, tableName)
+        except Exception as e:
+            raise TradeException(f"Failed to introspect table '{tableName}': {e!r}")
+
+        csvHead = []
         stmtColumn = []
-        stmtTable  = [ tableName ]
-        stmtOrder  = []
-        unqIndex   = getUniqueIndex(conn, tableName)
-        keyList    = getFKeyList(conn, tableName)
-        
-        tdenv.DEBUG1('UNIQUE: ' + ", ".join(unqIndex))
-        
-        # iterate over all columns of the table
-        for col in columnList:
-            # check if the column is a foreign key
-            key = search_keyList(keyList, col['name'])
-            if key:
-                # make the join statement
-                keyStmt = buildFKeyStmt(conn, tableName, key)
-                for keyRow in keyStmt:
-                    tdenv.DEBUG1('FK-Stmt: {}'.format(list(keyRow)))
-                    # is the join for the same table
-                    if keyRow['table'] == tableName:
-                        csvPfx = ''
-                        joinStmt = 'USING({})'.format(keyRow['joinColumn'])
-                    else:
-                        # this column must be ignored by the importer, it's only
-                        # used to resolve the FK relation
-                        csvPfx = ignorePfx
-                        joinStmt = 'ON {}.{} = {}.{}'.format(keyRow['table'], keyRow['joinColumn'], keyRow['joinTable'], keyRow['joinColumn'])
-                    if col['name'] in unqIndex:
-                        # column is part of an unique index
-                        csvPfx = uniquePfx + csvPfx
-                    csvHead += [ "{}{}@{}.{}".format(csvPfx, keyRow['column'], keyRow['joinTable'], keyRow['joinColumn']) ]
-                    stmtColumn += [ "{}.{}".format(keyRow['joinTable'], keyRow['column']) ]
-                    if col['notnull']:
-                        stmtTable += [ 'INNER JOIN {} {}'.format(keyRow['joinTable'], joinStmt) ]
-                    else:
-                        stmtTable += [ 'LEFT OUTER JOIN {} {}'.format(keyRow['joinTable'], joinStmt) ]
-                    stmtOrder += [ "{}.{}".format(keyRow['joinTable'], keyRow['column']) ]
+        stmtTable = [tableName]
+        stmtOrder = []
+        is_modified_col = []
+
+        for col in inspector.get_columns(tableName):
+            col_name = col["name"]
+            fk = next((fk for fk in fk_list if fk["from"] == col_name), None)
+            if fk:
+                joinTable = fk["table"]
+                joinColumn = fk["to"]
+                join_unique_cols = db_utils.get_unique_columns(session, joinTable)
+                if not join_unique_cols:
+                    raise TradeException(
+                        f"No unique column found in referenced table '{joinTable}'"
+                    )
+                export_col = join_unique_cols[0]
+                csvPfx = uniquePfx if col_name in unique_cols else ""
+                csvHead.append(f"{csvPfx}{col_name}@{joinTable}.{export_col}")
+                stmtColumn.append(f"{joinTable}.{export_col}")
+                is_modified_col.append(export_col == "modified")
+                nullable = bool(col.get("nullable", True))
+                join_type = "LEFT OUTER JOIN" if nullable else "INNER JOIN"
+                stmtTable.append(
+                    f"{join_type} {joinTable} ON {tableName}.{col_name} = {joinTable}.{joinColumn}"
+                )
+                stmtOrder.append(f"{joinTable}.{export_col}")
             else:
-                # ordinary column
-                if col['name'] in unqIndex:
-                    # column is part of an unique index
-                    csvHead += [ uniquePfx + col['name'] ]
-                    stmtOrder += [ "{}.{}".format(tableName, col['name']) ]
+                if col_name in unique_cols:
+                    csvHead.append(uniquePfx + col_name)
+                    stmtOrder.append(f"{tableName}.{col_name}")
                 else:
-                    csvHead += [ col['name'] ]
-                stmtColumn += [ "{}.{}".format(tableName, col['name']) ]
-        
-        # build the SQL statement
-        sqlStmt = "SELECT {} FROM {}".format(",".join(stmtColumn), " ".join(stmtTable))
-        if len(stmtOrder) > 0:
-            sqlStmt += " ORDER BY {}".format(",".join(stmtOrder))
-        tdenv.DEBUG1("SQL: %s" % sqlStmt)
-        
-        # finally generate the csv file
-        # write header line without quotes
-        exportFile.write("{}\n".format(",".join(csvHead)))
-        for line in cur.execute(sqlStmt):
+                    csvHead.append(col_name)
+                stmtColumn.append(f"{tableName}.{col_name}")
+                is_modified_col.append(col_name == "modified")
+
+        sqlStmt = f"SELECT {','.join(stmtColumn)} FROM {' '.join(stmtTable)}"
+        if stmtOrder:
+            sqlStmt += f" ORDER BY {','.join(stmtOrder)}"
+        tdenv.DEBUG1(f"SQL: {sqlStmt}")
+
+        exportFile.write(f"{','.join(csvHead)}\n")
+
+        for row in session.execute(text(sqlStmt)):
             lineCount += 1
-            tdenv.DEBUG2("{count}: {values}".format(count=lineCount, values=list(line)))
-            exportOut.writerow(list(line))
-        tdenv.DEBUG1("{count} {table}s exported".format(count=lineCount, table=tableName))
-    
-    # Update the DB file so we don't regenerate it.
-    os.utime(str(tdb.dbPath))
-    
+            row_out = [
+                _fmt_ts(val) if is_modified_col[i] else val
+                for i, val in enumerate(row)
+            ]
+            tdenv.DEBUG2(f"{lineCount}: {row_out}")
+            exportOut.writerow(row_out)
+
+        tdenv.DEBUG1(f"{lineCount} {tableName}s exported")
+
+    # Close session if we created it
+    if hasattr(tdb_or_session, "engine"):
+        session.close()
+
     return lineCount, exportPath

tradedangerous/gui.py

@@ -941,9 +941,9 @@ def main(argv = None):
     sys.argv = ['trade']
     if not argv:
         argv = sys.argv
-    if sys.hexversion < 0x03040200:
+    if sys.hexversion < 0x30813F0:
         raise SystemExit(
-            "Sorry: TradeDangerous requires Python 3.4.2 or higher.\n"
+            "Sorry: TradeDangerous requires Python 3.8.19 or higher.\n"
             "For assistance, see:\n"
             "\tBug Tracker: https://github.com/eyeonus/Trade-Dangerous/issues\n"
             "\tDocumentation: https://github.com/eyeonus/Trade-Dangerous/wiki\n"