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

tradedangerous/commands/market_cmd.py

@@ -4,6 +4,8 @@ from .parsing import (
     ParseArgument, MutuallyExclusiveGroup,
 )
 from ..formatting import RowFormat
+from sqlalchemy import select, table, column
+from sqlalchemy.orm import Session
 
 
 ######################################################################
@@ -50,35 +52,63 @@ def render_units(units, 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()
-    cur = tdb.query("""
-        SELECT  item_id,
-                demand_price, demand_units, demand_level,
-                supply_price, supply_units, supply_level,
-                JULIANDAY('now') - JULIANDAY(modified)
-          FROM  StationItem
-         WHERE  station_id = ?
-    """, [origin.ID])
-    
-    for row in cur:
-        it = iter(row)
+
+    # --- 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)
@@ -89,6 +119,7 @@ def run(results, cmdenv, tdb):
             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)
@@ -99,17 +130,19 @@ def run(results, cmdenv, tdb):
             hasSell = (row.sellCr or units or level)
         else:
             hasSell = False
-        row.age = float(next(it) or 0)
-        
+
+        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
 
 #######################################################################

tradedangerous/commands/olddata_cmd.py

@@ -4,6 +4,8 @@ from .parsing import (
 )
 from ..tradedb import TradeDB
 from ..tradeexcept import TradeException
+from sqlalchemy import select, table, column, func, literal
+from sqlalchemy.orm import Session
 
 
 ######################################################################
@@ -61,150 +63,161 @@ switches = [
 # 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
-    
-    fields = [
-        "si.station_id",
-        "JULIANDAY('NOW') - JULIANDAY(MAX(si.modified))",
-        "stn.ls_from_star",
-    ]
-    
-    joins = []
-    wheres = []
-    havings = []
-    
-    if cmdenv.minAge:
-        wheres.append(
-            "(JULIANDAY('NOW') - JULIANDAY(si.modified) >= {})"
-            .format(cmdenv.minAge)
-        )
-    
+
+    # 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
+    join_sys = False
     if nearSys:
-        maxLy = cmdenv.maxLyPer or tdb.maxSystemLinkLy
-        maxLy2 = maxLy ** 2
-        fields.append(
-                "dist2("
-                    "sys.pos_x, sys.pos_y, sys.pos_z,"
-                    "{}, {}, {}"
-                ") AS d2".format(
-                    nearSys.posX,
-                    nearSys.posY,
-                    nearSys.posZ,
-        ))
-        joins.append("INNER JOIN System sys USING (system_id)")
-        wheres.append("""(
-                sys.pos_x BETWEEN {} and {}
-                AND sys.pos_y BETWEEN {} and {}
-                AND sys.pos_z BETWEEN {} and {}
-        )""".format(
-                nearSys.posX - maxLy,
-                nearSys.posX + maxLy,
-                nearSys.posY - maxLy,
-                nearSys.posY + maxLy,
-                nearSys.posZ - maxLy,
-                nearSys.posZ + maxLy,
-        ))
-        havings.append("d2 <= {}".format(maxLy2))
+        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:
-        fields.append("0")
-    
-    fieldStr = ','.join(fields)
-    
-    if joins:
-        joinStr = ' '.join(joins)
-    else:
-        joinStr = ''
-    
-    if wheres:
-        whereStr = 'WHERE ' + ' AND '.join(wheres)
-    else:
-        whereStr = ''
-    
-    if havings:
-        haveStr = 'HAVING ' + ' AND '.join(havings)
-    else:
-        haveStr = ''
-    
-    stmt = """
-            SELECT  {fields}
-              FROM  StationItem as si
-                    INNER JOIN Station stn USING (station_id)
-                    {joins}
-             {wheres}
-             GROUP  BY 1
-             {having}
-             ORDER  BY 2 DESC
-    """.format(
-            fields=fieldStr,
-            joins=joinStr,
-            wheres=whereStr,
-            having=haveStr,
+        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())
     )
-    
-    cmdenv.DEBUG1(stmt)
-    
+
+    # Bounding box for near (keeps scan small, mirrors original)
+    if nearSys:
+        maxLy = cmdenv.maxLyPer or tdb.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 tdb.query(stmt):
+
+    for (stnID, age, ls, dist2) in rows:
         cmdenv.DEBUG2("{}:{}:{}", stnID, age, ls)
         row = ResultRow()
         row.station = tdb.stationByID[stnID]
-        row.age = age
-        if ls:
-            row.ls = "{:n}".format(ls)
-        else:
-            row.ls = "?"
-        row.dist = dist2 ** 0.5
-        if not padSize or row.station.checkPadSize(padSize):
-            if not planetary or row.station.checkPlanetary(planetary):
-                if not fleet or row.station.checkFleet(fleet):
-                    if not odyssey or row.station.checkOdyssey(odyssey):
-                        if not noPlanet or row.station.planetary == 'N':
-                            if not mls or row.station.lsFromStar <= mls:
-                                results.rows.append(row)
-    
+        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(startNode, dist):
-            rows = results.rows
-            startNode = rows[startNode]
-            openList = set(rows)
+        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):
+            while len(path) < len(rows_):
                 lastNode = path[-1]
                 distFn = lastNode.station.system.distanceTo
-                nearest = min(openList, key=lambda row: distFn(row.station.system))
+                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)):
-                path = walk(i, 0)
-                if path[1] < bestPath[1]:
-                    bestPath = path
+                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