tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/mfd/saitek/x52pro.py

@@ -0,0 +1,195 @@
+"""
+x52pro.py - DirectOutputDevice for SaitekX52Pro
+
+Version: 0.2
+Author: Frazzle
+Version: 0.3
+Author: Oliver "kfsone" Smith <oliver@kfs.org> 2014
+
+Description: Python class implementing specific functions for Saitek X52 Pro
+
+
+TODO:
+    * Error handling and exceptions
+"""
+
+from tradedangerous.mfd.saitek.directoutput import DirectOutputDevice
+
+import sys
+import time
+
+
+class X52Pro(DirectOutputDevice):
+    class Page:
+        _lines = [ str(), str(), str() ]
+        _leds  = dict()
+        
+        def __init__(self, device, page_id, name, active):
+            self.device = device
+            self.page_id = page_id
+            self.name = name
+            self.device.AddPage(self.page_id, name, 1 if active else 0)
+            self.active = active
+        
+        def __del__(self, *args, **kwargs):
+            try:
+                self.device.RemovePage(self.page_id)
+            except AttributeError:
+                pass
+        
+        def __getitem__(self, key):
+            return self._lines[key]
+        
+        def __setitem__(self, key, value):
+            self._lines[key] = value
+            if self.active:
+                self.device.SetString(self.page_id, key, value)
+        
+        def activate(self):
+            if self.active is True:
+                return
+            self.device.AddPage(self.page_id, self.name, 1)
+        
+        def refresh(self):
+            # Resend strings to the display
+            for lineNo, string in enumerate(self._lines):
+                self.device.SetString(self.page_id, lineNo, string)
+            for led, value in self._leds:
+                self.device.SetLed(self.page_id, led, 1 if value else 0)
+        
+        def set_led(self, led, value):
+            self._leds[led] = value
+            if self.active:
+                self.device.SetLed(self.page_id, led, 1 if value else 0)
+        
+        def set_led_colour(self, value, led_red, led_green):
+            if value == "red":
+                self.set_led(led_red, 1)
+                self.set_led(led_green, 0)
+            elif value == "green":
+                self.set_led(led_red, 0)
+                self.set_led(led_green, 1)
+            elif value == "orange":
+                self.set_led(led_red, 1)
+                self.set_led(led_green, 1)
+            elif value == "off":
+                self.set_led(led_red, 0)
+                self.set_led(led_green, 0)
+        
+        def fire(self, value):
+            self.set_led(0, value)
+        
+        def fire_a(self, value):
+            self.set_led_colour(value, 1, 2)
+        
+        def fire_b(self, value):
+            self.set_led_colour(value, 3, 4)
+        
+        def fire_d(self, value):
+            self.set_led_colour(value, 5, 6)
+        
+        def fire_e(self, value):
+            self.set_led_colour(value, 7, 8)
+        
+        def toggle_1_2(self, value):
+            self.set_led_colour(value, 9, 10)
+        
+        def toggle_3_4(self, value):
+            self.set_led_colour(value, 11, 12)
+        
+        def toggle_5_6(self, value):
+            self.set_led_colour(value, 13, 14)
+        
+        def pov_2(self, value):
+            self.set_led_colour(value, 15, 16)
+        
+        def clutch(self, value):
+            self.set_led_colour(value, 17, 18)
+        
+        def throttle_axis(self, value):
+            self.set_led(19, value)
+    
+    pages = {}
+    _page_counter = 0
+    
+    def add_page(self, name, active=True):
+        page = self.pages[name] = self.Page(self, self._page_counter, name, active=active)
+        self._page_counter += 1
+        return page
+    
+    def remove_page(self, name):
+        del self.pages[name]
+
+
+    def OnPage(self, page_id, activated):
+        super().OnPage(page_id, activated)
+        for page in self.pages.values():
+            if page.page_id == page_id:
+                print("Found the page", page_id, activated)
+                if activated:
+                    page.refresh()
+                else:
+                    page.active = False
+                return
+
+
+    def OnSoftButton(self, *args, **kwargs):
+        super().OnSoftButton(*args, **kwargs)
+        print("*** ON SOFT BUTTON")
+
+
+    def finish(self):
+        for page in self.pages:
+            del page
+        super().finish()
+
+
+if __name__ == '__main__':
+    x52 = X52Pro(debug_level=1)
+    print("X52 Connected")
+    
+    x52.add_page("Page1")
+    print("Page1 page added")
+    
+    x52.pages["Page1"][0] = "Test String"
+    try:
+        x52.pages["Page1"][5] = "FAIL"
+        raise ValueError("Your stick thinks it has 5 lines of MFD, I think it lies.")
+    except IndexError:
+        print("Your MFD has the correct number of lines of text")
+    
+    x52.pages["Page1"][1] = "-- Page 1 [0]"
+    
+    fireToggle = False
+    x52.pages["Page1"].fire(fireToggle)
+    x52.pages["Page1"].fire_a("amber")
+    x52.pages["Page1"].toggle_3_4("red")
+    x52.pages["Page1"].throttle_axis(~fireToggle)
+    
+    print("Adding second page")
+    x52.add_page("Page2", active=False)
+    x52.pages["Page2"][0] = "Second Page Is Right Here"
+    x52.pages["Page2"][1] = "-- Page 2 [1]"
+    
+    print("Looping")
+    
+    loopNo = 0
+    while True:
+        try:
+            loopNo += 1
+            x52.pages["Page1"][2] = "Loop #" + str(loopNo)
+            time.sleep(0.25)
+            x52.pages["Page1"].fire_a("red")
+            time.sleep(0.25)
+            x52.pages["Page1"].fire_a("orange")
+            time.sleep(0.25)
+            x52.pages["Page1"].fire_a("green")
+            time.sleep(0.25)
+            x52.pages["Page1"].fire_a("off")
+            fireToggle = ~fireToggle
+            x52.pages["Page1"].fire(fireToggle)
+            x52.pages["Page1"].throttle_axis(~fireToggle)
+        except Exception as e:
+            print(e)
+            x52.finish()
+            sys.exit()

