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

tradedangerous/commands/sell_cmd.py

@@ -7,6 +7,7 @@ from .parsing import (
 )
 from ..tradedb import TradeDB, System, Station
 from ..formatting import RowFormat
+from sqlalchemy import text
 
 
 ######################################################################
@@ -81,6 +82,14 @@ switches = [
 # 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")
@@ -96,37 +105,54 @@ def run(results, cmdenv, tdb: TradeDB):
     results.summary.avoidSystems = avoidSystems
     results.summary.avoidStations = avoidStations
     
+    # Detail: average demand price for this item (portable named bind)
     if cmdenv.detail:
-        avgPrice = tdb.query("""
-            SELECT AVG(si.demand_price)
-              FROM StationItem AS si
-             WHERE si.item_id = ? AND si.demand_price > 0
-        """, [item.ID]).fetchone()[0]
-        results.summary.avg = int(avgPrice)
-    
-    # Constraints
-    tables = "StationItem AS si"
-    constraints = [
-        "(item_id = {} AND demand_price > 0)".format(item.ID),
-    ]
-    columns = [
-        'si.station_id',
-        'si.demand_price',
-        'si.demand_units',
-    ]
-    bindValues = []
+        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:
-        constraints.append("(demand_units >= ?)")
-        bindValues.append(cmdenv.demand)
-    
+        where.append("si.demand_units >= :demand")
+        params["demand"] = cmdenv.demand
     if cmdenv.lt:
-        constraints.append("(demand_price < ?)")
-        bindValues.append(cmdenv.lt)
+        where.append("si.demand_price < :lt")
+        params["lt"] = cmdenv.lt
     if cmdenv.gt:
-        constraints.append("(demand_price > ?)")
-        bindValues.append(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 tdb.maxSystemLinkLy
@@ -136,24 +162,7 @@ def run(results, cmdenv, tdb: TradeDB):
     else:
         distanceFn = None
     
-    whereClause = ' AND '.join(constraints)
-    stmt = """SELECT DISTINCT {columns} FROM {tables} WHERE {where}""".format(
-        columns=','.join(columns),
-        tables=tables,
-        where=whereClause
-    )
-    cmdenv.DEBUG0('SQL: {}', stmt)
-    cur = tdb.query(stmt, bindValues)
-    
-    stationByID = tdb.stationByID
-    padSize = cmdenv.padSize
-    planetary = cmdenv.planetary
-    fleet = cmdenv.fleet
-    odyssey = cmdenv.odyssey
-    wantNoPlanet = cmdenv.noPlanet
-    wantBlackMarket = cmdenv.blackMarket
-    
-    for (stationID, priceCr, demand) in cur:
+    for (stationID, priceCr, demand) in cur_rows:
         station = stationByID[stationID]
         if padSize and not station.checkPadSize(padSize):
             continue
@@ -187,8 +196,6 @@ def run(results, cmdenv, tdb: TradeDB):
         row.age = station.itemDataAgeStr
         results.rows.append(row)
     
-    cur.close()
-    
     if not results.rows:
         raise NoDataError("No available items found")
     

tradedangerous/commands/shipvendor_cmd.py

@@ -1,244 +1,59 @@
-# Deprecated
-# Can already use buy command for ship searching
-from .commandenv import ResultRow
-from .exceptions import CommandLineError
-from .parsing import MutuallyExclusiveGroup, ParseArgument
-from ..formatting import RowFormat, ColumnFormat, max_len
-from itertools import chain
-from ..tradedb import Station
-
-# Original by Dirk Wilhelm
-
-from .. import csvexport
+# 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
 
-######################################################################
-# Parser config
+# No DB access needed.
+wantsTradeDB = False
+usesTradeData = False
 
-help = 'List, add or update available ships to a station'
-name = 'shipvendor'
-epilog = None
-arguments = [
+# Accept ANY number of positional args and ignore them (prevents parser errors).
+arguments = (
     ParseArgument(
-        'origin',
-        help = 'Specify the full name of the station '
-            '(SYS NAME/STN NAME is also supported).',
-        metavar = 'STATIONNAME',
-        type = str,
-    ),
-    ParseArgument(
-        'ship',
-        help = 'Comma or space separated list of ship names.',
-        type = str,
-        nargs = '*',
-    ),
-]
-switches = [
-    MutuallyExclusiveGroup(
-        ParseArgument(
-            '--remove', '-rm',
-            help = 'Indicates you want to remove an entry.',
-            action = 'store_true',
-        ),
-        ParseArgument(
-            '--add', '-a',
-            help = 'Indicates you want to add a new station.',
-            action = 'store_true',
-        ),
-        ParseArgument(
-            '--name-sort',
-            help = 'Sort listed ships by name.',
-            action = 'store_true',
-            dest = 'nameSort',
-        ),
+        'args',
+        help="(deprecated) ignored",
+        nargs='*',
+        type=str,
     ),
-    ParseArgument(
-        '--no-export',
-        help = 'Do not update the .csv files.',
-        action = 'store_true',
-        dest = 'noExport',
-    ),
-]
-
-######################################################################
-# Helpers
-
-
-def addShipVendor(tdb, cmdenv, station, ship):
-    db = tdb.getDB()
-    db.execute("""
-                INSERT INTO ShipVendor (
-                    ship_id, station_id
-                ) VALUES (
-                    ?, ?
-                )
-        """, [
-                ship.ID, station.ID
-        ])
-    db.commit()
-    cmdenv.NOTE("At {} adding {}", station.name(), ship.name())
-    return ship
-
-
-def removeShipVendor(tdb, cmdenv, station, ship):
-    db = tdb.getDB()
-    db.execute("""
-            DELETE FROM ShipVendor WHERE ship_id = ? and station_id = ?
-    """, [ship.ID, station.ID])
-    db.commit()
-    cmdenv.NOTE("At {} removing {}", station.name(), ship.name())
-    return ship
-
-
-def maybeExportToCSV(tdb, cmdenv):
-    if cmdenv.noExport:
-        cmdenv.DEBUG0("no-export set, not exporting stations")
-        return
-    
-    lines, csvPath = csvexport.exportTableToFile(tdb, cmdenv, "ShipVendor")
-    cmdenv.NOTE("{} updated.", csvPath)
-
-
-def checkShipPresent(tdb, station, ship):
-    # Ask the database how many rows it sees claiming
-    # this ship is sold at that station. The value will
-    # be zero if we don't have an entry, otherwise it
-    # will be some positive number.
-    cur = tdb.query("""
-        SELECT  COUNT(*)
-          FROM  ShipVendor
-         WHERE  ship_id = ? AND station_id = ?
-    """, [ship.ID, station.ID]
-    )
-    # Get the first result of the row and get the first column of that row
-    count = int(cur.fetchone()[0])
-    
-    # Test if count > 0, if so, we'll return True, otherwise False
-    return (count > 0)
-
-
-def listShipsPresent(tdb, cmdenv, station, results):
-    """ Populate results with a list of ships present at the given station """
-    cur = tdb.query("""
-        SELECT ship_id
-          FROM ShipVendor
-         WHERE station_id = ?
-    """, [station.ID]
+)
+# No switches; unknown switches will still be rejected by the global parser.
+switches = tuple()
+
+
+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"
     )
-    
-    results.summary = ResultRow()
-    results.summary.station = station
-    ships = tdb.shipByID
-    addShip = results.rows.append
-    
-    for (ship_id,) in cur:
-        ship = ships.get(ship_id, None)
-        if ship:
-            addShip(ResultRow(ship = ship))
-    
-    if cmdenv.nameSort:
-        results.rows.sort(key = lambda row: row.ship.name())
-    else:
-        results.rows.sort(key = lambda row: row.ship.cost, reverse = True)
-    
-    return results
-
-######################################################################
-# Perform query and populate result set
 
 
-def run(results, cmdenv, tdb):
-    station = cmdenv.startStation
-    if not isinstance(station, Station):
-        raise CommandLineError(
-            "{} is a system, not a station"
-            .format(station.name())
-        )
-    if station.shipyard == 'N' and not cmdenv.remove:
-        raise CommandLineError(
-            "{} is flagged as having no shipyard."
-            .format(station.name())
-        )
-    
-    if cmdenv.add:
-        action = addShipVendor
-    elif cmdenv.remove:
-        action = removeShipVendor
-    else:
-        return listShipsPresent(tdb, cmdenv, station, results)
-    
-    if not cmdenv.ship:
-        raise CommandLineError(
-            "No ship names specified."
-        )
-    
-    cmdenv.NOTE("Using local database ({})", tdb.dbPath)
-    ships = {}
-    shipNames = chain.from_iterable(
-        name.split(",") for name in cmdenv.ship
-    )
-    for shipName in shipNames:
-        try:
-            ship = tdb.lookupShip(shipName)
-        except LookupError:
-            raise CommandLineError("Unrecognized Ship: {}".format(shipName))
-        
-        # Lets see if that ship sails from the specified port.
-        shipPresent = checkShipPresent(tdb, station, ship)
-        if cmdenv.add:
-            if shipPresent:
-                cmdenv.DEBUG0("{} is already listed at {}",
-                    ship.name(), station.name()
-                )
-            else:
-                ships[ship.ID] = ship
-        else:
-            if not shipPresent:
-                cmdenv.DEBUG0("{} is not listed at {}",
-                    ship.name(), station.name()
-                )
-            else:
-                ships[ship.ID] = ship
-    
-    if len(ships) == 0:
-        cmdenv.NOTE("Nothing to do.")
-        return None
-    
-    # We've checked that everything should be good.
-    dataToExport = False
-    for ship in ships.values():
-        if action(tdb, cmdenv, station, ship):
-            dataToExport = True
-    
-    cmdenv.DEBUG0("dataToExport = {}", dataToExport)
-    
-    maybeExportToCSV(tdb, cmdenv)
-    
+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 None
 
-######################################################################
-# Transform result set into output
-
 
-def render(results, cmdenv, tdb):
-    if not results or not results.rows:
-        raise CommandLineError(
-            "No ships available at {}"
-            .format(results.summary.station.name())
-        )
-    
-    maxShipLen = max_len(results.rows, key = lambda row: row.ship.name())
-    
-    rowFmt = RowFormat().append(
-        ColumnFormat("Ship", '<', maxShipLen,
-            key = lambda row: row.ship.name())
-    ).append(
-        ColumnFormat("Cost", '>', 12, 'n',
-            key = lambda row: row.ship.cost)
-    )
-    
-    if not cmdenv.quiet:
-        heading, underline = rowFmt.heading()
-        print(heading, underline, sep = '\n')
-    
-    for row in results.rows:
-        print(rowFmt.format(row))
+def render(results, cmdenv, tdb=None):
+    # No output beyond the banner emitted in run().
+    return