tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/commands/parsing.py

@@ -0,0 +1,221 @@
+from .exceptions import (
+    FleetCarrierError, OdysseyError, PadSizeError, PlanetaryError,
+)
+
+######################################################################
+# Parsing Helpers
+
+class ParseArgument:
+    """
+        Provides argument forwarding so that 'makeSubParser' can take function-like arguments.
+    """
+    def __init__(self, *args, **kwargs):
+        self.args, self.kwargs = args, kwargs
+
+
+class MutuallyExclusiveGroup:
+    def __init__(self, *args):
+        self.arguments = list(args)
+
+
+######################################################################
+# Derived Parsers
+
+
+class CreditParser(int):
+    """
+    argparse helper for parsing numeric prefixes, i.e.
+    'k' for thousands, 'm' for millions and 'b' for billions.
+    """
+    suffixes = {'k': 10**3, 'm': 10**6, 'b': 10**9}
+    
+    def __new__(cls, val, **kwargs):
+        if isinstance(val, str):
+            if val[-1].lower() in CreditParser.suffixes:
+                val = int(float(val[:-1]) * CreditParser.suffixes[val[-1].lower()])
+        return super().__new__(cls, val, **kwargs)
+
+
+class PadSizeArgument(int):
+    """
+    argparse helper for --pad-size
+    """
+    class PadSizeParser(str):
+        def __new__(cls, val, **kwargs):
+            if not isinstance(val, str):
+                raise PadSizeError(val)
+            for v in val:
+                if "SML?".find(v.upper()) < 0:
+                    raise PadSizeError(val.upper())
+            return super().__new__(cls, val, **kwargs)
+    
+    def __init__(self):
+        self.args = ('--pad-size', '-p',)
+        self.kwargs = {
+            'help': (
+                'Limit to stations with one of the specified pad sizes, '
+                'e.g. --pad SML? matches any pad, --pad M matches only '
+                'medium pads.'
+            ),
+            'dest': 'padSize',
+            'metavar': 'PADSIZES',
+            'type': 'padsize',
+        }
+
+
+class AvoidPlacesArgument(ParseArgument):
+    def __init__(self):
+        self.args = ['--avoid']
+        self.kwargs = {
+            'action': 'append',
+            'help': (
+                "Don't list results for the specified systems or stations.\n"
+                "Names can be one-per '--avoid' or comma separated, e.g. "
+                "'--avoid a,b,c' or '--avoid a,b --avoid c'"
+            ),
+        }
+
+
+class SwitchArgument(ParseArgument):
+    def __init__(self, help=None):
+        if isinstance(self.switches, (tuple, list)):
+            self.args = self.switches
+        else:
+            self.args = (self.switches,)
+        help = help or self.help
+        self.kwargs = {'action': 'store_true', 'dest': self.dest, 'help': help}
+
+
+class BlackMarketSwitch(SwitchArgument):
+    switches = ['--black-market', '--bm']
+    dest = 'blackMarket'
+    help = 'Require stations known to have a black market.'
+
+
+class ShipyardSwitch(SwitchArgument):
+    switches = ['--shipyard']
+    dest = 'shipyard'
+    help = 'Require stations known to have a Shipyard.'
+
+
+class OutfittingSwitch(SwitchArgument):
+    switches = ['--outfitting']
+    dest = 'outfitting'
+    help = 'Require stations known to have Outfitting.'
+
+
+class RearmSwitch(SwitchArgument):
+    switches = ['--rearm']
+    dest = 'rearm'
+    help = 'Require stations known to sell munitions.'
+
+
+class RefuelSwitch(SwitchArgument):
+    switches = ['--refuel']
+    dest = 'refuel'
+    help = 'Require stations known to sell fuel.'
+
+
+class RepairSwitch(SwitchArgument):
+    switches = ['--repair']
+    dest = 'repair'
+    help = 'Require stations known to offer repairs.'
+
+
+class NoPlanetSwitch(SwitchArgument):
+    switches = ['--no-planet']
+    dest = 'noPlanet'
+    help = 'Require stations to be in space.'
+
+
+class PlanetaryArgument(int):
+    """
+    argparse helper for --planetary
+    """
+    class PlanetaryParser(str):
+        def __new__(cls, val, **kwargs):
+            if not isinstance(val, str):
+                raise PlanetaryError(val)
+            for v in val:
+                if "YN?".find(v.upper()) < 0:
+                    raise PlanetaryError(val.upper())
+            return super().__new__(cls, val, **kwargs)
+    
+    def __init__(self):
+        self.args = ['--planetary']
+        self.kwargs = {
+            'help': (
+                'Limit to stations with one of the specified planetary, '
+                'e.g. --pla YN? matches any station, --pla Y matches only '
+                'planetary stations.'
+            ),
+            'dest': 'planetary',
+            'metavar': 'PLANETARY',
+            'type': 'planetary',
+        }
+
+
+class FleetCarrierArgument(int):
+    """
+    argparse helper for --fleet-carrier
+    """
+    class FleetCarrierParser(str):
+        def __new__(cls, val, **kwargs):
+            if not isinstance(val, str):
+                raise FleetCarrierError(val)
+            for v in val:
+                if "YN?".find(v.upper()) < 0:
+                    raise FleetCarrierError(val.upper())
+            return super().__new__(cls, val, **kwargs)
+    
+    def __init__(self):
+        self.args = ['--fleet-carrier', '--fc']
+        self.kwargs = {
+            'help': (
+                'Limit to stations with one of the specified fleet-carrier, '
+                'e.g. --fc YN? matches any station, --fc Y matches only '
+                'fleet-carrier stations.'
+            ),
+            'dest': 'fleet',
+            'metavar': 'FLEET',
+            'type': 'fleet',
+        }
+
+class OdysseyArgument(int):
+    """
+    argparse helper for --odyssey
+    """
+    class OdysseyParser(str):
+        def __new__(cls, val, **kwargs):
+            if not isinstance(val, str):
+                raise OdysseyError(val)
+            for v in val:
+                if "YN?".find(v.upper()) < 0:
+                    raise OdysseyError(val.upper())
+            return super().__new__(cls, val, **kwargs)
+    
+    def __init__(self):
+        self.args = ['--odyssey', '--od']
+        self.kwargs = {
+            'help': (
+                'Limit to stations with one of the specified odyssey, '
+                'e.g. --od YN? matches any station, --od Y matches only '
+                'odyssey stations.'
+            ),
+            'dest': 'odyssey',
+            'metavar': 'ODYSSEY',
+            'type': 'odyssey',
+        }
+
+
+__tdParserHelpers = {
+    'credits': CreditParser,
+    'padsize': PadSizeArgument.PadSizeParser,
+    'planetary': PlanetaryArgument.PlanetaryParser,
+    'fleet': FleetCarrierArgument.FleetCarrierParser,
+    'odyssey': OdysseyArgument.OdysseyParser,
+}
+
+def registerParserHelpers(into):
+    for typeName, helper in __tdParserHelpers.items():
+        into.register('type', typeName, helper)

