tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/commands/nav_cmd.py

@@ -0,0 +1,252 @@
+from .commandenv import ResultRow
+from .parsing import (
+    AvoidPlacesArgument, FleetCarrierArgument, MutuallyExclusiveGroup,
+    NoPlanetSwitch, OdysseyArgument, PadSizeArgument, ParseArgument,
+    PlanetaryArgument,
+)
+
+from tradedangerous import TradeDB, TradeException
+from tradedangerous.tradedb import Station, System
+from tradedangerous.formatting import RowFormat, ColumnFormat
+
+
+######################################################################
+# Parser config
+
+help='Calculate a route between two systems.'
+name='nav'
+epilog=None
+wantsTradeDB=True
+arguments = [
+    ParseArgument('starting', help='System to start from', type=str),
+    ParseArgument('ending', help='System to end at', type=str),
+]
+switches = [
+    ParseArgument('--ly-per',
+        help='Maximum light years per jump.',
+        dest='maxLyPer',
+        metavar='N.NN',
+        type=float,
+    ),
+    AvoidPlacesArgument(),
+    ParseArgument('--via',
+        help='Require specified systems/stations to be en-route (in order).',
+        action='append',
+        metavar='PLACE[,PLACE,...]',
+    ),
+    ParseArgument('--stations', '-S',
+        help='Include station details.',
+        action='store_true',
+    ),
+    ParseArgument('--refuel-jumps',
+        help='Require a station after this many jumps',
+        type=int,
+        dest='stationInterval',
+    ),
+    PadSizeArgument(),
+    MutuallyExclusiveGroup(
+        NoPlanetSwitch(),
+        PlanetaryArgument(),
+    ),
+    FleetCarrierArgument(),
+    OdysseyArgument(),
+]
+
+######################################################################
+# Helpers
+
+
+class NoRouteError(TradeException):
+    """ Exception denoting specifically a route could not be found. """
+
+
+######################################################################
+# Perform query and populate result set
+
+def run(results, cmdenv, tdb):
+    srcSystem, dstSystem = cmdenv.origPlace, cmdenv.destPlace
+    if isinstance(srcSystem, Station):
+        srcSystem = srcSystem.system
+    if isinstance(dstSystem, Station):
+        dstSystem = dstSystem.system
+    
+    maxLyPer = cmdenv.maxLyPer or cmdenv.maxSystemLinkLy
+    
+    cmdenv.DEBUG0("Route from {} to {} with max {}ly per jump.",
+                    srcSystem.name(), dstSystem.name(), maxLyPer)
+    
+    # Build a list of src->dst pairs
+    hops = [ [ srcSystem, None ] ]
+    if cmdenv.viaPlaces:
+        for hop in cmdenv.viaPlaces:
+            hops[-1][1] = hop
+            hops.append([hop, None])
+    hops[-1][1] = dstSystem
+    
+    avoiding = [
+        avoid for avoid in cmdenv.avoidPlaces
+        if isinstance(avoid, System)
+    ]
+    
+    route = [ ]
+    stationInterval = cmdenv.stationInterval
+    for hop in hops:
+        try:
+            hopRoute = list(tdb.getRoute(
+                hop[0], hop[1],
+                maxLyPer,
+                avoiding,
+                stationInterval=stationInterval,
+                ))
+        except TypeError:
+            raise NoRouteError(
+                    "No route found between {} and {} "
+                    "with a max {}ly/jump limit.".format(
+                        hop[0].name(), hop[1].name(),
+                        maxLyPer,
+            ))
+        route = route[:-1] + hopRoute
+    
+    results.summary = ResultRow(
+                fromSys=srcSystem,
+                toSys=dstSystem,
+                maxLy=maxLyPer,
+            )
+    
+    lastSys, totalLy, dirLy = srcSystem, 0.00, 0.00
+    maxPadSize = cmdenv.padSize
+    planetary = cmdenv.planetary
+    fleet = cmdenv.fleet
+    odyssey = cmdenv.odyssey
+    noPlanet = cmdenv.noPlanet
+    
+    for (jumpSys, dist) in route:
+        jumpLy = lastSys.distanceTo(jumpSys)
+        totalLy += jumpLy
+        if cmdenv.detail:
+            dirLy = jumpSys.distanceTo(dstSystem)
+        row = ResultRow(
+            action='Via',
+            system=jumpSys,
+            jumpLy=jumpLy,
+            totalLy=totalLy,
+            dirLy=dirLy,
+            )
+        row.stations = []
+        if cmdenv.stations:
+            for (station) in jumpSys.stations:
+                if maxPadSize and not station.checkPadSize(maxPadSize):
+                    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 noPlanet and station.planetary != 'N':
+                    continue
+                rr = ResultRow(
+                    station=station,
+                    age=station.itemDataAgeStr,
+                )
+                row.stations.append(rr)
+        results.rows.append(row)
+        lastSys = jumpSys
+    results.rows[0].action='Depart'
+    results.rows[-1].action='Arrive'
+    
+    return results
+
+######################################################################
+# Transform result set into output
+
+def render(results, cmdenv, tdb):
+    if cmdenv.quiet > 1:
+        print(','.join(row.system.name() for row in results.rows))
+        return False
+    
+    longestNamed = max(results.rows,
+                    key=lambda row: len(row.system.name()))
+    longestNameLen = len(longestNamed.system.name())
+    
+    rowFmt = RowFormat()
+    if cmdenv.detail:
+        rowFmt.addColumn("Action", '<', 6, post=":", key=lambda row: row.action)
+    rowFmt.addColumn("System", '<', longestNameLen,
+            key=lambda row: row.system.name())
+    rowFmt.addColumn("JumpLy", '>', '7', '.2f',
+            key=lambda row: row.jumpLy)
+    if cmdenv.detail:
+        rowFmt.addColumn("Stations", '>', 2,
+            key=lambda row: len(row.system.stations))
+    if cmdenv.detail:
+        rowFmt.addColumn("DistLy", '>', '7', '.2f',
+            key=lambda row: row.totalLy)
+    if cmdenv.detail > 1:
+        rowFmt.addColumn("DirLy", '>', 7, '.2f',
+            key=lambda row: row.dirLy)
+    
+    showStations = cmdenv.stations
+    if showStations:
+        stnRowFmt = RowFormat(prefix='  /  ').append(
+                ColumnFormat("Station", '<', 38,
+                    key=lambda row: row.station.dbname)
+        ).append(
+                ColumnFormat("StnLs", '>', '10',
+                    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)
+            )
+    
+    if not cmdenv.quiet:
+        heading, underline = rowFmt.heading()
+        if showStations:
+            print(heading)
+            heading, underline = stnRowFmt.heading()
+        print(heading, underline, sep='\n')
+    
+    for row in results.rows:
+        print(rowFmt.format(row))
+        for stnRow in row.stations:
+            print(stnRowFmt.format(stnRow))
+    
+    return results

