tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/commands/sell_cmd.py

@@ -0,0 +1,262 @@
+from .commandenv import ResultRow
+from .exceptions import CommandLineError, NoDataError
+from .parsing import (
+    AvoidPlacesArgument, BlackMarketSwitch, FleetCarrierArgument,
+    MutuallyExclusiveGroup, NoPlanetSwitch, OdysseyArgument,
+    PadSizeArgument, ParseArgument, PlanetaryArgument,
+)
+from ..tradedb import TradeDB, System, Station
+from ..formatting import RowFormat
+from sqlalchemy import text
+
+
+######################################################################
+# Parser config
+
+help='Find places to sell a given item within range of a given station.'
+name='sell'
+epilog=None
+wantsTradeDB=True
+arguments = [
+    ParseArgument('item', help='Name of item you want to sell.', type=str),
+]
+switches = [
+    ParseArgument(
+        '--demand', '--quantity',
+        help='Limit to stations known to have at least this much demand.',
+        default=0,
+        type=int,
+    ),
+    ParseArgument('--near',
+            help='Find buyers within jump range of this system.',
+            type=str
+    ),
+    ParseArgument('--ly-per',
+            help='Maximum light years per jump.',
+            default=None,
+            dest='maxLyPer',
+            metavar='N.NN',
+            type=float,
+    ),
+    ParseArgument('--age', '--max-days-old', '-MD',
+        help = 'Maximum age (in days) of trade data to use.',
+        metavar = 'DAYS',
+        type = float,
+        dest = 'maxAge',
+    ),
+    AvoidPlacesArgument(),
+    PadSizeArgument(),
+    MutuallyExclusiveGroup(
+        NoPlanetSwitch(),
+        PlanetaryArgument(),
+    ),
+    FleetCarrierArgument(),
+    OdysseyArgument(),
+    BlackMarketSwitch(),
+    ParseArgument('--limit',
+            help='Maximum number of results to list.',
+            default=None,
+            type=int,
+    ),
+    ParseArgument('--price-sort', '-P',
+            help='(When using --near) Sort by price not distance',
+            action='store_true',
+            default=False,
+            dest='sortByPrice',
+    ),
+    ParseArgument('--gt',
+            help='Limit to prices above Ncr',
+            metavar='N',
+            dest='gt',
+            type="credits",
+    ),
+    ParseArgument('--lt',
+            help='Limit to prices below Ncr',
+            metavar='N',
+            dest='lt',
+            type="credits",
+    ),
+]
+
+######################################################################
+# Perform query and populate result set
+
+def run(results, cmdenv, tdb: TradeDB):
+    """
+    Backend-neutral implementation:
+      - Use SQLAlchemy text() with NAMED binds (':param') instead of '?'.
+      - Eagerly materialize rows via engine.connect().execute(...).fetchall()
+        to avoid closed-cursor errors when iterating later.
+      - Preserve all existing filters, sorting, and output fields.
+    """
+    
+    if cmdenv.lt and cmdenv.gt:
+        if cmdenv.lt <= cmdenv.gt:
+            raise CommandLineError("--gt must be lower than --lt")
+    
+    item = tdb.lookupItem(cmdenv.item)
+    cmdenv.DEBUG0("Looking up item {} (#{})", item.name(), item.ID)
+    
+    avoidSystems = {s for s in cmdenv.avoidPlaces if isinstance(s, System)}
+    avoidStations = {s for s in cmdenv.avoidPlaces if isinstance(s, Station)}
+    
+    results.summary = ResultRow()
+    results.summary.item = item
+    results.summary.avoidSystems = avoidSystems
+    results.summary.avoidStations = avoidStations
+    
+    # Detail: average demand price for this item (portable named bind)
+    if cmdenv.detail:
+        with tdb.engine.connect() as conn:
+            avg_val = conn.execute(
+                text("""
+                    SELECT AVG(si.demand_price)
+                      FROM StationItem AS si
+                     WHERE si.item_id = :item_id AND si.demand_price > 0
+                """),
+                {"item_id": item.ID},
+            ).scalar()
+        results.summary.avg = int(avg_val or 0)
+    
+    # Build the main query with named binds
+    columns = "si.station_id, si.demand_price, si.demand_units"
+    where = ["si.item_id = :item_id", "si.demand_price > 0"]
+    params = {"item_id": item.ID}
+    
+    if cmdenv.demand:
+        where.append("si.demand_units >= :demand")
+        params["demand"] = cmdenv.demand
+    if cmdenv.lt:
+        where.append("si.demand_price < :lt")
+        params["lt"] = cmdenv.lt
+    if cmdenv.gt:
+        where.append("si.demand_price > :gt")
+        params["gt"] = cmdenv.gt
+    
+    stmt = f"""
+        SELECT DISTINCT {columns}
+          FROM StationItem AS si
+         WHERE {' AND '.join(where)}
+    """
+    cmdenv.DEBUG0('SQL: {} ; params={}', stmt, params)
+    
+    # Execute and eagerly fetch rows
+    with tdb.engine.connect() as conn:
+        cur_rows = conn.execute(text(stmt), params).fetchall()
+    
+    stationByID = tdb.stationByID
+    padSize = cmdenv.padSize
+    planetary = cmdenv.planetary
+    fleet = cmdenv.fleet
+    odyssey = cmdenv.odyssey
+    wantNoPlanet = cmdenv.noPlanet
+    wantBlackMarket = cmdenv.blackMarket
+    
+    # System-based search
+    nearSystem = cmdenv.nearSystem
+    if nearSystem:
+        maxLy = cmdenv.maxLyPer or cmdenv.maxSystemLinkLy
+        results.summary.near = nearSystem
+        results.summary.ly = maxLy
+        distanceFn = nearSystem.distanceTo
+    else:
+        distanceFn = None
+    
+    for (stationID, priceCr, demand) in cur_rows:
+        station = stationByID[stationID]
+        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 wantNoPlanet and station.planetary != 'N':
+            continue
+        if wantBlackMarket and station.blackMarket != 'Y':
+            continue
+        if station in avoidStations:
+            continue
+        if station.system in avoidSystems:
+            continue
+        maxAge, stnAge = cmdenv.maxAge, station.dataAge or float("inf")
+        if maxAge and stnAge > maxAge:
+            continue
+        
+        row = ResultRow()
+        row.station = station
+        if distanceFn:
+            distance = distanceFn(row.station.system)
+            if distance > maxLy:
+                continue
+            row.dist = distance
+        row.price = priceCr
+        row.demand = demand
+        row.age = station.itemDataAgeStr
+        results.rows.append(row)
+    
+    if not results.rows:
+        raise NoDataError("No available items found")
+    
+    results.summary.sort = "Price"
+    results.rows.sort(key=lambda result: result.demand, reverse=True)
+    results.rows.sort(key=lambda result: result.price, reverse=True)
+    if nearSystem and not cmdenv.sortByPrice:
+        results.summary.sort = "Dist"
+        results.rows.sort(key=lambda result: result.dist)
+    
+    limit = cmdenv.limit or 0
+    if limit > 0:
+        results.rows = results.rows[:limit]
+    
+    return results
+
+
+#######################################################################
+## Transform result set into output
+
+def render(results, cmdenv, tdb):
+    longestNamed = max(results.rows, key=lambda result: len(result.station.name()))
+    longestNameLen = len(longestNamed.station.name())
+    
+    stnRowFmt = RowFormat()
+    stnRowFmt.addColumn('Station', '<', longestNameLen,
+            key=lambda row: row.station.name())
+    stnRowFmt.addColumn('Cost', '>', 10, 'n',
+            key=lambda row: row.price)
+    if cmdenv.detail:
+        stnRowFmt.addColumn('Demand', '>', 10,
+                key=lambda row: '{:n}'.format(row.demand) if row.demand >= 0 else '?')
+    if cmdenv.nearSystem:
+        stnRowFmt.addColumn('DistLy', '>', 6, '.2f',
+                key=lambda row: row.dist)
+    
+    stnRowFmt.addColumn('Age/days', '>', 7,
+            key=lambda row: row.age)
+    stnRowFmt.addColumn('StnLs', '>', 10,
+                key=lambda row: row.station.distFromStar())
+    stnRowFmt.addColumn('B/mkt', '>', 4,
+            key=lambda row: TradeDB.marketStates[row.station.blackMarket])
+    stnRowFmt.addColumn("Pad", '>', '3',
+            key=lambda row: TradeDB.padSizes[row.station.maxPadSize])
+    stnRowFmt.addColumn("Plt", '>', '3',
+            key=lambda row: TradeDB.planetStates[row.station.planetary])
+    stnRowFmt.addColumn("Flc", '>', '3',
+            key=lambda row: TradeDB.fleetStates[row.station.fleet])
+    stnRowFmt.addColumn("Ody", '>', '3',
+            key=lambda row: TradeDB.odysseyStates[row.station.odyssey])
+    
+    if not cmdenv.quiet:
+        heading, underline = stnRowFmt.heading()
+        print(heading, underline, sep='\n')
+    
+    for row in results.rows:
+        print(stnRowFmt.format(row))
+    
+    if cmdenv.detail:
+        print("{:{lnl}} {:>10n}".format(
+                "-- Average",
+                results.summary.avg,
+                lnl=longestNameLen,
+        ))

