tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/prices.py

@@ -0,0 +1,211 @@
+# --------------------------------------------------------------------
+# Copyright (C) Oliver 'kfsone' Smith 2014 <oliver@kfs.org>:
+# Copyright (C) Bernd 'Gazelle' Gollesch 2016, 2017
+# Copyright (C) Stefan 'Tromador' Morrell 2025
+# Copyright (C) Jonathan 'eyeonus' Jones 2018-2025
+#
+# You are free to use, redistribute, or even print and eat a copy of
+# this software so long as you include this copyright notice.
+# I guarantee there is at least one bug neither of us knew about.
+# --------------------------------------------------------------------
+# TradeDangerous :: Modules :: Generate TradeDangerous.prices
+
+import sys
+from sqlalchemy.orm import Session
+from .db import orm_models as SA
+from .tradeexcept import TradeException
+
+
+class Element:      # TODO: enum?
+    basic     = 1 << 0
+    supply    = 1 << 1
+    timestamp = 1 << 2
+    full      = basic | supply | timestamp
+    blanks    = 1 << 31
+
+
+######################################################################
+# Main
+
+def dumpPrices(
+    session: Session,      # SQLAlchemy session
+    elementMask,           # which columns to output
+    stationID=None,        # limits to one station
+    file=None,             # file handle to write to
+    defaultZero=False,
+    debug=0,
+):
+    """
+    Generate a prices list using data from the DB.
+    If stationID is not None, only the specified station is dumped.
+    If file is not None, outputs to the given file handle.
+    """
+    
+    withTimes = elementMask & Element.timestamp
+    
+    # ORM queries to build lookup dicts
+    systems = dict(
+        session.query(SA.System.system_id, SA.System.name).all()
+    )
+    
+    stations = {
+        ID: [name, systems.get(sysID)]
+        for ID, name, sysID in session.query(
+            SA.Station.station_id, SA.Station.name, SA.Station.system_id
+        ).all()
+    }
+    
+    categories = dict(
+        session.query(SA.Category.category_id, SA.Category.name).all()
+    )
+    
+    items = {
+        ID: [name, catID, categories[catID]]
+        for ID, name, catID in session.query(
+            SA.Item.item_id, SA.Item.name, SA.Item.category_id
+        ).all()
+    }
+    
+    # find longest item name (for formatting)
+    longestName = max(items.values(), key=lambda ent: len(ent[0]))
+    longestNameLen = len(longestName[0])
+    
+    defaultDemandVal = 0 if defaultZero else -1
+    
+    # Build the main query
+    q = (
+        session.query(
+            SA.StationItem.station_id,
+            SA.Item.item_id,
+            SA.StationItem.demand_price,
+            SA.StationItem.supply_price,
+            SA.StationItem.demand_units,
+            SA.StationItem.demand_level,
+            SA.StationItem.supply_units,
+            SA.StationItem.supply_level,
+            SA.StationItem.modified,
+            SA.Item.name,
+            SA.Item.category_id,
+            SA.Category.name.label("category_name"),
+            SA.Station.name.label("station_name"),
+            SA.System.name.label("system_name"),
+        )
+        .join(SA.Item, SA.Item.item_id == SA.StationItem.item_id)
+        .join(SA.Category, SA.Category.category_id == SA.Item.category_id)
+        .join(SA.Station, SA.Station.station_id == SA.StationItem.station_id)
+        .join(SA.System, SA.System.system_id == SA.Station.system_id)
+        .order_by(SA.Station.station_id, SA.Category.name, SA.Item.ui_order)
+    )
+    
+    if stationID:
+        q = q.filter(SA.StationItem.station_id == stationID)
+    
+    # Set up output
+    if not file:
+        file = sys.stdout
+    
+    if stationID:
+        stationSet = str(stations[stationID])
+    else:
+        stationSet = "ALL Systems/Stations"
+    
+    file.write(
+        "# TradeDangerous prices for {}\n"
+        "\n"
+        "# REMOVE ITEMS THAT DON'T APPEAR IN THE UI\n"
+        "# ORDER IS REMEMBERED: Move items around within categories "
+        "to match the game UI\n"
+        "\n"
+        "# File syntax:\n"
+        "# <item name> <sell> <buy> [<demand> <supply> [<timestamp>]]\n"
+        "#   Use '?' for demand/supply when you don't know/care,\n"
+        "#   Use '-' for demand/supply to indicate unavailable,\n"
+        "#   Otherwise use a number followed by L, M or H, e.g.\n"
+        "#     1L, 23M or 30000H\n"
+        "# If you omit the timestamp, the current time will be used when "
+        "the file is loaded.\n"
+        "\n".format(stationSet)
+    )
+    
+    levelDesc = "?0LMH"
+    maxCrWidth = 7
+    levelWidth = 9
+    
+    outFmt = (
+        "      {{:<{width}}}"
+        " {{:>{crwidth}}}"
+        " {{:>{crwidth}}}"
+        "  {{:>{lvlwidth}}}"
+        " {{:>{lvlwidth}}}".format(
+            width=longestNameLen,
+            crwidth=maxCrWidth,
+            lvlwidth=levelWidth,
+        )
+    )
+    if withTimes:
+        outFmt += "  {}"
+    outFmt += "\n"
+    header = outFmt.format(
+        "Item Name",
+        "SellCr", "BuyCr",
+        "Demand", "Supply",
+        "Timestamp",
+    )
+    file.write('#' + header[1:])
+    
+    naIQL = "-"
+    unkIQL = "?"
+    defIQL = "?" if not defaultZero else "-"
+    
+    # Main loop — stream results instead of preloading
+    output = ""
+    lastStn, lastCat = None, None
+    for row in q.yield_per(1000).execution_options(stream_results=True):
+        stnID = row.station_id
+        station = row.station_name
+        system = row.system_name
+        item = row.name
+        catID = row.category_id
+        category = row.category_name
+        
+        # Guard against bad system names
+        if not system:
+            raise TradeException(
+                f"Station {station} (ID {stnID}) is linked to a system with no name."
+            )
+        
+        if stnID != lastStn:
+            file.write(output)
+            output = f"\n\n@ {system.upper()}/{station}\n"
+            lastStn = stnID
+            lastCat = None
+        
+        if catID != lastCat:
+            output += f"   + {category}\n"
+            lastCat = catID
+        
+        demandCr = row.demand_price or 0
+        supplyCr = row.supply_price or 0
+        demandUnits = row.demand_units or defaultDemandVal
+        demandLevel = row.demand_level or defaultDemandVal
+        supplyUnits = row.supply_units or defaultDemandVal
+        supplyLevel = row.supply_level or defaultDemandVal
+        
+        # Demand/supply formatting
+        if supplyCr > 0:
+            demandStr = defIQL if demandCr <= 0 else unkIQL
+            supplyStr = (
+                naIQL if supplyLevel == 0
+                else (f"{supplyUnits if supplyUnits >= 0 else '?'}{levelDesc[supplyLevel+1]}")
+            )
+        else:
+            demandStr = (
+                naIQL if demandCr == 0 or demandLevel == 0
+                else (f"{demandUnits if demandUnits >= 0 else '?'}{levelDesc[demandLevel+1]}")
+            )
+            supplyStr = naIQL
+        
+        modified = row.modified or ""
+        output += outFmt.format(item, demandCr, supplyCr, demandStr, supplyStr, modified)
+    
+    file.write(output)