tradedangerous/misc/checkpricebounds.py

@@ -0,0 +1,287 @@
+#! /usr/bin/env python
+
+from collections import defaultdict
+import argparse
+import colorama
+import tradedb
+import tradeenv
+import sys
+
+colorama.init()
+
+def check_price_bounds(
+        tdb,
+        table,
+        margin=25,
+        deletePrices="tmp/deletions.prices",
+        deleteSql="tmp/deletions.sql",
+        doDeletions=False,
+        percentile=5,
+        errorFilter=None,
+        ):
+    assert isinstance(percentile, (int,float))
+    assert percentile >= 0.01 and percentile < 50
+    
+    lowP = percentile / 100
+    highP = 1 - lowP
+    
+    mask = "{:>7}:{:<28}|{:>8}|{:>8}|{:>8}|{:>8}|{:>8}|{:>8}|{:>8}|{:>8}|{:>8} {}"
+    header = "{}:\n".format(table)
+    header += mask.format(
+        "#prices", "name",
+        "p0", "low", "p{}".format(percentile),
+        "p50", "avg", "midavg",
+        "p{}".format(100-percentile), "high", "p100",
+        ""
+    )
+    header += "\n" + '-' * len(header)
+    print(header)
+    
+    deletions = []
+    stations = defaultdict(list)
+    
+    def remediation(item, compare, value):
+        deletion = (
+            "DELETE FROM {} "
+            "WHERE item_id = {} "
+            "AND price > 0 AND price {} {}".format(
+                table, item.ID, compare, value
+        ))
+        deletions.append((deletion, "{}".format(item.dbname)))
+        count = 0
+        for (stnID,) in tdb.query("""
+                    SELECT station_id FROM {}
+                     WHERE item_id = {} AND price > 0 AND price {} {}
+                """.format(
+                    table, item.ID, compare, value,
+                )):
+            stations[stnID].append((item.ID, compare, value))
+            count += 1
+        return count
+    
+    # Distance between p50 and p5 or p95 is 45.
+    # We use multiplier to expand projections so that our thresholds
+    # behave as though they are pX to p50+M instead of pX to p50.
+    multiplier = (50 + margin) / (50 - lowP)
+    
+    for item in tdb.itemByID.values():
+        if item.dbname.upper() in tdb.tdenv.ignore:
+            continue
+        cur = tdb.query("""
+            SELECT price
+              FROM {}
+             WHERE item_id = ?
+               AND price > 0
+        """.format(table), [item.ID])
+        prices = [ row[0] for row in cur ]
+        if not prices:
+            if tdb.tdenv.detail:
+                tdb.tdenv.NOTE("{}: Zero entries", item.dbname)
+            continue
+        prices.sort()
+        numPrices = len(prices)
+        if numPrices < 20:
+            tdb.tdenv.NOTE("{}: only {} rows", item.dbname, numPrices)
+            continue
+        
+        lowPos = int(numPrices * lowP)
+        midPos = int(numPrices * 0.5)
+        highPos = int(numPrices * highP)
+        
+        low = prices[lowPos]
+        mid = prices[midPos]
+        high = prices[highPos]
+        
+        avg = int(sum(prices) / numPrices)
+        midlist = prices[lowPos:highPos]
+        midavg = int(sum(midlist) / len(midlist))
+        
+        # project the line from p50->p5 to predict
+        # what we would expect p0 to be.
+        # prices under 11 are invalid anyway
+        bestMid = max(mid, avg)
+        leastMid = min(mid, avg)
+        lowCutoff = max(int(leastMid - (bestMid - low) * multiplier), 0)
+        highCutoff = int(bestMid + (high - leastMid) * multiplier)
+        
+        if prices[0] < 11:
+            alert = colorama.Fore.RED
+            comp, cutoff, error = '<', 11, 'DUMB'
+        elif prices[0] < lowCutoff:
+            alert = colorama.Fore.YELLOW
+            comp, cutoff, error = '<', lowCutoff, 'LOW'
+        elif prices[-1] > 100 and prices[-1] > highCutoff:
+            alert = colorama.Fore.CYAN
+            comp, cutoff, error = '>', highCutoff, 'HIGH'
+        else:
+            continue
+        
+        if errorFilter and error != errorFilter:
+            continue
+        
+        count = remediation(item, comp, cutoff)
+        print(
+            alert,
+            mask.format(
+                numPrices,
+                item.dbname,
+                prices[0],
+                lowCutoff,
+                low, 
+                mid,
+                avg,
+                midavg,
+                high,
+                highCutoff,
+                prices[-1],
+                '{:<4s} {:>4n}'.format(error, count),
+            ),
+            colorama.Fore.RESET,
+            sep="",
+        )
+    
+    if stations:
+        print()
+        print("Generating", deletePrices)
+        now = tdb.query("SELECT CURRENT_TIMESTAMP").fetchone()[0]
+        with open(deletePrices, "w", encoding="utf-8") as fh:
+            print("# Deletions based on {} prices".format(
+                table,
+            ), file=fh)
+            for stnID, items in stations.items():
+                station = tdb.stationByID[stnID]
+                print(file=fh)
+                print("@ {}".format(station.name()), file=fh)
+                for item in items:
+                    itemID = item[0]
+                    print("      {:<30} {:>7} {:>7} {:>9} {:>9} {}  # was {} {}"
+                        .format(
+                            tdb.itemByID[itemID].name(),
+                            0, 0,
+                            '-', '-',
+                            now,
+                            item[1], item[2],
+                        ), file=fh
+                    )
+        if doDeletions:
+            db = tdb.getDB()
+        print("Generating", deleteSql)
+        with open(deleteSql, "w", encoding="utf-8") as fh:
+            for deletion in deletions:
+                print(deletion[0], '; --', deletion[1], file=fh)
+                if doDeletions:
+                    db.execute(deletion[0])
+            if doDeletions:
+                db.commit()
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Check for prices that are outside reasonable bounds.'
+    )
+    parser.add_argument(
+        '--percentile',
+        help='Set cutoff percentile',
+        type=float,
+        default=2,
+    )
+    parser.add_argument(
+        '--selling',
+        help='Check the StationSelling table instead of StationBuying',
+        action='store_true',
+    )
+    parser.add_argument(
+        '--delete',
+        help='Remove bad elements from the local .db immediately',
+        action='store_true',
+        default=False,
+    )
+    parser.add_argument(
+        '--db',
+        help='Specify location of the SQLite database.',
+        default=None,
+        dest='dbFilename',
+        type=str,
+    )
+    parser.add_argument(
+        '--debug', '-w',
+        help='Enable/raise level of diagnostic output.',
+        default=0,
+        required=False,
+        action='count',
+    )
+    parser.add_argument(
+        '--detail', '-v',
+        help='Increase level  of detail in output.',
+        default=0,
+        required=False,
+        action='count',
+    )
+    parser.add_argument(
+        '--quiet', '-q',
+        help='Reduce level of detail in output.',
+        default=0,
+        required=False,
+        action='count',
+    )
+    parser.add_argument(
+        '--margin',
+        help='Adjust the error margin.',
+        type=int,
+        default=25,
+    )
+    parser.add_argument(
+        '--ignore',
+        help='Ignore items.',
+        action='append',
+        default=[],
+    )
+    
+    filters = parser.add_mutually_exclusive_group()
+    filters.add_argument(
+        '--dumb',
+        help='Limit to "DUMB" items (<11cr).',
+        dest='filters',
+        action='store_const',
+        const='DUMB',
+    )
+    filters.add_argument(
+        '--high',
+        help='Limit to "HIGH" items.',
+        dest='filters',
+        action='store_const',
+        const='HIGH',
+    )
+    filters.add_argument(
+        '--low',
+        help='Limit to "LOW" items.',
+        dest='filters',
+        action='store_const',
+        const='LOW',
+    )
+    
+    argv = parser.parse_args(sys.argv[1:])
+    argv.ignore = [
+        ignore.upper() for ignore in argv.ignore
+    ]
+    
+    table = "StationSelling" if argv.selling else "StationBuying"
+    tdenv = tradeenv.TradeEnv(properties=argv)
+    tdb = tradedb.TradeDB(tdenv)
+    
+    tdenv.NOTE(
+        "Checking {}, margin={}", table, argv.margin,
+    )
+    
+    errorFilter = getattr(argv, "filters", None)
+    check_price_bounds(
+        tdb,
+        table,
+        margin=argv.margin,
+        doDeletions=argv.delete,
+        percentile=argv.percentile,
+        errorFilter=errorFilter,
+    )
+
+
+if __name__ == "__main__":
+    main()