tradedangerous/commands/shipvendor_cmd.py

@@ -0,0 +1,60 @@
+# tradedangerous/commands/shipvendor_cmd.py — DEPRECATED (no-op)
+# This command no longer maintains ship lists directly.
+# Guidance:
+#   • Import authoritative data via:   trade import -P spansh  |  trade import -P eddblink
+#   • Search for ships via:            trade buy --near "<place>" --ly N "<ship>"
+
+from __future__ import annotations
+from .parsing import ParseArgument  # to swallow arbitrary positional args
+
+# ---- Command metadata ----
+help = "DEPRECATED: no longer used. See deprecation banner when run."
+name = "shipvendor"
+epilog = None
+acceptUnknown = True
+
+# No DB access needed.
+wantsTradeDB = False
+usesTradeData = False
+
+# Accept ANY number of positional args and ignore them (prevents parser errors).
+arguments = (
+    ParseArgument(
+        'args',
+        help="(deprecated) ignored",
+        nargs='*',
+        type=str,
+    ),
+)
+# No switches; unknown switches will still be rejected by the global parser.
+switches = (
+)
+
+
+def _banner() -> str:
+    return (
+        "\n"
+        "=== DEPRECATION NOTICE: shipvendor ==================================\n"
+        "This command is no longer used and does not modify the database.\n"
+        "• Import authoritative data with:  trade import -P eddblink | -P spansh\n"
+        "• Search for ships using:         trade buy --near \"<place>\" --ly N \"<ship>\"\n"
+        "======================================================================\n"
+    )
+
+
+def run(results, cmdenv, tdb=None):
+    """
+    No-op implementation: print banner and exit immediately.
+    All arguments/switches are ignored by design.
+    """
+    banner = _banner()
+    try:
+        cmdenv.NOTE("{}", banner)
+    except Exception:
+        print(banner)
+    return False  # Nothing to render
+
+
+def render(results, cmdenv, tdb=None):
+    # No output beyond the banner emitted in run().
+    return False  # command is done