tradedangerous/submit-distances.py

@@ -0,0 +1,422 @@
+#!/usr/bin/env python3.6
+# Deprecated
+# Website no longer exists
+
+"""
+Small tool to submit new star data to EDStarCoordinator.
+
+Use:
+    submit-distances.py "system name"
+"""
+
+#
+# NOTE: This tool is very hacky. If someone wants to clean it up,
+# and submit a diff, that'd be greatly appreciated!
+#
+
+import argparse
+import os
+import random
+import re
+import requests
+import sys
+import tradedb
+import tradeenv
+
+from tradedangerous.misc.edsc import StarSubmission, StarSubmissionResult, SubmissionError
+from tradedangerous.misc.clipboard import SystemNameClip
+
+
+standardStars = [
+    "SOL",
+    "NEW YEMBO",
+    "VESUVIT",
+    "HIP 79884",
+    "ASELLUS AUSTRALIS",
+]
+
+
+sys.stderr.write("*** WARNING: submit-distances.py is deprecated; if you rely on it, please post a github issue\n")
+
+
+############################################################################
+
+
+class UsageError(Exception):
+    def __init__(self, argv, error):
+        self.argv, self.error = argv, error
+    
+    def __str__(self):
+        return error + "\n" + argv.format_usage()
+
+def parse_arguments():
+    parser = argparse.ArgumentParser(
+        description='Submit star distances to the EDSC project.',
+    )
+    parser.add_argument(
+        'origin',
+        help='System to submit distances for.',
+        type=str,
+    )
+    parser.add_argument(
+        '--pick',
+        help='Randomly select N existing systems from gamma or ealier',
+        required=False,
+        type=int,
+    )
+    parser.add_argument(
+        '--cmdr',
+        required=False,
+        help='Specify your commander name.',
+        type=str,
+        default=os.environ.get('CMDR', None)
+    )
+    parser.add_argument(
+        '--test',
+        help='Use the EDSC Test Database.',
+        required=False,
+        action='store_true',
+    )
+    parser.add_argument(
+        '--detail', '-v',
+        help='Output additional detail.',
+        action='count',
+        default=0,
+    )
+    parser.add_argument(
+        '--debug', '-w',
+        help='Enable debugging output,',
+        action='count',
+        default=0,
+    )
+    parser.add_argument(
+        '--no-update',
+        help='Disallow distances from an existing system.',
+        action='store_false',
+        default=True,
+        dest='allowUpdate',
+    )
+    parser.add_argument(
+        '--extra-file',
+        help='File to read/write extra stars to.',
+        type=str,
+        default='data/extra-stars.txt',
+        dest='extraFile',
+    )
+    parser.add_argument(
+        'destinations',
+        help='System or systems to measure distance to.',
+        default=[],
+        nargs='*',
+    )
+    
+    argv = parser.parse_args(sys.argv[1:])
+    argv.origin = argv.origin.upper()
+    if argv.origin.startswith('@'):
+        argv.origin = argv.origin[1:]
+    
+    if not argv.cmdr:
+        raise UsageError(argv, "No commander name specified")
+    
+    return argv
+
+def get_system(argv, tdb):
+    system = tdb.systemByName.get(argv.origin.upper(), None)
+    if not system:
+        return argv.origin, None
+    
+    if not argv.allowUpdate:
+        raise UsageError(
+            argv,
+            "System '{}' already exists.\n"
+            .format(systemName)
+        )
+    
+    if argv.detail:
+        print("EXISTING SYSTEM:", argv.origin)
+    
+    return argv.origin, system
+
+def pick_destinations(argv, tdb):
+    numSystems = len(tdb.systemByName)
+    if numSystems < 1:
+        raise UsageError(
+            argv,
+            "Can't --pick random systems: "
+            "Your TD database doesn't contain any systems."
+        )
+    num = min(argv.pick, numSystems)
+    systems = tdb.systemByName
+    try:
+        gamma = tdb.lookupAdded("Gamma")
+    except KeyError:
+        gamma = 20
+    destinations = random.sample([
+        sysName for sysName, system in systems.items()
+        if system.addedID <= gamma and \
+            not sysName in standardStars
+    ], num)
+    
+    return destinations
+
+def get_outliers(argv):
+    outliers = set()
+    try:
+        with open(argv.extraFile, "r", encoding="utf-8") as input:
+            for line in input:
+                name = line.partition('#')[0].strip().upper()
+                if name and name != argv.origin:
+                    outliers.add(name)
+    except FileNotFoundError:
+        pass
+    outliers = list(outliers)
+    random.shuffle(outliers)
+    return outliers
+
+def get_distances(argv, clip, stars):
+    distances = []
+    for star in stars:
+        starNo = len(distances) + 1
+        # Check it's not already in the list
+        star = star.upper()
+        if star in distances:
+            continue
+        
+        clip.copy_text(star)
+        
+        if len(stars) > 1:
+            prefix = "{:>2}/{:2}: ".format(starNo, len(stars))
+        else:
+            prefix = ""
+        dist = input(prefix + "Distance to {}: ".format(star))
+        if dist == 'q':
+            return distances, 'q'
+        
+        if dist:
+            distances.append({
+                'name': star.upper(),
+                'dist': float(dist),
+            })
+    
+    return distances, 'end'
+
+def check_system(argv, tdb, tdbSys, name):
+    system = tdb.systemByName.get(name.upper(), None)
+    if system and not tdbSys:
+        print("KNOWN SYSTEM")
+        return
+    if system:
+        print("KNOWN SYSTEM: {:.2f} ly".format(
+            tdbSys.distanceTo(system)
+        ))
+
+def add_extra_stars(argv, extraStars):
+    if not extraStars:
+        return
+    if argv.detail:
+        print("Saving {} to {}".format(
+            str(extraStars), argv.extraFile,
+        ))
+    try:
+        with open(argv.extraFile, "a", encoding="utf-8") as output:
+            for star in extraStars:
+                print(star, file=output)
+    except FileNotFoundError:
+        pass
+
+def submit_distances(argv, tdb, distances):
+    system = argv.origin
+    cmdr = argv.cmdr
+    mode = "TEST" if argv.test else "Live"
+    
+    print()
+    print("System:", system)
+    print("Database:", mode)
+    print("Distances:")
+    for ref in distances:
+        print("  {}: {:.02f} ly".format(
+            ref['name'], ref['dist']
+        ))
+    print()
+    
+    ok = input("Does this look correct (y/n)? ")
+    if ok != 'y':
+        print("Stopped")
+        return
+    
+    print()
+    print("Submitting {} {}".format(mode, system))
+    
+    sub = StarSubmission(
+        star=system,
+        commander=cmdr,
+        refs=distances,
+        test=argv.test,
+    )
+    resp = sub.submit()
+    
+    result = StarSubmissionResult(star=system, response=resp)
+    print(str(result))
+    if result.valid:
+        # Check for systems we can add
+        trilats = set()
+        for sysName in result.systems.keys():
+            code, coord = result.systems[sysName]
+            sysName = sysName.upper()
+            # Does it have a distance
+            if isinstance(coord, (list, tuple)):
+                x, y, z = coord
+                system = tdb.systemByName.get(sysName, None)
+                if system:
+                    tdb.updateLocalSystem(system, sysName, x, y, z)
+                else:
+                    tdb.addLocalSystem(sysName, x, y, z)
+        if result.recheck:
+            return list(result.recheck.keys())
+    return None
+
+def do_rechecks(argv, clip, rechecks):
+    print("\aSome systems need their distances rechecked:")
+    
+    distances, term = get_distances(argv, clip, rechecks)
+    return distances
+
+def send_and_check_distances(argv, tdb, clip, distances):
+    if not distances:
+        if argv.detail:
+            print("No distances, no submission.")
+        return False
+    
+    while distances:
+        rechecks = submit_distances(argv, tdb, distances)
+        if not rechecks:
+            break
+        
+        distances = do_rechecks(argv, clip, rechecks)
+    
+    return True
+
+def process_destinations(argv, tdb):
+    clip = SystemNameClip()
+    
+    print("Distances from {}:".format(argv.origin))
+    distances, _ = get_distances(argv, clip, argv.destinations)
+    send_and_check_distances(argv, tdb, clip, distances)
+
+############################################################################
+
+def main():
+    argv = parse_arguments()
+    
+    tdenv = tradeenv.TradeEnv(properties=argv)
+    tdb = tradedb.TradeDB(tdenv)
+    
+    system, tdbSys = get_system(argv, tdb)
+    
+    if argv.pick:
+        argv.destinations.extend(pick_destinations(argv, tdb))
+    
+    if argv.destinations:
+        process_destinations(argv, tdb)
+        return
+    
+    print("Add EDSC Star Distances for \"{}\"".format(system))
+    print()
+    print("You will now be prompted for distances to various stars.")
+    print()
+    print(
+        "At each prompt, the star name will be copied into your paste buffer. "
+        "You should alt-tab into the game and paste the name into the Galaxy "
+        "Map's search box. Then alt-tab back and enter the distance value."
+    )
+    print()
+    print(
+        "At each prompt enter a ly distance (e.g. 123.45), q to stop, "
+        "or leave the line empty if you don't want to enter data for "
+        "this star."
+    )
+    print(
+        "5 distances are required for EDSC to make a first guess at a "
+        "star's location. You can submit more to increase the accuracy "
+        "but the only time you need to submit more than 10 is when you "
+        "are trying to submit corrections."
+    )
+    print()
+    
+    clip = SystemNameClip()
+    
+    print()
+    print("""
+===================================================
+STANDARD STARS: (q to skip to the next section)
+  
+  These are stars with well-known positions.
+===================================================
+""")
+    distances, term = get_distances(argv, clip, standardStars)
+    if distances:
+        send_and_check_distances(argv, tdb, clip, distances)
+    
+    outliers = get_outliers(argv)
+    if outliers:
+        print("""
+===================================================
+EXTRA STARS: (q to skip to the next section)
+  
+  Stars from {}.
+===================================================
+""".format(argv.extraFile))
+        distances, term = get_distances(argv, clip, outliers)
+        if distances:
+            send_and_check_distances(argv, tdb, clip, distances)
+    
+    print("""
+===================================================
+CHOOSE YOUR OWN: (q to stop)
+  
+  Specify additional stars.
+  
+  Prefix names with a '+' to add them to
+  {}.
+===================================================
+""".format(argv.extraFile))
+    distances = []
+    newOutliers = []
+    while True:
+        star = input("Enter star name: ")
+        star = star.strip().upper()
+        if not star or star == 'Q':
+            break
+        # Remove surrounding quotes
+        save = False
+        if star.startswith('+'):
+            save = True
+            star = star[1:].strip()
+        star = re.sub(r'\s+', ' ', star)
+        star = re.sub(r"''+", "'", star)
+        star = re.sub(r'^("|\')+\s*(.*)\s*\1+', r'\2', star)
+        if star.find('"') >= 0:
+            print("Invalid star name")
+            continue
+        if star.startswith('+'):
+            save = True
+            star = star[1:].strip()
+        for ref in distances:
+            if ref['name'] == star:
+                print("'{}' is already listed.")
+                continue
+        check_system(argv, tdb, tdbSys, star)
+        extras, term = get_distances(argv, clip, [star])
+        if term != 'q' and len(extras) > 0:
+            distances.extend(extras)
+            if save and star not in outliers and star not in newOutliers:
+                newOutliers.append(star)
+    
+    if send_and_check_distances(argv, tdb, clip, distances):
+        add_extra_stars(argv, newOutliers)
+
+if __name__ == "__main__":
+    try:
+        main()
+    except (SubmissionError, UsageError) as e:
+        print(str(e))

