tradedangerous 11.5.3__py3-none-any.whl → 12.0.1__py3-none-any.whl

tradedangerous/cli.py

@@ -49,9 +49,9 @@ if "CPROF" in os.environ:
 def main(argv = None):
     if not argv:
         argv = sys.argv
-    if sys.hexversion < 0x03070000:
+    if sys.hexversion < 0x30813F0:
         raise SystemExit(
-            "Sorry: TradeDangerous requires Python 3.7 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"

tradedangerous/commands/TEMPLATE.py

@@ -1,6 +1,4 @@
-from commands.commandenv import ResultRow
-from commands.parsing import *
-from formatting import RowFormat, ColumnFormat
+from __future__ import annotations
 
 ######################################################################
 # Parser config
@@ -8,25 +6,23 @@ from formatting import RowFormat, ColumnFormat
 help = 'Describe your command briefly here for the top-level --help.'
 name = 'TEMPLATE'       # name of your .py file excluding the _cmd
 epilog = None           # text to print at the bottom of --help
-wantsTradeDB = True     # Should we try to load the cache at startup?
-usesTradeData = True    # Will we be needing trading data?
-arguments = [
-    #ParseArgument('near', help='System to start from', type=str),
-]
-switches = [
-    #ParseArgument('--ly-per',
-    #       help='Maximum light years per jump.',
-    #       dest='maxLyPer',
-    #       metavar='N.NN',
-    #       type=float,
-    #   ),
-]
 
-######################################################################
-# Helpers
+# Whether this command needs a TradeDB instance
+wantsTradeDB = True
+usesTradeData = False
 
-######################################################################
-# Perform query and populate result set
+# Parser wiring (keep tuples for consistency with loader)
+from .parsing import ParseArgument  # import specific helpers as needed
+arguments = (
+    ParseArgument("name", help="Example positional(s).", type=str, nargs="*"),
+)
+switches = (
+    ParseArgument("--flag", help="Example flag.", action="store_true", default=False),
+)
+
+# Runtime API
+from .commandenv import ResultRow
+from ..formatting import RowFormat, ColumnFormat  # use package-relative imports
 
 def run(results, cmdenv, tdb):
     """
@@ -44,12 +40,10 @@ def run(results, cmdenv, tdb):
     """
     
     ### TODO: Implement
-    
+    row = ResultRow(example="ok")
+    results.rows.append(row)
     return results
 
-######################################################################
-# Transform result set into output
-
 def render(results, cmdenv, tdb):
     """
     If run() returns a non-None value, the trade.py code will then
@@ -57,5 +51,10 @@ def render(results, cmdenv, tdb):
     
     This is where you should generate any output from your command.
     """
-    
-    ### TODO: Implement
+    fmt = RowFormat()
+    fmt.addColumn("Example", "<", 10, key=lambda r: getattr(r, "example", ""))
+    if not cmdenv.quiet:
+        hdr, ul = fmt.heading()
+        print(hdr, ul, sep="\n")
+    for row in results.rows:
+        print(fmt.format(row))

tradedangerous/commands/__init__.py

@@ -101,12 +101,6 @@ class CommandIndex:
         # Figure out the pre-indentation
         cmdFmt = '  {:<12s}  '
         cmdFmtLen = len(cmdFmt.format(''))
-        # Generate a formatter which will produce nicely formatted text
-        # that wraps at column 78 but puts continuation text one character
-        # indented from where the previous text started, e.g
-        #   cmd1    Cmd1 help text stuff
-        #            continued cmd1 text
-        #   cmd2    Cmd2 help text
         tw = TextWrapper(
                 subsequent_indent = ' ' * (cmdFmtLen + 1),
                 width = 78,
@@ -117,14 +111,12 @@ class CommandIndex:
                 break_on_hyphens = True,
                 )
         
-        # List each command with its help text
         lastCmdName = None
         for cmdName, cmd in sorted(commandIndex.items()):
             tw.initial_indent = cmdFmt.format(cmdName)
             text += tw.fill(cmd.help) + "\n"
             lastCmdName = cmdName
         
-        # Epilog
         text += (
             "\n"
             "For additional help on a specific command, such as '{cmd}' use\n"
@@ -139,10 +131,6 @@ class CommandIndex:
                     "TradeDangerous provides a set of trade database "
                     "facilities for Elite:Dangerous.", self.usage(argv))
         
-        # ## TODO: Break this model up a bit more so that
-        # ## we just try and import the command you specify,
-        # ## and only worry about an index when that fails or
-        # ## the user requests usage.
         cmdName, cmdModule = argv[1].casefold(), None
         try:
             cmdModule = commandIndex[cmdName]
@@ -172,7 +160,6 @@ class CommandIndex:
             cmdModule = candidates[0][1]
         
         class ArgParser(argparse.ArgumentParser):
-            
             def error(self, message):
                 raise exceptions.CommandLineError(message, self.format_usage())
         
@@ -244,9 +231,14 @@ class CommandIndex:
         fromfilePath = _findFromFile(cmdModule.name)
         if fromfilePath:
             argv.insert(2, '{}{}'.format(fromfile_prefix, fromfilePath))
-        properties = parser.parse_args(argv[1:])
         
-        parsed = CommandEnv(properties, argv, cmdModule)
-        parsed.DEBUG0("Command line was: {}", argv)
+        # Parse argv; optionally swallow unknown args/switches if the module allows it.
+        accept_unknown = getattr(cmdModule, 'acceptUnknown', False)
+        if accept_unknown:
+            properties, _unknown = parser.parse_known_args(argv[1:])
+        else:
+            properties = parser.parse_args(argv[1:])
         
+        parsed = CommandEnv(vars(properties), argv, cmdModule)
+        parsed.DEBUG0("Command line was: {}", argv)
         return parsed

tradedangerous/commands/buildcache_cmd.py

@@ -53,16 +53,46 @@ switches = [
 
 
 def run(results, cmdenv, tdb: TradeDB):
-    # Check that the file doesn't already exist.
-    if not cmdenv.force:
-        if tdb.dbPath.exists():
-            raise CommandLineError(
-                f"SQLite3 database '{tdb.dbFilename}' already exists.\n"
-                "Either remove the file first or use the '-f' option.")
-    
+    """
+    BRUTE-FORCE rebuild of the cache/database.
+
+    Semantics preserved:
+      - If DB exists and --force not given => error
+      - SQL file must exist
+      - Performs a full destructive rebuild
+
+    Implementation change:
+      - Delegates to tradedangerous.db.lifecycle.ensure_fresh_db with mode='force'
+        so all backend-specific checks and rebuild steps run via the central path.
+    """
+    # Deprecation note: keep short and visible but non-fatal.
+    print("NOTE: 'buildcache' is deprecated. Prefer 'update' or importer plugins. "
+          "Proceeding with a forced rebuild via db.lifecycle.ensure_fresh_db().")
+
+    # Honor legacy safety: require --force to overwrite an existing DB file.
+    if not cmdenv.force and tdb.dbPath.exists():
+        raise CommandLineError(
+            f"SQLite3 database '{tdb.dbFilename}' already exists.\n"
+            "Either remove the file first or use the '-f/--force' option."
+        )
+
+    # Ensure the SQL source exists (buildCache ultimately relies on this path).
     if not tdb.sqlPath.exists():
         raise CommandLineError(f"SQL File does not exist: {tdb.sqlFilename}")
-    
-    buildCache(tdb, cmdenv)
-    
+
+    # Force a rebuild through the lifecycle helper (works for both backends).
+    from tradedangerous.db.lifecycle import ensure_fresh_db
+
+    ensure_fresh_db(
+        backend=tdb.engine.dialect.name if getattr(tdb, "engine", None) else "sqlite",
+        engine=getattr(tdb, "engine", None),
+        data_dir=tdb.dataPath,
+        metadata=None,
+        mode="force",
+        tdb=tdb,
+        tdenv=cmdenv,
+        rebuild=True,
+    )
+
     return None
+

tradedangerous/commands/buy_cmd.py

@@ -8,6 +8,7 @@ from .parsing import (
     AvoidPlacesArgument, BlackMarketSwitch, FleetCarrierArgument, MutuallyExclusiveGroup,
     NoPlanetSwitch, OdysseyArgument, PadSizeArgument, ParseArgument, PlanetaryArgument,
 )
+from sqlalchemy import text
 
 # TODO: Add UPGRADE_MODE
 ITEM_MODE = "Item"
@@ -176,52 +177,57 @@ def get_lookup_list(cmdenv, tdb):
 
 
 def sql_query(cmdenv, tdb, queries, mode):
-    # Constraints
-    idList = ','.join(str(ID) for ID in queries.keys())
+    """
+    Backend-portable query builder.
+    - Uses named binds (':param') instead of SQLite '?'.
+    - Materializes rows eagerly to avoid closed-cursor issues.
+    - Preserves return shapes:
+        * Ship:   (ship_id, station_id, cost, 1)
+        * Item:   (item_id, station_id, supply_price, supply_units)
+    """
+    ids = list(queries.keys())
+
+    # Build a stable, named-parameter IN(...) list
+    params = {}
+    placeholders = []
+    for i, val in enumerate(ids):
+        key = f"id{i}"
+        placeholders.append(f":{key}")
+        params[key] = val
+    id_list_sql = ",".join(placeholders)
+
     if mode is SHIP_MODE:
-        tables = "ShipVendor AS s INNER JOIN Ship AS sh USING (ship_id)"
-        constraints = ["(ship_id IN ({}))".format(idList)]
-        columns = [
-            's.ship_id',
-            's.station_id',
-            'sh.cost',
-            '1',
-            ]
-        bindValues = []
+        columns = "s.ship_id, s.station_id, sh.cost, 1"
+        tables = "ShipVendor AS s JOIN Ship AS sh ON sh.ship_id = s.ship_id"
+        constraints = [f"(s.ship_id IN ({id_list_sql}))"]
     else:
+        columns = "s.item_id, s.station_id, s.supply_price, s.supply_units"
         tables = "StationItem AS s"
-        columns = [
-            's.item_id',
-            's.station_id',
-            's.supply_price',
-            's.supply_units',
-        ]
         constraints = [
-            "(s.item_id IN ({}))".format(idList),
-            "(s.supply_price > 0)",
+            f"(s.item_id IN ({id_list_sql}))",
+            "(s.supply_price > 0)",  # preserves index intent across backends
         ]
-        bindValues = []
-    
-    # Additional constraints in ITEM_MODE
-    if mode is ITEM_MODE:
         if cmdenv.supply:
-            constraints.append("(supply_units >= ?)")
-            bindValues.append(cmdenv.supply)
+            constraints.append("(s.supply_units >= :supply)")
+            params["supply"] = cmdenv.supply
         if cmdenv.lt:
-            constraints.append("(supply_price < ?)")
-            bindValues.append(cmdenv.lt)
+            constraints.append("(s.supply_price < :lt)")
+            params["lt"] = cmdenv.lt
         if cmdenv.gt:
-            constraints.append("(supply_price > ?)")
-            bindValues.append(cmdenv.gt)
-    
-    whereClause = ' AND '.join(constraints)
-    stmt = """SELECT DISTINCT {columns} FROM {tables} WHERE {where}""".format(
-        columns = ','.join(columns),
-        tables = tables,
-        where = whereClause
-    )
-    cmdenv.DEBUG0('SQL: {}', stmt)
-    return tdb.query(stmt, bindValues)
+            constraints.append("(s.supply_price > :gt)")
+            params["gt"] = cmdenv.gt
+
+    where_clause = " AND ".join(constraints)
+    stmt = f"SELECT DISTINCT {columns} FROM {tables} WHERE {where_clause}"
+    cmdenv.DEBUG0('SQL: {} ; params={}', stmt, params)
+
+    # Eagerly fetch to avoid closed cursor when iterating later.
+    with tdb.engine.connect() as conn:
+        result = conn.execute(text(stmt), params)
+        rows = result.fetchall()
+    return rows
+
+
 
 ######################################################################
 # Perform query and populate result set
@@ -256,14 +262,17 @@ def run(results, cmdenv, tdb):
         if mode is SHIP_MODE:
             results.summary.avg = first.cost
         else:
-            avgPrice = tdb.query("""
-                SELECT AVG(si.supply_price)
-                  FROM StationItem AS si
-                 WHERE si.item_id = ? AND si.supply_price > 0
-            """, [first.ID]).fetchone()[0]
-            if not avgPrice:
-                avgPrice = 0
-            results.summary.avg = int(avgPrice)
+            # Portable AVG with named bind; eager scalar fetch
+            with tdb.engine.connect() as conn:
+                avg_val = conn.execute(
+                    text("""
+                        SELECT AVG(si.supply_price) AS avg_price
+                          FROM StationItem AS si
+                         WHERE si.item_id = :item_id AND si.supply_price > 0
+                    """),
+                    {"item_id": first.ID},
+                ).scalar()
+            results.summary.avg = int(avg_val or 0)
     
     # System-based search
     nearSystem = cmdenv.nearSystem
@@ -360,6 +369,8 @@ def run(results, cmdenv, tdb):
     
     return results
 
+
+
 #######################################################################
 # # Transform result set into output
 

tradedangerous/commands/commandenv.py

@@ -1,5 +1,3 @@
-import sqlite3
-
 from .exceptions import (
     CommandLineError, FleetCarrierError, OdysseyError,
     PadSizeError, PlanetaryError,

tradedangerous/commands/export_cmd.py

@@ -3,8 +3,6 @@ from .parsing import ParseArgument, MutuallyExclusiveGroup
 from .exceptions import CommandLineError
 from pathlib import Path
 
-import sqlite3
-
 ######################################################################
 # TradeDangerous :: Commands :: Export
 #
@@ -63,61 +61,91 @@ switches = [
 # Perform query and populate result set
 
 def run(results, cmdenv, tdb):
-    # check database exists
-    if not tdb.dbPath.is_file():
-        raise CommandLineError("Database '{}' not found.".format(tdb.dbPath))
-    
-    # check export path exists
-    if cmdenv.path:
-        # the "--path" overwrites the default path of TD
-        exportPath = Path(cmdenv.path)
-    else:
-        exportPath = Path(cmdenv.dataDir)
+    """
+    Backend-neutral export of DB tables to CSV.
+
+    Changes:
+      * Use tradedangerous.db.lifecycle.ensure_fresh_db(rebuild=False) to verify a usable DB
+        without rebuilding (works for SQLite and MariaDB).
+      * Backend-aware announcement of the source DB (file path for SQLite, DSN for others).
+      * Table enumeration via SQLAlchemy inspector (no sqlite_master, no COLLATE quirks).
+    """
+    # --- Sanity check the database without rebuilding (works for both backends) ---
+    from tradedangerous.db.lifecycle import ensure_fresh_db  # local import avoids import-time tangles
+    summary = ensure_fresh_db(
+        backend=getattr(tdb.engine, "dialect", None).name if getattr(tdb, "engine", None) else "unknown",
+        engine=getattr(tdb, "engine", None),
+        data_dir=tdb.dataPath,
+        metadata=None,
+        mode="auto",
+        rebuild=False,   # IMPORTANT: never rebuild from here; just report health
+    )
+    if summary.get("sane") != "Y":
+        reason = summary.get("reason", "unknown")
+        raise CommandLineError(
+            f"Database is not initialized/healthy (reason: {reason}). "
+            "Use 'buildcache' or an importer to (re)build it."
+        )
+
+    # --- Determine export target directory (same behavior as before) ---
+    from pathlib import Path
+    exportPath = Path(cmdenv.path) if cmdenv.path else Path(tdb.dataDir)
     if not exportPath.is_dir():
         raise CommandLineError("Save location '{}' not found.".format(str(exportPath)))
-    
-    # connect to the database
-    cmdenv.NOTE("Using database '{}'", tdb.dbPath)
-    conn = tdb.getDB()
-    conn.row_factory = sqlite3.Row
-    
-    # some tables might be ignored
+
+    # --- Announce which DB we will read from, backend-aware ---
+    try:
+        dialect = tdb.engine.dialect.name
+        if dialect == "sqlite":
+            source_label = f"SQLite file '{tdb.dbPath}'"
+        else:
+            # Hide password in DSN
+            source_label = f"{dialect} @ {tdb.engine.url.render_as_string(hide_password=True)}"
+    except Exception:
+        source_label = str(getattr(tdb, "dbPath", "Unknown DB"))
+    cmdenv.NOTE("Using database {}", source_label)
+
+    # --- Enumerate tables using SQLAlchemy inspector (backend-neutral) ---
+    from sqlalchemy import inspect
+    inspector = inspect(tdb.engine)
+    all_tables = inspector.get_table_names()  # current schema / database
+
+    # Optional ignore list (preserve legacy default: skip StationItem unless --all-tables)
     ignoreList = []
-    
-    # extract tables from command line
-    if cmdenv.tables:
-        bindValues = cmdenv.tables.split(',')
-        tableStmt = " AND name COLLATE NOCASE IN ({})".format(",".join("?" * len(bindValues)))
-        cmdenv.DEBUG0(tableStmt)
+    if not getattr(cmdenv, "allTables", False):
+        ignoreList.append("StationItem")
+
+    # --tables filtering (case-insensitive, like old COLLATE NOCASE)
+    if getattr(cmdenv, "tables", None):
+        requested = [t.strip() for t in cmdenv.tables.split(",") if t.strip()]
+        lower_map = {t.lower(): t for t in all_tables}
+        resolved = []
+        for name in requested:
+            found = lower_map.get(name.lower())
+            if found:
+                resolved.append(found)
+            else:
+                cmdenv.NOTE("Requested table '{}' not found; skipping", name)
+        table_list = sorted(set(resolved))
     else:
-        bindValues = []
-        tableStmt = ''
-        if not cmdenv.allTables:
-            ignoreList.append("StationItem")
-    
-    tableCursor = conn.cursor()
-    for row in tableCursor.execute("""
-                                      SELECT name
-                                        FROM sqlite_master
-                                       WHERE type = 'table'
-                                         AND name NOT LIKE 'sqlite_%'
-                                             {cmdTables}
-                                       ORDER BY name
-                                   """.format(cmdTables=tableStmt),
-                                   bindValues):
-        tableName = row['name']
+        table_list = sorted(set(all_tables))
+
+    # --- Export each table via csvexport (already refactored elsewhere) ---
+    for tableName in table_list:
         if tableName in ignoreList:
-            # ignore the table
             cmdenv.NOTE("Ignore Table '{table}'", table=tableName)
             continue
-        
+
         cmdenv.NOTE("Export Table '{table}'", table=tableName)
-        
-        # create CSV files
+
         lineCount, filePath = exportTableToFile(tdb, cmdenv, tableName, exportPath)
-        if cmdenv.deleteEmpty and lineCount == 0:
-            # delete file if emtpy
-            filePath.unlink()
-            cmdenv.DEBUG0("Delete empty file {file}'".format(file=filePath))
-    
+
+        # Optionally delete empty CSVs
+        if getattr(cmdenv, "deleteEmpty", False) and lineCount == 0:
+            try:
+                filePath.unlink(missing_ok=True)
+                cmdenv.DEBUG0("Delete empty file {file}", file=filePath)
+            except Exception as e:
+                cmdenv.DEBUG0("Failed to delete empty file {file}: {err}", file=filePath, err=e)
+
     return None

tradedangerous/commands/import_cmd.py

@@ -1,3 +1,15 @@
+# tradedangerous/commands/import_cmd.py
+# DEPRECATED: The legacy “.prices” import path is deprecated.
+# Prefer supported import plugins:
+#   - trade import -P spansh      (authoritative bulk dump)
+#   - trade import -P eddblink    (server listings pipeline)
+# Solo / offline players: use the TradeDangerous DB-Update plugin for EDMC:
+#   https://github.com/bgol/UpdateTD
+#
+# This module remains available for compatibility with old “.prices” files,
+# but the format is being phased out and may be removed in a future release.
+
+
 from .exceptions import CommandLineError
 from .parsing import ParseArgument, MutuallyExclusiveGroup
 from itertools import chain
@@ -104,7 +116,13 @@ switches = [
 
 
 def run(results, cmdenv, tdb):
-    # If we're using a plugin, initialize that first.
+    """
+    Dispatch import work:
+      • If a plugin (-P) is specified: load it and run it (no deprecation banner).
+      • Otherwise: proceed with legacy .prices/.url flow and show a deprecation notice.
+    """
+
+    # --- Plugin path (preferred; no banner) ---
     if cmdenv.plug:
         if cmdenv.pluginOptions:
             cmdenv.pluginOptions = chain.from_iterable(
@@ -114,65 +132,83 @@ def run(results, cmdenv, tdb):
             pluginClass = plugins.load(cmdenv.plug, "ImportPlugin")
         except plugins.PluginException as e:
             raise CommandLineError("Plugin Error: " + str(e))
-        
-        # Initialize the plugin
+
         plugin = pluginClass(tdb, cmdenv)
-        
-        # Run the plugin. If it returns False, then it did everything
-        # that needs doing and we can stop now.
-        # If it returns True, it is returning control to the module.
+
+        # If plugin returns False, it fully handled the run → stop here.
         if not plugin.run():
             return None
-    
+
+        # If plugin returns True, it’s handing control back to legacy flow below.
+        # Fall through intentionally (still no banner, as user invoked a plugin).
+
+    # --- Legacy .prices path (deprecated; show banner once) ---
+    # Only warn when the user is *not* using a plugin. Keep functionality intact.
+    if not cmdenv.plug:
+        print(
+            "NOTE:\n"
+            "=== DEPRECATION NOTICE ============================================\n"
+            "The legacy '.prices' import is deprecated.\n"
+            "Use a supported plugin instead:\n"
+            "  • trade import -P spansh\n"
+            "  • trade import -P eddblink\n"
+            "Solo/offline: TradeDangerous DB-Update for EDMC → https://github.com/bgol/UpdateTD\n"
+            "===================================================================\n"
+        )
+
+    # Refresh/close any cached handles before file ops (kept from original)
     tdb.reloadCache()
     tdb.close()
-    
+
+    # Treat a bare http(s) string in 'filename' as a URL
     if cmdenv.filename:
         if re.match(r"^https?://", cmdenv.filename, re.IGNORECASE):
             cmdenv.url, cmdenv.filename = cmdenv.filename, None
-    
+
+    # Optional download step
     if cmdenv.url:
         cmdenv.filename = cmdenv.filename or "import.prices"
         transfers.download(cmdenv, cmdenv.url, cmdenv.filename)
         if cmdenv.download:
             return None
-    
-    # If the filename specified was "-" or None, then go ahead
-    # and present the user with an open file dialog.
+
+    # No filename? If Tk is available, prompt user (legacy behavior)
+    fh = None
     if not cmdenv.filename and hasTkInter:
         tk = tkinter.Tk()
         tk.withdraw()
         filetypes = (
-                ("TradeDangerous '.prices' Files", "*.prices"),
-                ("All Files", "*.*"),
-                )
+            ("TradeDangerous '.prices' Files", "*.prices"),
+            ("All Files", "*.*"),
+        )
         filename = tkfd.askopenfilename(
-                    title = "Select the file to import",
-                    initialfile = "TradeDangerous.prices",
-                    filetypes = filetypes,
-                    initialdir = '.',
-                )
+            title="Select the file to import",
+            initialfile="TradeDangerous.prices",
+            filetypes=filetypes,
+            initialdir='.',
+        )
         if not filename:
             raise SystemExit("Aborted")
         cmdenv.filename = filename
-    
-    # check the file exists.
+
+    # Validate path or use stdin
     if cmdenv.filename != "-":
-        fh = None
         filePath = Path(cmdenv.filename)
         if not filePath.is_file():
-            raise CommandLineError("File not found: {}".format(
-                        str(filePath)
-                    ))
+            raise CommandLineError(f"File not found: {str(filePath)}")
     else:
         filePath = "stdin"
         fh = sys.stdin
-    
+
+    # If a plugin was also involved and wants to finish with default flow,
+    # honour that (unchanged behavior).
     if cmdenv.plug:
+        # Plugins returning True above chose to hand control back.
+        # finish() may return False to suppress default regeneration.
         if not plugin.finish():
             cache.regeneratePricesFile()
             return None
-    
-    cache.importDataFromFile(tdb, cmdenv, filePath, pricesFh = fh, reset = cmdenv.reset)
-    
+
+    # Legacy .prices import
+    cache.importDataFromFile(tdb, cmdenv, filePath, pricesFh=fh, reset=cmdenv.reset)
     return None