tradedangerous/commands/station_cmd.py

@@ -0,0 +1,68 @@
+# tradedangerous/commands/station_cmd.py — DEPRECATED (no-op)
+# This command no longer edits station records directly.
+#
+# How to maintain station data going forward:
+#   • Import authoritative data via:   trade import -P spansh  |  trade import -P eddblink
+#   • Solo/offline players (manual capture via EDMC plugin):
+#       TradeDangerous DB-Update for EDMC → https://github.com/bgol/UpdateTD
+#
+# To inspect a station’s data, use read-only commands like:
+#   trade station <name>         ← (legacy pattern; now deprecated)
+#   trade local --near "<system>"   (discoverability)
+#   trade market --origin "<station>" (market view)
+
+from __future__ import annotations
+from .parsing import ParseArgument
+
+# ---- Command metadata ----
+help = "DEPRECATED: no longer used. See deprecation banner when run."
+name = "station"
+epilog = None
+acceptUnknown = True
+
+# No DB access is needed for this no-op command.
+wantsTradeDB = False
+usesTradeData = False
+
+# Accept ANY number of positional args and ignore them (prevents parser errors).
+arguments = (
+    ParseArgument(
+        'args',
+        help="(deprecated) ignored",
+        nargs='*',
+        type=str,
+    ),
+)
+# No switches; unknown switches will still be rejected by the global parser.
+switches = (
+)
+
+
+def _banner() -> str:
+    return (
+        "\n"
+        "=== DEPRECATION NOTICE: station ====================================\n"
+        "This command no longer edits station records and does not modify the DB.\n"
+        "• Import station data via:    trade import -P eddblink | -P spansh\n"
+        "• Solo/offline capture via EDMC plugin:\n"
+        "    TradeDangerous DB-Update → https://github.com/bgol/UpdateTD\n"
+        "=====================================================================\n"
+    )
+
+
+def run(results, cmdenv, tdb=None):
+    """
+    No-op implementation: print banner and exit immediately.
+    All arguments/switches are ignored by design.
+    """
+    banner = _banner()
+    try:
+        cmdenv.NOTE("{}", banner)
+    except Exception:
+        print(banner)
+    return False  # Nothing to render
+
+
+def render(results, cmdenv, tdb=None):
+    # No output beyond the banner emitted in run().
+    return