tradedangerous/templates/Added.csv

@@ -0,0 +1,37 @@
+unq:name
+'Alpha1'
+'Alpha2'
+'Alpha3'
+'Alpha4'
+'Beta1'
+'Beta1 (unverified)'
+'Beta1 (unverified)-Inferred'
+'Beta1-Inferred'
+'Beta2'
+'Beta2 (outside Beta3)'
+'Beta2 (outside Beta3)-Inferred'
+'Beta2 (unverified)'
+'Beta2 (unverified)-Inferred'
+'Beta2-Inferred'
+'Beta3'
+'Beta3 (unverified)'
+'Beta3 (unverified)-Inferred'
+'Beta3-Inferred'
+'Beyond The Pill (unverified)-Inferred'
+'EDSM'
+'Gamma'
+'Gamma (unverified)'
+'Gamma (unverified)-Inferred'
+'Gamma-Inferred'
+'Gamma1'
+'Gamma1 (unverified)'
+'Gamma1 (unverified)-Inferred'
+'Gamma1-Inferred'
+'Journal'
+'Local'
+'netLog'
+'Not Present'
+'Premium Beta1'
+'Premium Beta2'
+'Release 1.00-EDStar'
+'undefined-Inferred'

tradedangerous/templates/Category.csv

@@ -0,0 +1,17 @@
+unq:category_id,name
+1,Metals
+2,Minerals
+3,Chemicals
+4,Foods
+5,Textiles
+6,Industrial Materials
+7,Medicines
+8,Legal Drugs
+9,Machinery
+10,Technology
+11,Weapons
+12,Consumer Items
+13,Slavery
+14,Waste
+15,NonMarketable
+16,Salvage