tradedangerous/misc/clipboard.py

@@ -0,0 +1,49 @@
+"""
+Wrapper for trade-dangerous clipboard functionality.
+"""
+
+import os
+
+if 'NOTK' not in os.environ:
+    try:
+        from tkinter import Tk
+        
+        class SystemNameClip:
+            """
+            A cross-platform wrapper for copying system names into
+            the clipboard such that they can be pasted into the E:D
+            galaxy search - which means forcing them into lower case
+            because E:D's search doesn't work with upper case
+            characters.
+            """
+            
+            def __init__(self):
+                self.tkroot = Tk()
+                self.tkroot.withdraw()
+            
+            def strip(self, text, trailing):
+                if text.endswith(trailing):
+                    text = text[:-len(trailing)].strip()
+                return text
+            
+            def copy_text(self, text):
+                """ Copies the specified text into the clipboard. """
+                text = text.lower().strip()
+                text = self.strip(text, "(fix)")
+                text = self.strip(text, "(fixed)")
+                self.tkroot.clipboard_clear()
+                self.tkroot.clipboard_append(text.lower())
+    
+    except ImportError:
+        print(
+                "WARNING: This feature expects you to have 'tkinter' package "
+                "installed to work. It is either not installed or broken.\n"
+                "Set the environment variable 'NOTK' to disable this warning."
+        )
+        
+        class SystemNameClip:
+            """
+            Dummy implementation when tkinter is not available.
+            """
+            def copy_text(self, text):
+                pass