tradedangerous/commands/trade_cmd.py

@@ -0,0 +1,181 @@
+# tradedangerous/commands/trade_cmd.py
+import datetime
+
+from .commandenv import ResultRow
+from .exceptions import CommandLineError
+from .parsing import ParseArgument
+from tradedangerous import TradeORM
+from tradedangerous.db import orm_models as models
+from tradedangerous.formatting import RowFormat, max_len
+
+from sqlalchemy import select
+from sqlalchemy.orm import aliased
+
+
+######################################################################
+# Parser config
+
+help='Find potential trades between two given stations.'
+name='trade'
+epilog=None
+wantsTradeDB=False
+arguments = [
+    ParseArgument(
+        'origin',
+        help='Station you are purchasing from.',
+        type=str,
+    ),
+    ParseArgument(
+        'dest',
+        help='Station you are selling to.',
+        type=str,
+    ),
+]
+switches = [
+    ParseArgument('--gain-per-ton', '--gpt',
+        help = 'Specify the minimum gain per ton of cargo',
+        dest = 'minGainPerTon',
+        type = "credits",
+        default = 1,
+    ),
+    ParseArgument('--limit', '-n',
+        help = 'Limit output to the top N results',
+        dest = 'limit',
+        type = int,
+        default = 0,
+    ),
+]
+
+
+def age(now: datetime, modified: datetime) -> float:
+    """ Return age in hours between now and modified timestamp. """
+    delta = (now - modified).total_seconds() / 60.0
+    if delta < 90:
+        return f"{delta:.1f}M"
+    delta /= 60.0
+    if delta < 25:
+        return f"{delta:.1f}H"
+    delta /= 7.0
+    if delta < 7:
+        return f"{delta:.1f}D"
+    return f"{int(delta):n}D"
+
+
+######################################################################
+# Perform query and populate result set
+
+def run(results, cmdenv, tdb):
+    # IMPORTANT: resolve stations BEFORE constructing TradeCalc
+    tdb = TradeORM(tdenv=cmdenv)
+    
+    lhs = tdb.lookup_station(cmdenv.origin)
+    if not lhs:
+        raise CommandLineError(f"Unknown origin station: {cmdenv.origin}")
+    cmdenv.DEBUG0("from id: system={}, station={}", lhs.system_id, lhs.station_id)
+    rhs = tdb.lookup_station(cmdenv.dest)
+    if not rhs:
+        raise CommandLineError(f"Unknown destination station: {cmdenv.dest}")
+    cmdenv.DEBUG0("to id..: system={}, station={}", rhs.system_id, rhs.station_id)
+    
+    if lhs == rhs:
+        raise CommandLineError("Must specify two different stations.")
+    
+    seller = aliased(models.StationItem, name="seller")
+    buyer = aliased(models.StationItem, name="buyer")
+    stmt = (
+        select(
+            models.Item,
+            seller.supply_price, seller.supply_units, seller.supply_level,
+            buyer.demand_price, buyer.demand_units, buyer.demand_level,
+            seller.modified, buyer.modified,
+        )
+        .where(
+            seller.station_id == lhs.station_id,
+            buyer.station_id == rhs.station_id,
+            seller.item_id == buyer.item_id,
+            seller.supply_price > 0,
+            buyer.demand_price > 0,                 # (optional extra guard)
+            buyer.demand_price >= seller.supply_price,
+            seller.item_id == models.Item.item_id,
+        )
+        .order_by((buyer.demand_price - seller.supply_price).desc())
+    )
+    compiled = stmt.compile(
+        dialect=tdb.session.bind.dialect,
+        compile_kwargs={"literal_binds": True}
+    )
+    cmdenv.DEBUG1("query: {}", compiled)
+    trades = tdb.session.execute(stmt).unique().all()
+    cmdenv.DEBUG0("Raw result count: {}", len(trades))
+    if not trades:
+        raise CommandLineError(f"No profitable trades {lhs.name} -> {rhs.name}")
+    
+    results.summary = ResultRow(color=cmdenv.color)
+    results.summary.fromStation = lhs
+    results.summary.toStation = rhs
+    
+    now = datetime.datetime.now(tz=datetime.timezone.utc)
+    
+    if cmdenv.limit > 0:
+        trades = trades[:cmdenv.limit]
+    
+    for item, sup_price, sup_units, sup_level, dem_price, dem_units, dem_level, sup_age, dem_age in trades:
+        gain = dem_price - sup_price
+        if gain < cmdenv.minGainPerTon:
+            continue
+        results.rows.append({
+            "item": item.dbname(cmdenv.detail),
+            "sup_price": sup_price,
+            "sup_units": sup_units,
+            "sup_level": sup_level,
+            "dem_price": dem_price,
+            "dem_units": dem_units,
+            "dem_level": dem_level,
+            "sup_age": age(now, sup_age),
+            "dem_age": age(now, dem_age),
+            "gain": gain,
+        })
+    
+    return results
+
+#######################################################################
+## Transform result set into output
+
+def render(results, cmdenv, tdb):
+    longestNameLen = max_len(results.rows, key=lambda row: row["item"])
+    
+    rowFmt = RowFormat()
+    rowFmt.addColumn('Item', '<', longestNameLen,
+            key=lambda row: row["item"])
+    rowFmt.addColumn('Profit', '>', 10, 'n',
+            key=lambda row: row["gain"])
+    rowFmt.addColumn('Cost', '>', 10, 'n',
+            key=lambda row: row["sup_price"])
+    # if cmdenv.detail > 1:
+    #     rowFmt.addColumn('AvgCost', '>', 10,
+    #         key=lambda row: tdb.avgSelling.get(row.item.ID, 0)
+    #     )
+    rowFmt.addColumn('Buying', '>', 10, 'n',
+            key=lambda row: row["dem_price"])
+    # rowFmt.addColumn('AvgBuy', '>', 10,
+    #     key=lambda row: tdb.avgBuying.get(row.item.ID, 0)
+    # )
+    
+    if cmdenv.detail > 1:
+        rowFmt.addColumn('Supply', '>', 10,
+            key=lambda row: f'{row["sup_units"]:n}' if row["sup_units"] >= 0 else '?')
+        rowFmt.addColumn('Demand', '>', 10,
+            key=lambda row: f'{row["dem_units"]:n}' if row["dem_units"] >= 0 else '?')
+    if cmdenv.detail:
+        rowFmt.addColumn('SrcAge', '>', 9, 's',
+            key=lambda row: row["sup_age"])
+        rowFmt.addColumn('DstAge', '>', 9, 's',
+            key=lambda row: row["dem_age"])
+    
+    if not cmdenv.quiet:
+        print(f"{len(results.rows)} trades found between {results.summary.fromStation.dbname()} and {results.summary.toStation.dbname()}.")
+        heading, underline = rowFmt.heading()
+        print(heading, underline, sep='\n')
+    
+    for row in results.rows:
+        print(rowFmt.format(row))