tradedangerous/commands/rares_cmd.py

@@ -0,0 +1,298 @@
+from .commandenv import ResultRow
+from .exceptions import CommandLineError
+from .parsing import (
+    PadSizeArgument, ParseArgument, MutuallyExclusiveGroup, NoPlanetSwitch,
+    PlanetaryArgument, FleetCarrierArgument, OdysseyArgument,
+)
+from ..formatting import RowFormat, max_len
+from ..tradedb import TradeDB, select, SA_Category, SA_RareItem, SA_Station
+
+import time
+
+
+######################################################################
+# Parser config
+
+# Displayed on the "trade.py --help" command list, etc.
+help='Find rares near your current local.'
+# Should match the name of the module minus the _cmd.py
+name='rares'
+# Displayed at the end of the "trade.py rares --help"
+epilog=None
+# Set to False in commands that need to operate without
+# a trade database.
+wantsTradeDB=True
+# Required parameters
+arguments = [
+    ParseArgument(
+            'near',
+            help='Your current system.',
+            type=str,
+            metavar='SYSTEMNAME',
+    ),
+]
+# Optional parameters
+switches = [
+    ParseArgument('--ly',
+            help='Maximum distance to search.',
+            metavar='LY',
+            type=float,
+            default=180,
+            dest='maxLyPer',
+    ),
+    ParseArgument('--limit',
+            help='Maximum number of results to list.',
+            default=None,
+            type=int,
+    ),
+    PadSizeArgument(),
+    MutuallyExclusiveGroup(
+        NoPlanetSwitch(),
+        PlanetaryArgument(),
+    ),
+    FleetCarrierArgument(),
+    OdysseyArgument(),
+    ParseArgument('--price-sort', '-P',
+            help='Sort by price not distance.',
+            action='store_true',
+            default=False,
+            dest='sortByPrice',
+    ),
+    ParseArgument('--reverse', '-r',
+            help='Reverse the list.',
+            action='store_true',
+            default=False,
+    ),
+    ParseArgument('--away',
+            help='Require "--from" systems to be at least this far from primary system',
+            metavar='LY',
+            default=0,
+            type=float,
+    ),
+    MutuallyExclusiveGroup(
+        ParseArgument('--legal',
+            help='List only items known to be legal.',
+            action='store_true',
+        ),
+        ParseArgument('--illegal',
+            help='List only items known to be illegal.',
+            action='store_true',
+        )
+    ),
+    ParseArgument('--from',
+            help='Additional systems to range check candidates against, requires --away.',
+            metavar='SYSTEMNAME',
+            action='append',
+            dest='awayFrom',
+    ),
+]
+
+######################################################################
+# Perform query and populate result set
+
+def run(results, cmdenv, tdb):
+    """
+    Fetch all the data needed to display the results of a "rares"
+    command. Does not actually print anything.
+    """
+    # Lookup the system we're currently in.
+    start = cmdenv.nearSystem
+    # Hoist the padSize, noPlanet and planetary parameter for convenience
+    padSize = cmdenv.padSize
+    noPlanet = cmdenv.noPlanet
+    planetary = cmdenv.planetary
+    fleet = cmdenv.fleet
+    odyssey = cmdenv.odyssey
+    # How far we're want to cast our net.
+    maxLy = float(cmdenv.maxLyPer or 0.0)
+    
+    awaySystems = set()
+    if cmdenv.away or cmdenv.awayFrom:
+        if not cmdenv.away or not cmdenv.awayFrom:
+            raise CommandLineError("Invalid --away/--from usage. See --help")
+        minAwayDist = cmdenv.away
+        for sysName in cmdenv.awayFrom:
+            system = tdb.lookupPlace(sysName).system
+            awaySystems.add(system)
+    
+    # Start to build up the results data.
+    results.summary = ResultRow()
+    results.summary.near = start
+    results.summary.ly = maxLy
+    results.summary.awaySystems = awaySystems
+    
+    distCheckFn = start.distanceTo
+    
+    # Look through the rares list.
+    stmt = select(
+        SA_RareItem.rare_id,
+        SA_RareItem.station_id,
+        SA_RareItem.name,
+        SA_RareItem.cost,
+        SA_RareItem.max_allocation,
+        SA_RareItem.illegal,
+        SA_RareItem.suppressed,
+        SA_Category.name
+    ).join(SA_Category)
+    if cmdenv.illegal or cmdenv.legal:
+        stmt = stmt.where(SA_RareItem.illegal == ('Y' if cmdenv.legal else 'N'))
+    if noPlanet:
+        stmt = stmt.join(SA_Station).where(SA_Station.planetary != 'Y')
+    
+    awaySystems = set()
+    
+    started = time.time()
+    with tdb.Session() as session:
+        rows = session.execute(stmt).all()
+    
+    for rare in rows:
+        stn = tdb.stationByID[rare.station_id]
+        if padSize and not stn.checkPadSize(padSize):
+            continue
+        if planetary and not stn.checkPlanetary(planetary):
+            continue
+        if fleet and not stn.checkFleet(fleet):
+            continue
+        if odyssey and not stn.checkOdyssey(odyssey):
+            continue
+        
+        rareSys = stn.system
+        dist = distCheckFn(rareSys)
+        if maxLy > 0.0 and dist > maxLy:
+            continue
+        
+        if awaySystems:
+            awayCheck = rareSys.distanceTo
+            if any(awayCheck(away) < minAwayDist for away in awaySystems):
+                continue
+        
+        row = ResultRow()
+        row.rare = rare
+        row.station = stn            # <-- IMPORTANT: used by render()
+        row.dist = dist
+        results.rows.append(row)
+    
+    cmdenv.DEBUG0("Found {:n} rares in {:.3f}s", len(results.rows), time.time() - started)
+    
+    # Was anything matched?
+    if not results.rows:
+        print("No matches found.")
+        return None
+    
+    # Sort safely even if rare.costCr is None (treat None as 0)
+    def price_key(row):
+        return row.rare.cost or 0
+    
+    if cmdenv.sortByPrice:
+        results.rows.sort(key=lambda row: row.dist)
+        results.rows.sort(key=price_key, reverse=True)
+    else:
+        results.rows.sort(key=price_key, reverse=True)
+        results.rows.sort(key=lambda row: row.dist)
+    
+    if cmdenv.reverse:
+        results.rows.reverse()
+    
+    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):
+    """
+    Render output for 'rares' with robust None-handling.
+    Keeps existing column order/labels.
+    """
+    rows = results.rows
+    if not rows:
+        return
+    
+    # Helpers to coalesce possibly-missing attributes
+    def _cost(row):
+        try:
+            v = row.rare.cost
+            return int(v) if v is not None else 0
+        except Exception:
+            return 0
+    
+    def _rare_name(row):
+        try:
+            n = row.rare.name
+            return n or "?"
+        except Exception:
+            return "?"
+    
+    def _alloc(row):
+        val = row.rare.max_allocation
+        return str(val) if val not in (None, "") else "?"
+    
+    def _rare_illegal(row):
+        val = row.rare.illegal
+        return val if val in ("Y", "N", "?") else "?"
+    
+    def _stn_ls(row):
+        try:
+            v = row.station.distFromStar()
+            return v if v is not None else "?"
+        except Exception:
+            return "?"
+    
+    def _dist(row):
+        try:
+            return float(getattr(row, "dist", 0.0) or 0.0)
+        except Exception:
+            return 0.0
+    
+    def _stn_bm(row):
+        key = getattr(row.station, "blackMarket", "?")
+        return TradeDB.marketStates.get(key, key or "?")
+    
+    def _pad(row):
+        key = getattr(row.station, "maxPadSize", "?")
+        return TradeDB.padSizes.get(key, key or "?")
+    
+    def _plt(row):
+        key = getattr(row.station, "planetary", "?")
+        return TradeDB.planetStates.get(key, key or "?")
+    
+    def _flc(row):
+        key = getattr(row.station, "fleet", "?")
+        return TradeDB.fleetStates.get(key, key or "?")
+    
+    def _ody(row):
+        key = getattr(row.station, "odyssey", "?")
+        return TradeDB.odysseyStates.get(key, key or "?")
+    
+    # Column widths based on safe key functions
+    max_stn = max_len(rows, key=lambda r: r.station.name())
+    max_rare = max_len(rows, key=lambda r: _rare_name(r))
+    
+    rowFmt = RowFormat()
+    rowFmt.addColumn('Station', '<', max_stn, key=lambda r: r.station.name())
+    rowFmt.addColumn('Rare', '<', max_rare, key=lambda r: _rare_name(r))
+    rowFmt.addColumn('Cost', '>', 10, 'n', key=lambda r: _cost(r))
+    rowFmt.addColumn('DistLy', '>', 6, '.2f', key=lambda r: _dist(r))
+    rowFmt.addColumn('Alloc', '>', 5, key=lambda r: _alloc(r))
+    # First B/mkt: rare legality flag (Y/N/?)
+    rowFmt.addColumn('B/mkt', '>', 4, key=lambda r: _rare_illegal(r))
+    rowFmt.addColumn('StnLs', '>', 10, key=lambda r: _stn_ls(r))
+    # Second B/mkt: station black market availability via mapping
+    rowFmt.addColumn('B/mkt', '>', 4, key=lambda r: _stn_bm(r))
+    rowFmt.addColumn('Pad', '>', 3, key=lambda r: _pad(r))
+    rowFmt.addColumn('Plt', '>', 3, key=lambda r: _plt(r))
+    rowFmt.addColumn('Flc', '>', 3, key=lambda r: _flc(r))
+    rowFmt.addColumn('Ody', '>', 3, key=lambda r: _ody(r))
+    
+    if not cmdenv.quiet:
+        heading, underline = rowFmt.heading()
+        print(heading, underline, sep='\n')
+    
+    for row in rows:
+        print(rowFmt.format(row))