tradedangerous/misc/coord64.py

@@ -0,0 +1,83 @@
+# Coordinate ID generator:
+# Takes a set of 3d coordinates (x, y, z), truncates to 2dp and then
+# generates a base64-like(*) representation that can be used as an id
+# for the object.
+#
+# The actual encoding is not base64, since base64 contains characters
+# that present a problem when used, e.g, in URIs. I replaced the '+'
+# and '/' characters with '_' and '.' respectively.
+#
+# Example usage:
+#   coord_to_id64(51.5625, 32.1875, -27.125)
+# Generates:
+#   "1gA:Oi:-Go"
+#
+# A reversing function is also provided.
+#
+# Original Author: Oliver "kfsone" Smith <oliver@kfs.org>
+# Released under the "use it with attribution" license.
+
+import string
+
+
+alphabet = string.digits + string.ascii_lowercase + string.ascii_uppercase + '_.'
+precision = 100.
+
+
+def coord_to_d64(coord):
+    i = int(abs(coord * precision))
+    
+    digits = ""
+    while True:
+        digits = alphabet[i & 63] + digits
+        i >>= 6   # divides by 64, or one digit
+        if i == 0:
+            break
+    
+    sign = '-' if coord < 0 else ''
+    return sign + digits
+
+
+def d64_to_coord(d64):
+    divisor, digits = precision, d64
+    if d64.startswith('-'):
+        divisor = -divisor
+        digits = digits[1:]
+    
+    number = 0
+    for digit in digits:
+        value = alphabet.find(digit)
+        if value < 0:
+            raise ValueError("Invalid d64 value: {}".format(value))
+        number = (number * 64) + value
+    
+    return number / divisor
+
+
+def pos_to_id64(x, y, z):
+    return coord_to_d64(x) + ':' + coord_to_d64(y) + ':' + coord_to_d64(z)
+
+
+def id64_to_pos(id64):
+    (x64, y64, z64) = id64.split(':')
+    return (d64_to_coord(x64), d64_to_coord(y64), d64_to_coord(z64))
+
+
+if __name__ == "__main__":
+    test1 = ( 51.5625,32.1875,-27.125 )
+    test2 = ( -154.65625,40.34375,-82.78125 )
+    
+    id64 = pos_to_id64(test1[0], test1[1], test1[2])
+    print("id64 of {} = {}".format(test1, id64))
+    pos = id64_to_pos(id64)
+    print("pos of {} = {}".format(id64, pos))
+    
+    id64 = pos_to_id64(test1[0], test1[1], test1[2])
+    print("id64 of {} = {}".format(test1, id64))
+    pos = id64_to_pos(id64)
+    print("pos of {} = {}".format(id64, pos))
+    
+    id64 = pos_to_id64(test2[0], test2[1], test2[2])
+    print("id64 of {} = {}".format(test2, id64))
+    pos = id64_to_pos(id64)
+    print("pos of {} = {}".format(id64, pos))