tradedangerous/commands/update_cmd.py

@@ -0,0 +1,67 @@
+# tradedangerous/commands/update_cmd.py — DEPRECATED (no-op)
+# This command no longer edits station price lists directly.
+#
+# How to maintain price/station data going forward:
+#   • Import authoritative data via:   trade import -P spansh  |  trade import -P eddblink
+#   • Solo/offline players (manual capture via EDMC plugin):
+#       TradeDangerous DB-Update for EDMC → https://github.com/bgol/UpdateTD
+#
+# This module accepts and ignores any arguments/switches and exits immediately.
+
+from __future__ import annotations
+from .parsing import ParseArgument
+
+# ---- Command metadata ----
+help = "DEPRECATED: no longer used. See deprecation banner when run."
+name = "update"
+epilog = None
+
+# Swallow unknown switches/args (loader must honor this flag).
+acceptUnknown = True
+
+# No DB access is needed for this no-op command.
+wantsTradeDB = False
+usesTradeData = False
+
+# Accept ANY number of positional args and ignore them (prevents parser errors).
+arguments = (
+    ParseArgument(
+        "args",
+        help="(deprecated) ignored",
+        nargs="*",
+        type=str,
+    ),
+)
+# No switches; unknown switches will be ignored via acceptUnknown.
+switches = (
+)
+
+
+def _banner() -> str:
+    return (
+        "\n"
+        "=== DEPRECATION NOTICE: update =====================================\n"
+        "This command no longer edits station price lists and does not modify the DB.\n"
+        "• Import data via:               trade import -P eddblink | -P spansh\n"
+        "• Solo/offline capture via EDMC: TradeDangerous DB-Update → https://github.com/bgol/UpdateTD\n"
+        "=====================================================================\n"
+    )
+
+
+def run(results, cmdenv, tdb=None):
+    """
+    No-op implementation: print banner and exit immediately.
+    All arguments/switches are ignored by design.
+    """
+    banner = _banner()
+    try:
+        cmdenv.NOTE("{}", banner)
+    except Exception:
+        print(banner)
+    
+    return False  # all done
+
+
+def render(results, cmdenv, tdb=None):
+    # No output beyond the banner emitted in run().
+    return False  # all done

