tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/commands/import_cmd.py

@@ -0,0 +1,222 @@
+# 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 __future__ import annotations
+
+from .exceptions import CommandLineError
+from .parsing import ParseArgument, MutuallyExclusiveGroup
+from itertools import chain
+from pathlib import Path
+
+from .. import cache, plugins, transfers
+import re
+import sys
+import typing
+
+try:
+    import tkinter
+    import tkinter.filedialog as tkfd
+    hasTkInter = True
+except ImportError:
+    hasTkInter = False
+
+if typing.TYPE_CHECKING:
+    from ..tradedb import TradeDB
+    from ..tradeenv import TradeEnv
+
+
+######################################################################
+# Parser config
+
+help = (
+    "TD data import system. On its own, this command lets you "
+    "merge station prices from a '.prices' file (entries in the "
+    "file that are older than your local data are not loaded)."
+)
+name = 'import'
+epilog = (
+    "This sub-command provides a plugin infrastructure, and comes "
+    "with a module to import data from Tromador's Trading Dangerously server"
+    "(https://elite.tromador.com/).\n"
+    "See \"trade import -P eddblink -O help\" for more help."
+)
+wantsTradeDB = False
+arguments = [
+]
+switches = [
+    MutuallyExclusiveGroup(
+        ParseArgument('filename',
+            help = (
+                "Name of the file to read, or, used with '--url', "
+                "will save the downloaded file as this name."
+            ),
+            type = str,
+            default = None,
+        ),
+        ParseArgument('--plug', '-P',
+                help = "Use the specified import plugin.",
+                type = str,
+                default = None,
+        ),
+    ),
+    ParseArgument('--url',
+        help = 'URL to download filename (default "import.prices") from.',
+        type = str,
+        default = None,
+    ),
+    ParseArgument('--download',
+        help = 'Stop after downloading.',
+        action = 'store_true',
+        default = False,
+    ),
+    ParseArgument(
+        '--ignore-unknown', '-i',
+        default = False, action = 'store_true',
+        dest = 'ignoreUnknown',
+        help = (
+            "Data for systems, stations and items that are not "
+            "recognized is reported as warning but skipped."
+        ),
+    ),
+    ParseArgument(
+        '--option', '-O',
+        default = [], action = 'append',
+        dest = 'pluginOptions',
+        help = (
+            "Provides a way to pass additional arguments to plugins."
+        ),
+    ),
+    MutuallyExclusiveGroup(
+        ParseArgument('--reset-all',
+            help = 'Clear the database before importing.',
+            action = 'store_true',
+            default = False,
+        ),
+        ParseArgument('--merge-import', '-M',
+            help = (
+                'Merge the import file with the existing local database: '
+                'only loads values that have an explicit entry with a '
+                'newer timestamp than the existing data. Local values '
+                'are only removed if there is an explicit entry with a '
+                '0/0 demand/supply price.'
+            ),
+            action = 'store_true',
+            default = False,
+            dest = 'mergeImport',
+        ),
+    ),
+]
+
+######################################################################
+# Helpers
+
+######################################################################
+# Perform query and populate result set
+
+
+def run(results, cmdenv: TradeEnv, tdb: TradeDB):
+    """
+    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(
+                opt.split(',') for opt in cmdenv.pluginOptions
+            )
+        try:
+            pluginClass = plugins.load(cmdenv.plug, "ImportPlugin")
+        except plugins.PluginException as e:
+            raise CommandLineError("Plugin Error: " + str(e))
+        
+        plugin = pluginClass(tdb, cmdenv)
+        
+        # If plugin returns False, it fully handled the run → stop here.
+        if not plugin.run():
+            return False
+        
+        # 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()
+    tdb.removePerist()
+    
+    # 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 False
+    
+    # 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", "*.*"),
+        )
+        filename = tkfd.askopenfilename(
+            title="Select the file to import",
+            initialfile="TradeDangerous.prices",
+            filetypes=filetypes,
+            initialdir='.',
+        )
+        if not filename:
+            raise SystemExit("Aborted")
+        cmdenv.filename = filename
+    
+    # Validate path or use stdin
+    if cmdenv.filename != "-":
+        filePath = Path(cmdenv.filename)
+        if not filePath.is_file():
+            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 False
+    
+    # Legacy .prices import
+    cache.importDataFromFile(tdb, cmdenv, filePath, pricesFh=fh, reset=cmdenv.reset)
+    return False

tradedangerous/commands/local_cmd.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+from itertools import chain
+
+from .commandenv import ResultRow
+from .exceptions import NoDataError
+from .parsing import (
+    ParseArgument, PadSizeArgument, MutuallyExclusiveGroup, NoPlanetSwitch,
+    PlanetaryArgument, FleetCarrierArgument, OdysseyArgument, BlackMarketSwitch,
+    ShipyardSwitch, OutfittingSwitch, RearmSwitch, RefuelSwitch, RepairSwitch,
+)
+from tradedangerous import TradeDB
+from tradedangerous.formatting import RowFormat, ColumnFormat, max_len
+
+
+######################################################################
+# Parser config
+
+name='local'
+help='Calculate local systems.'
+epilog="See also the 'station' sub-command."
+wantsTradeDB=True
+arguments = [
+    ParseArgument(
+            'near',
+            help='Name of the system to query from.',
+            type=str,
+            metavar='SYSTEMNAME',
+    ),
+]
+switches = [
+    ParseArgument('--ly',
+            help='Maximum light years from system.',
+            dest='ly',
+            metavar='N.NN',
+            type=float,
+            default=None,
+    ),
+    PadSizeArgument(),
+    MutuallyExclusiveGroup(
+        NoPlanetSwitch(),
+        PlanetaryArgument(),
+    ),
+    FleetCarrierArgument(),
+    OdysseyArgument(),
+    ParseArgument('--stations',
+            help='Limit to systems which have stations.',
+            action='store_true',
+    ),
+    ParseArgument('--trading',
+            help='Limit stations to ones with price data or flagged as having '
+                 'a market.',
+            action='store_true',
+    ),
+    BlackMarketSwitch(),
+    ShipyardSwitch(),
+    OutfittingSwitch(),
+    RearmSwitch(),
+    RefuelSwitch(),
+    RepairSwitch(),
+]
+
+######################################################################
+# Perform query and populate result set
+
+def run(results, cmdenv, tdb):
+    cmdenv = results.cmdenv
+    tdb = cmdenv.tdb
+    srcSystem = cmdenv.nearSystem
+    
+    # Allow the user to say '0' for system-only
+    ly = cmdenv.ly if cmdenv.ly is not None else cmdenv.maxSystemLinkLy
+    
+    results.summary = ResultRow()
+    results.summary.near = srcSystem
+    results.summary.ly = ly
+    results.summary.stations = 0
+    
+    distances = { srcSystem: 0.0 }
+    
+    # Calculate the bounding dimensions
+    for destSys, dist in tdb.genSystemsInRange(srcSystem, ly):
+        distances[destSys] = dist
+    
+    showStations = cmdenv.detail
+    wantStations = cmdenv.stations
+    padSize = cmdenv.padSize
+    planetary = cmdenv.planetary
+    fleet = cmdenv.fleet
+    odyssey = cmdenv.odyssey
+    wantNoPlanet = cmdenv.noPlanet
+    wantTrading = cmdenv.trading
+    wantShipYard = cmdenv.shipyard
+    wantBlackMarket = cmdenv.blackMarket
+    wantOutfitting = cmdenv.outfitting
+    wantRearm = cmdenv.rearm
+    wantRefuel = cmdenv.refuel
+    wantRepair = cmdenv.repair
+    
+    def station_filter(stations):
+        for station in stations:
+            if wantNoPlanet and station.planetary != 'N':
+                continue
+            if wantTrading and not station.isTrading:
+                continue
+            if wantBlackMarket and station.blackMarket != 'Y':
+                continue
+            if wantShipYard and station.shipyard != 'Y':
+                continue
+            if padSize and not station.checkPadSize(padSize):
+                continue
+            if planetary and not station.checkPlanetary(planetary):
+                continue
+            if fleet and not station.checkFleet(fleet):
+                continue
+            if odyssey and not station.checkOdyssey(odyssey):
+                continue
+            if wantOutfitting and station.outfitting != 'Y':
+                continue
+            if wantRearm and station.rearm != 'Y':
+                continue
+            if wantRefuel and station.refuel != 'Y':
+                continue
+            if wantRepair and station.repair != 'Y':
+                continue
+            yield station
+    
+    for (system, dist) in sorted(distances.items(), key=lambda x: x[1]):
+        if showStations or wantStations:
+            stations = []
+            for (station) in station_filter(system.stations):
+                stations.append(
+                    ResultRow(
+                        station=station,
+                        age=station.itemDataAgeStr,
+                    )
+                )
+            if not stations and wantStations:
+                continue
+        
+        row = ResultRow()
+        row.system = system
+        row.dist = dist
+        row.stations = stations if showStations else []
+        results.rows.append(row)
+        results.summary.stations += len(row.stations)
+    
+    return results
+
+
+def render(results, cmdenv, tdb):
+    """ render transforms a result set into output for the CLI. """
+    if not results or not results.rows:
+        distance, origin = results.summary.ly, results.summary.near.name()
+        raise NoDataError(f"No suitable systems found within {distance}ly of {origin}.")
+    
+    # Compare name lengths for formatting
+    maxSysLen = max_len(results.rows, key=lambda row: row.system.name())
+    
+    sysRowFmt = RowFormat().append(
+        ColumnFormat("System", '<', maxSysLen,
+                key=lambda row: row.system.name())
+    ).append(
+        ColumnFormat("Dist", '>', '7', '.2f',
+                key=lambda row: row.dist)
+    )
+    
+    showStations = cmdenv.detail
+    if showStations:
+        maxStnLen = max_len(
+            chain.from_iterable(row.stations for row in results.rows),
+            key=lambda row: row.station.dbname
+        )
+        maxLsLen = max_len(
+            chain.from_iterable(row.stations for row in results.rows),
+            key=lambda row: row.station.distFromStar()
+        )
+        maxLsLen = max(maxLsLen, 5)
+        stnRowFmt = RowFormat(prefix='  /  ').append(
+                ColumnFormat("Station", '.<', maxStnLen + 2,
+                    key=lambda row: row.station.dbname)
+        ).append(
+                ColumnFormat("StnLs", '>', maxLsLen,
+                    key=lambda row: row.station.distFromStar())
+        ).append(
+                ColumnFormat("Age/days", '>', 7,
+                        key=lambda row: row.age)
+        ).append(
+                ColumnFormat("Mkt", '>', '3',
+                    key=lambda row: TradeDB.marketStates[row.station.market])
+        ).append(
+                ColumnFormat("BMk", '>', '3',
+                    key=lambda row: TradeDB.marketStates[row.station.blackMarket])
+        ).append(
+                ColumnFormat("Shp", '>', '3',
+                    key=lambda row: TradeDB.marketStates[row.station.shipyard])
+        ).append(
+                ColumnFormat("Out", '>', '3',
+                    key=lambda row: TradeDB.marketStates[row.station.outfitting])
+        ).append(
+                ColumnFormat("Arm", '>', '3',
+                    key=lambda row: TradeDB.marketStates[row.station.rearm])
+        ).append(
+                ColumnFormat("Ref", '>', '3',
+                    key=lambda row: TradeDB.marketStates[row.station.refuel])
+        ).append(
+                ColumnFormat("Rep", '>', '3',
+                    key=lambda row: TradeDB.marketStates[row.station.repair])
+        ).append(
+                ColumnFormat("Pad", '>', '3',
+                    key=lambda row: TradeDB.padSizes[row.station.maxPadSize])
+        ).append(
+                ColumnFormat("Plt", '>', '3',
+                    key=lambda row: TradeDB.planetStates[row.station.planetary])
+        ).append(
+                ColumnFormat("Flc", '>', '3',
+                    key=lambda row: TradeDB.fleetStates[row.station.fleet])
+        ).append(
+                ColumnFormat("Ody", '>', '3',
+                    key=lambda row: TradeDB.odysseyStates[row.station.odyssey])
+        )
+        if cmdenv.detail > 1:
+            stnRowFmt.append(
+                ColumnFormat("Itms", ">", 4,
+                    key=lambda row: row.station.itemCount)
+            )
+    
+    cmdenv.DEBUG0(
+        "Systems within {ly:<5.2f}ly of {sys}.\n",
+        sys=results.summary.near.name(),
+        ly=results.summary.ly,
+    )
+    
+    if not cmdenv.quiet:
+        heading, underline = sysRowFmt.heading()
+        if showStations:
+            print(heading)
+            heading, underline = stnRowFmt.heading()
+        print(heading, underline, sep='\n')
+    
+    for row in results.rows:
+        print(sysRowFmt.format(row))
+        for stnRow in row.stations:
+            print(stnRowFmt.format(stnRow))

tradedangerous/commands/market_cmd.py

@@ -0,0 +1,207 @@
+from .commandenv import ResultRow
+from .exceptions import CommandLineError
+from .parsing import (
+    ParseArgument, MutuallyExclusiveGroup,
+)
+from ..formatting import RowFormat
+from sqlalchemy import select, table, column
+from sqlalchemy.orm import Session
+
+
+######################################################################
+# Parser config
+
+help='Lists items bought/sold at a given station.'
+name='market'
+epilog=None
+wantsTradeDB=True
+arguments = [
+    ParseArgument(
+        'origin',
+        help='Station being queried.',
+        metavar='STATIONNAME',
+        type=str,
+    ),
+]
+switches = [
+    MutuallyExclusiveGroup(
+        ParseArgument(
+            '--buying', '-B',
+            help='Show items station is buying',
+            action='store_true',
+        ),
+        ParseArgument(
+            '--selling', '-S',
+            help='Show items station is selling',
+            action='store_true',
+        ),
+    ),
+]
+
+######################################################################
+# Perform query and populate result set
+
+
+def render_units(units, level):
+    if level == 0:
+        return '-'
+    if units < 0:
+        return '?'
+    levelNames = { -1: '?', 1: 'L', 2: 'M', 3: 'H' }
+    return "{:n}{}".format(units, levelNames[level])
+
+
+def run(results, cmdenv, tdb):
+    # Lazy import to avoid any import-time tangles elsewhere.
+    from tradedangerous.db.utils import age_in_days
+    
+    origin = cmdenv.startStation
+    if not origin.itemCount:
+        raise CommandLineError(
+            "No trade data available for {}".format(origin.name())
+        )
+    
+    buying, selling = cmdenv.buying, cmdenv.selling
+    
+    results.summary = ResultRow()
+    results.summary.origin = origin
+    results.summary.buying = cmdenv.buying
+    results.summary.selling = cmdenv.selling
+    
+    # Precompute averages (unchanged)
+    tdb.getAverageSelling()
+    tdb.getAverageBuying()
+    
+    # --- Backend-neutral query using SQLAlchemy Core + age_in_days ---
+    si = table(
+        "StationItem",
+        column("item_id"),
+        column("station_id"),
+        column("demand_price"),
+        column("demand_units"),
+        column("demand_level"),
+        column("supply_price"),
+        column("supply_units"),
+        column("supply_level"),
+        column("modified"),
+    )
+    
+    # Build session bound to current engine (needed by age_in_days)
+    session = Session(bind=tdb.engine)
+    
+    stmt = (
+        select(
+            si.c.item_id,
+            si.c.demand_price, si.c.demand_units, si.c.demand_level,
+            si.c.supply_price, si.c.supply_units, si.c.supply_level,
+            age_in_days(session, si.c.modified).label("age_days"),
+        )
+        .where(si.c.station_id == origin.ID)
+    )
+    
+    rows = session.execute(stmt).fetchall()
+    session.close()
+    
+    for r in rows:
+        it = iter(r)
+        item = tdb.itemByID[next(it)]
+        
+        row = ResultRow()
+        row.item = item
+        
+        row.buyCr = int(next(it) or 0)
+        row.avgBuy = tdb.avgBuying.get(item.ID, 0)
+        units, level = int(next(it) or 0), int(next(it) or 0)
+        row.buyUnits = units
+        row.buyLevel = level
+        row.demand = render_units(units, level)
+        if not selling:
+            hasBuy = (row.buyCr or units or level)
+        else:
+            hasBuy = False
+        
+        row.sellCr = int(next(it) or 0)
+        row.avgSell = tdb.avgSelling.get(item.ID, 0)
+        units, level = int(next(it) or 0), int(next(it) or 0)
+        row.sellUnits = units
+        row.sellLevel = level
+        row.supply = render_units(units, level)
+        if not buying:
+            hasSell = (row.sellCr or units or level)
+        else:
+            hasSell = False
+        
+        age_days = next(it)
+        row.age = float(age_days or 0.0)
+        
+        if hasBuy or hasSell:
+            results.rows.append(row)
+    
+    if not results.rows:
+        raise CommandLineError("No items found")
+    
+    results.rows.sort(key=lambda row: row.item.dbname)
+    results.rows.sort(key=lambda row: row.item.category.dbname)
+    
+    return results
+
+#######################################################################
+## Transform result set into output
+
+
+def render(results, cmdenv, tdb):
+    longest = max(results.rows, key=lambda row: len(row.item.name()))
+    longestLen = len(longest.item.name())
+    longestDmd = max(results.rows, key=lambda row: len(row.demand)).demand
+    longestSup = max(results.rows, key=lambda row: len(row.supply)).supply
+    dmdLen = max(len(longestDmd), len("Demand"))
+    supLen = max(len(longestSup), len("Supply"))
+    
+    showCategories = (cmdenv.detail > 0)
+    
+    rowFmt = RowFormat()
+    if showCategories:
+        rowFmt.prefix = '    '
+    
+    sellPred = lambda row: row.sellCr != 0 and row.supply != '-'    # noqa: E731
+    buyPred = lambda row: row.buyCr != 0 and row.demand != '-'      # noqa: E731
+    
+    rowFmt.addColumn('Item', '<', longestLen,
+            key=lambda row: row.item.name())
+    if not cmdenv.selling:
+        rowFmt.addColumn('Buying', '>', 7, 'n',
+            key=lambda row: row.buyCr,
+            pred=buyPred)
+        if cmdenv.detail:
+            rowFmt.addColumn('Avg', '>', 7, 'n',
+            key=lambda row: row.avgBuy,
+            pred=buyPred)
+        if cmdenv.detail > 1:
+            rowFmt.addColumn('Demand', '>', dmdLen,
+                key=lambda row: row.demand,
+                pred=buyPred)
+    if not cmdenv.buying:
+        rowFmt.addColumn('Selling', '>', 7, 'n',
+            key=lambda row: row.sellCr,
+            pred=sellPred)
+        if cmdenv.detail:
+            rowFmt.addColumn('Avg', '>', 7, 'n',
+            key=lambda row: row.avgSell,
+            pred=sellPred)
+        rowFmt.addColumn('Supply', '>', supLen,
+            key=lambda row: row.supply,
+            pred=sellPred)
+    if cmdenv.detail:
+        rowFmt.addColumn('Age/Days', '>', 7, '.2f',
+        key=lambda row: row.age)
+    
+    if not cmdenv.quiet:
+        heading, underline = rowFmt.heading()
+        print(heading, underline, sep='\n')
+    
+    lastCat = None
+    for row in results.rows:
+        if showCategories and row.item.category is not lastCat:
+            print("+{}".format(row.item.category.name()))
+            lastCat = row.item.category
+        print(rowFmt.format(row))