tradedangerous/misc/csvdialect.py

@@ -0,0 +1,57 @@
+import csv
+
+
+class CSVDialect:
+    """
+    Defines the TDCSVDialect class for fine-tuning CSV parsing.
+    
+    Python's CSV parser uses an Excel dialect for CSV parsing which
+    seems to introduce some needless overhead parsing our simpler,
+    standard format.
+    
+    Providing the correct defaults trims away a little inefficiency,
+    but it may also protect us against any opinionated future
+    changes to the python defaults.
+    
+    In particular, the current approach causes the CSV parser to
+    produce quoted strings with their quotes intact:
+        
+        csv.reader("'hello'")
+            -> "'hello'"
+        csv.reader("'hello'", dialect=CSVDialect)
+            -> "hello"
+    
+    Use:
+        
+        import csv
+        from tradedangerous.misc.csvdialect import CSVDialect
+        
+        old_style = csv.reader(open("data/System.csv", encoding="utf-8"))
+        new_style = csv.reader(open("data/System.csv", encoding="utf-8"),
+                               dialect=CSVDialect)
+        
+        print("headers:")
+        print("- old:", next(old_style))
+        print("- new:", next(new_style))  # no difference
+        
+        for i, (old, new) in enumerate(zip(old_style, new_style)):
+            print(f"{i}: ids={old[0]},{new[0]}; names={old[1]},{new[1]}")
+            if i >= 5:
+                break
+    """
+    # comma separator, not tab - it's what the 'c' stands for, damnit Excel.
+    delimiter = ","
+    # single-quote for non-numeric values
+    quotechar = "'"
+    # The only escape we support is '' within a quoted string for a literal single-quote
+    # ... they term that ... *drum roll* double quote.
+    escapechar = None
+    doublequote = True  # ... I'm not making this up
+    # Unix-style line endings, no old-mac LFCR and no old-dos CRLF please.
+    lineterminator = "\n"
+    # No whitespace chasing
+    skipinitialspace = False
+    # We actually expect all non-numerics to be quoted, such as the empty string,
+    # but we're happy to tolerate less. Also, if we use the slightly more aggressive
+    # quoting, it requires floats to be quoted ... which seems insane.
+    quoting = csv.QUOTE_MINIMAL

tradedangerous/misc/derp-sentinel.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+
+import tradedb
+tdb = tradedb.TradeDB()
+
+names = set()
+
+for sys in tdb.systemByID.values():
+    for stn in sys.stations:
+        names.add(stn.name().upper())
+
+mutators = {
+        'D': [ 'O', '0', ],
+        'W': [ 'VV', ],
+        'R': [ 'IT' ],
+        'L': [ 'II' ],
+        '&': [ '6' ],
+}
+
+def mutate(text, pos):
+    for i in range(pos, len(text)):
+        char = text[i]
+        if char not in mutators:
+            continue
+        bef, aft = text[:i], text[i+1:]
+        for mutant in mutators[char]:
+            t2 = bef + mutant + aft
+            yield t2
+            yield from mutate(str(t2), i+len(mutant))
+
+
+for name in names:
+    for mutant in mutate(name, 0):
+        if mutant in names:
+            print("{} <-> {}".format(name, mutant))