tradedangerous/corrections.py

@@ -0,0 +1,55 @@
+# Provides an interface for correcting names that
+# have changed in recent versions.
+
+# Arbitrary, negative value to denote something that's been removed.
+DELETED = -111
+
+systems = {
+    "PANDAMONIUM": "PANDEMONIUM",
+    "ARGETLÁMH": "ARGETLAMH",
+    "LíFTHRUTI": "LIFTHRUTI",
+    "MANTóAC": "MANTOAC",
+    "NANTóAC": "NANTOAC",
+}
+
+stations = {
+}
+
+categories = {
+}
+
+items = {
+    'POWER TRANSFER CONDUITS': 'Power Transfer Bus',
+    'LOW TEMPERATURE DIAMOND': 'Low Temperature Diamonds',
+    'COOLING HOSES': 'Micro-weave Cooling Hoses',
+    'METHANOL MONOHYDRATE': 'Methanol Monohydrate Crystals',
+    'OCCUPIED CRYOPOD': 'Occupied Escape Pod',
+    'SALVAGEABLE WRECKAGE': 'Wreckage Components',
+    'POLITICAL PRISONER': 'Political Prisoners',
+    'HOSTAGE': 'Hostages',
+    "VOID OPALS": "Void Opal",
+}
+
+def correctSystem(oldName):
+    try:
+        return systems[oldName.upper()]
+    except KeyError:
+        return oldName
+
+def correctStation(systemName, oldName):
+    try:
+        return stations[systemName.upper() + "/" + oldName.upper()]
+    except KeyError:
+        return oldName
+
+def correctCategory(oldName):
+    try:
+        return categories[oldName.upper()]
+    except KeyError:
+        return oldName
+
+def correctItem(oldName):
+    try:
+        return items[oldName.upper()]
+    except KeyError:
+        return oldName