tradedangerous/commands/olddata_cmd.py

@@ -0,0 +1,270 @@
+from .parsing import (
+    FleetCarrierArgument, MutuallyExclusiveGroup, NoPlanetSwitch,
+    OdysseyArgument, ParseArgument, PadSizeArgument, PlanetaryArgument,
+)
+from ..tradedb import TradeDB
+from ..tradeexcept import TradeException
+from sqlalchemy import select, table, column, func, literal
+from sqlalchemy.orm import Session
+
+
+######################################################################
+# Parser config
+
+name='olddata'
+help='Show oldest data in database.'
+epilog=None
+wantsTradeDB=True
+arguments = [
+]
+switches = [
+    ParseArgument('--limit',
+            help='Maximum number of results to show',
+            default=20,
+            type=int,
+    ),
+    ParseArgument('--near',
+            help='Find sellers within jump range of this system.',
+            type=str
+    ),
+    ParseArgument('--ly',
+            help='[Requires --near] Systems within this range of --near.',
+            default=None,
+            dest='maxLyPer',
+            metavar='N.NN',
+            type=float,
+    ),
+    ParseArgument('--route',
+            help='Sort to shortest path',
+            action='store_true',
+    ),
+    ParseArgument('--min-age',
+            help='List data older than this number of days.',
+            type=float,
+            dest='minAge',
+    ),
+    PadSizeArgument(),
+    MutuallyExclusiveGroup(
+        NoPlanetSwitch(),
+        PlanetaryArgument(),
+    ),
+    FleetCarrierArgument(),
+    OdysseyArgument(),
+    ParseArgument('--ls-max',
+        help='Only consider stations upto this many ls from their star.',
+        metavar='LS',
+        dest='maxLs',
+        type=int,
+        default=0,
+    ),
+]
+
+######################################################################
+# Perform query and populate result set
+
+def run(results, cmdenv, tdb):
+    """
+    Backend-neutral rework:
+      - Use SQLAlchemy Core to compute age and (optionally) distance².
+      - age: age_in_days(session, MAX(StationItem.modified)) AS age_days
+      - dist2: (sys.pos_x - x0)^2 + (sys.pos_y - y0)^2 + (sys.pos_z - z0)^2 (when --near)
+      - Materialize rows to avoid closed-cursor errors.
+      - Preserve downstream filters/sorting/limit exactly as before.
+    """
+    from .commandenv import ResultRow
+    from tradedangerous.db.utils import age_in_days
+    
+    cmdenv = results.cmdenv
+    tdb = cmdenv.tdb
+    
+    results.summary = ResultRow()
+    results.limit = cmdenv.limit
+    
+    # SQLAlchemy lightweight table defs
+    si = table(
+        "StationItem",
+        column("station_id"),
+        column("item_id"),
+        column("modified"),
+    )
+    stn = table(
+        "Station",
+        column("station_id"),
+        column("system_id"),
+        column("ls_from_star"),
+    )
+    sys_tbl = table(
+        "System",
+        column("system_id"),
+        column("pos_x"),
+        column("pos_y"),
+        column("pos_z"),
+    )
+    
+    # Build session bound to current engine (age_in_days needs the session)
+    session = Session(bind=tdb.engine)
+    
+    # Base SELECT: station_id, ls_from_star, age_days
+    age_expr = age_in_days(session, func.max(si.c.modified)).label("age_days")
+    
+    # Optional near-system distance²
+    nearSys = cmdenv.nearSystem
+    if nearSys:
+        dx = (sys_tbl.c.pos_x - literal(nearSys.posX))
+        dy = (sys_tbl.c.pos_y - literal(nearSys.posY))
+        dz = (sys_tbl.c.pos_z - literal(nearSys.posZ))
+        dist2_expr = (dx * dx + dy * dy + dz * dz).label("d2")
+    else:
+        dist2_expr = literal(0.0).label("d2")
+    
+    stmt = (
+        select(
+            si.c.station_id,
+            age_expr,
+            stn.c.ls_from_star,
+            dist2_expr,
+        )
+        .select_from(
+            si.join(stn, stn.c.station_id == si.c.station_id)
+            .join(sys_tbl, sys_tbl.c.system_id == stn.c.system_id) if nearSys
+            else si.join(stn, stn.c.station_id == si.c.station_id)
+        )
+        .group_by(si.c.station_id, stn.c.ls_from_star, dist2_expr)
+        .order_by(age_expr.desc())
+    )
+    
+    # Bounding box for near (keeps scan small, mirrors original)
+    if nearSys:
+        maxLy = cmdenv.maxLyPer or cmdenv.maxSystemLinkLy
+        # Bounding box predicate
+        stmt = stmt.where(
+            sys_tbl.c.pos_x.between(nearSys.posX - maxLy, nearSys.posX + maxLy),
+            sys_tbl.c.pos_y.between(nearSys.posY - maxLy, nearSys.posY + maxLy),
+            sys_tbl.c.pos_z.between(nearSys.posZ - maxLy, nearSys.posZ + maxLy),
+        )
+        # Radius filter: HAVING dist2 <= maxLy^2
+        stmt = stmt.having(dist2_expr <= (maxLy * maxLy))
+    
+    # Min-age filter (apply to aggregated age of MAX(modified))
+    if cmdenv.minAge:
+        stmt = stmt.having(age_expr >= float(cmdenv.minAge))
+    
+    # Execute and materialize rows
+    rows = session.execute(stmt).fetchall()
+    session.close()
+    
+    # Downstream filters (unchanged)
+    padSize = cmdenv.padSize
+    planetary = cmdenv.planetary
+    fleet = cmdenv.fleet
+    odyssey = cmdenv.odyssey
+    noPlanet = cmdenv.noPlanet
+    mls = cmdenv.maxLs
+    
+    for (stnID, age, ls, dist2) in rows:
+        cmdenv.DEBUG2("{}:{}:{}", stnID, age, ls)
+        row = ResultRow()
+        row.station = tdb.stationByID[stnID]
+        row.age = float(age or 0.0)
+        row.ls = "{:n}".format(ls) if ls else "?"
+        row.dist = (float(dist2) ** 0.5) if dist2 else 0.0
+        
+        if padSize and not row.station.checkPadSize(padSize):
+            continue
+        if planetary and not row.station.checkPlanetary(planetary):
+            continue
+        if fleet and not row.station.checkFleet(fleet):
+            continue
+        if odyssey and not row.station.checkOdyssey(odyssey):
+            continue
+        if noPlanet and row.station.planetary != 'N':
+            continue
+        if mls and row.station.lsFromStar > mls:
+            continue
+        
+        results.rows.append(row)
+    
+    # Route optimization and limiting (unchanged)
+    if cmdenv.route and len(results.rows) > 1:
+        def walk(start_idx, dist):
+            rows_ = results.rows
+            startNode = rows_[start_idx]
+            openList = set(rows_)
+            path = [startNode]
+            openList.remove(startNode)
+            while len(path) < len(rows_):
+                lastNode = path[-1]
+                distFn = lastNode.station.system.distanceTo
+                nearest = min(openList, key=lambda r: distFn(r.station.system))
+                openList.remove(nearest)
+                path.append(nearest)
+                dist += distFn(nearest.station.system)
+            return (path, dist)
+        
+        if cmdenv.near:
+            bestPath = walk(0, results.rows[0].dist)
+        else:
+            bestPath = (results.rows, float("inf"))
+            for i in range(len(results.rows)):
+                candidate = walk(i, 0)
+                if candidate[1] < bestPath[1]:
+                    bestPath = candidate
+        results.rows[:] = bestPath[0]
+    
+    if cmdenv.limit:
+        results.rows[:] = results.rows[:cmdenv.limit]
+    
+    return results
+
+
+######################################################################
+# Transform result set into output
+
+def render(results, cmdenv, tdb):
+    from ..formatting import RowFormat, ColumnFormat
+    
+    if not results or not results.rows:
+        raise TradeException("No data found")
+    
+    # Compare system names so we can tell
+    longestNamed = max(results.rows,
+                    key=lambda row: len(row.station.name()))
+    longestNameLen = len(longestNamed.station.name())
+    
+    rowFmt = RowFormat().append(
+            ColumnFormat("Station", '<', longestNameLen,
+                    key=lambda row: row.station.name())
+    )
+    
+    if cmdenv.quiet < 2:
+        if cmdenv.nearSystem:
+            rowFmt.addColumn('DistLy', '>', 6, '.2f',
+                    key=lambda row: row.dist
+            )
+        
+        rowFmt.append(
+                ColumnFormat("Age/days", '>', '8', '.2f',
+                        key=lambda row: row.age)
+        ).append(
+                ColumnFormat("StnLs", '>', '10',
+                        key=lambda row: row.station.distFromStar())
+        ).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 not cmdenv.quiet:
+        heading, underline = rowFmt.heading()
+        print(heading, underline, sep='\n')
+    
+    for row in results.rows:
+        print(rowFmt.format(row))