tradedangerous 12.7.6__py3-none-any.whl

tradedangerous/misc/edsc.py

@@ -0,0 +1,437 @@
+#! /usr/bin/env python3
+
+from collections import namedtuple
+from urllib.request import Request, urlopen
+
+import json
+import requests
+
+
+def edsc_log(apiCall, params, jsonData=None, error=None):
+    """
+    Logs an EDSC query and it's response to tmp/edsc.log
+    """
+    try:
+        with open("tmp/edsc.log", "a", encoding="utf-8") as fh:
+            print('-'*70, file=fh)
+            print("API:", apiCall, file=fh)
+            print("REQ:", str(params), file=fh)
+            if jsonData:
+                print("REP:", json.dumps(jsonData, indent=1), file=fh)
+            if error:
+                print("ERR:", error)
+            print(file=fh)
+    except FileNotFoundError:
+        pass
+
+
+class EDSCQueryBase:
+    """
+    Base class for creating an EDSC Query class, do not use directly.
+    
+    Derived class must declare "apiCall" which is appended to baseURL
+    to form the query URL.
+    """
+    
+    baseURL = "http://edstarcoordinator.com/api.asmx/"
+    
+    def __init__(self, detail=2, test=False, known=1, confidence=0, **kwargs):
+        self.url = self.baseURL + self.apiCall
+        self.params = {
+            'data': {
+                'ver': 2,
+                'test': test,
+                'outputmode': detail,
+                'filter':  {
+                    'knownstatus': known,
+                    'cr': confidence,
+                }
+            }
+        }
+        for k, v in kwargs.items():
+            self.params['data']['filter'][k] = v
+        
+        self.jsData = None
+
+
+    def fetch(self):
+        params = json.dumps(self.params).encode('utf-8')
+        request = Request(self.url, params, {
+                    'Content-Type': 'application/json;charset=utf-8',
+                    'Content-Length': len(params)
+                })
+        
+        with urlopen(request, params) as stream:
+            self.jsData = stream.read()
+        
+        data = json.loads(self.jsData.decode())['d']
+        inputNo = 0
+        self.status = data['status']['input'][inputNo]['status']
+        
+        edsc_log(self.apiCall, self.params, data)
+        
+        return data
+
+
+class StarQuery(EDSCQueryBase):
+    """
+    Query EDSC Systems.
+    """
+    apiCall = "GetSystems"
+
+
+class DistanceQuery(EDSCQueryBase):
+    """
+    Request distances from EDSC.
+    """
+    apiCall = "GetDistances"
+
+
+class SubmissionError(Exception):
+    pass
+
+
+class Status(namedtuple('Status', [
+        'source', 'code', 'msg', 'lhs', 'rhs'
+        ])):
+    pass
+
+class StarSubmissionResult:
+    """
+    Translates a response the json we get back from EDSC when
+    we submit a StarSubmission into something less awful to
+    work with.
+    
+    Attributes:
+        valid
+            True or False whether the response looked healthy
+        
+        summary
+            A summary of the /parse/; currently either "No Data"
+            or "OK". This does NOT represent whether the
+            submission itself was successful.
+        
+        systems
+            A dict{ system name: [msgnum, coords] } for systems which
+            were reported as being added or updated. See
+            translateCode for converting these to text.
+            'coords' is either None if the system hasn't been
+            trilaterated yet, or an array of [x,y,z]
+        
+        distances
+            A dict{ lhs system: { rhs system: dist } }. It's not
+            really very useful but I didn't want to drop the data
+            EDSC was sending back to us, just incase.
+        
+        errors
+            A list of SubmissionError objects describing problems
+            that were encountered, mostly 304 (distance added but
+            failed to verify coordinates) and 305 (distance appears
+            to be wrong).
+        
+        recheck
+            A dict{ system name: dist } for systems that had a 305
+            error for a distance to "star". They still appear in
+            the 'errors' attribute, but this is a short-cut for
+            prompting the user to double check a distance from their
+            current p0.
+    
+    """
+    
+    codeMap = {
+        201:        "New Entry",
+        202:        "System CR increased",
+        203:        "Coordinates calculated",
+        301:        "Distance added",
+        302:        "Distance CR increased",
+        303:        "Added verification",
+        304:        "OK: Needs more data",
+        305:        "Distance appears to be wrong",
+        401:        "CALCULATED",
+        402:        "No solution found, more data needed"
+    }
+
+
+    def __init__(self, star, response):
+        self.star = star
+        self.valid = False
+        self.summary = "No Data"
+        self.systems = {}
+        self.distances = {}
+        self.errors = []
+        self.recheck = {}
+        
+        # This line righ there, this is just the beginning of
+        # why it's necessary to have this complicated of a
+        # wrapper for this json data. Don't forget, we have
+        # already peeled off some layers of json around this.
+        summary = response['status']['input'][0]['status']
+        code, msg = int(summary['statusnum']), summary['msg']
+        if code != 0:
+            self.valid = False
+            self.summary = "Error #{}: {}".format(code, msg)
+            self.errors.append(Status(
+                    'status', code, msg, None, None
+            ))
+            return
+        
+        self.valid = True
+        self.summary = "OK"
+        
+        # We get back an array of things called 'system', which
+        # allows EDSC to tell us that something got added. It
+        # could be p0 or it could be one of the refs or it could
+        # be something that was sitting in EDSCs distances buffer.
+        sysArray = response['status']['system']
+        for ent in sysArray:
+            sysName = ent['system'].upper()
+            code = int(ent['status']['statusnum'])
+            msg = ent['status']['msg']
+            if code in [201, 202, 203]:
+                self.systems[sysName] = (code, None)
+            else:
+                self.errors.append(Status(
+                        'system', code, msg, sysName, None,
+                ))
+        
+        # Now the pair-wise distance checks. These are either not
+        # very useful/duplicate the systems list, or they tell us
+        # about conflicts with pre-existing data.
+        # Pairs which generate 305 (distance wrong) that relate
+        # to P0 will be added to "recheck" so that the caller can
+        # ask their user to provide sanity values.
+        distArray = response['status']['dist']
+        errPairs = set()
+        for ent in distArray:
+            lhsName = ent['system1'].upper()
+            rhsName = ent['system2'].upper()
+            code = int(ent['status']['statusnum'])
+            msg = ent['status']['msg']
+            if code in [301, 302, 303, 304]:
+                if lhsName not in self.distances:
+                    self.distances[lhsName] = {}
+                try:
+                    rhsDists = self.distances[rhsName]
+                    if lhsName in rhsDists:
+                        continue
+                except KeyError:
+                    pass
+                dist = float(ent['dist'])
+                self.distances[lhsName][rhsName] = dist
+                if lhsName not in self.systems:
+                    self.systems[lhsName] = (code, None)
+            else:
+                if (lhsName,rhsName,code) in errPairs:
+                    continue
+                if (rhsName,lhsName,code) in errPairs:
+                    continue
+                errPairs.add((lhsName,rhsName,code))
+                errPairs.add((rhsName,lhsName,code))
+                self.errors.append(Status(
+                        'dist', code, msg, lhsName, rhsName,
+                ))
+                if code == 305:
+                    if lhsName == star:
+                        self.recheck[rhsName] = ent['dist']
+                    elif rhsName == star:
+                        self.recheck[lhsName] = ent['dist']
+        
+        # Finally we look thru the trilat array which is telling us
+        # how the search for p0's coordinates went on a per-ref
+        # basis.
+        #
+        # Successful trilateration will result in an array of
+        # trilats that contain code 401 and the coordinates of
+        # p0, one per ref. Since we can't tell what the *other*
+        # system is, this is a bit stupid. Probably a bug in edsc.
+        triArray = response['status']['trilat']
+        for ent in triArray:
+            sysName = ent['system'].upper()
+            code = int(ent['status']['statusnum'])
+            if code == 401:
+                try:
+                    system = self.systems[sysName]
+                    if system[1] is not None:
+                        continue
+                except KeyError:
+                    system = (code, None)
+                assert system[1] is None
+                coord = ent['coord']
+                x, y, z = coord['x'], coord['y'], coord['z']
+                self.systems[sysName] = (system[0], [x,y,z])
+            elif code == 402:
+                pass
+            else:
+                self.errors.append(Status(
+                        'trilat', code, msg, sysName, None,
+                ))
+
+
+    def __str__(self):
+        if not self.valid:
+            return "ERROR: {}".format(self.summary)
+        
+        text = ""
+        
+        if not self.errors:
+            text += "Success.\n"
+        
+        if self.systems:
+            text += "+Updates:\n"
+            sysNames = list(self.systems.keys())
+            sysNames.sort(key=lambda s: self.systems[s][0])
+            for sysName in sysNames:
+                code, coords = self.systems[sysName]
+                sysText = self.translateCode(code)
+                if coords is not None:
+                    sysText += str(coords)
+                text += "|- {:.<30s} {}\n".format(
+                    sysName, sysText,
+                )
+            text += "\n"
+        
+        if self.errors:
+            text += "+Problems:\n"
+            errors = sorted(self.errors, key=lambda e: e.rhs or "")
+            errors.sort(key=lambda e: e.lhs or "")
+            errors.sort(key=lambda e: e.code)
+            for err in errors:
+                text += "|- {:.<30s} #{} {}".format(
+                        err.lhs,
+                        err.code,
+                        self.translateCode(err.code),
+                )
+                if err.rhs:
+                    text += " <-> " + err.rhs
+                text += "\n"
+        
+        return text
+    
+    def translateCode(self, code):
+        try:
+            return self.codeMap[code]
+        except KeyError:
+            return "Error #{} (unknown)".format(code)
+
+
+
+class StarSubmission:
+    baseURL = "http://edstarcoordinator.com/api.asmx/"
+    apiCall = "SubmitDistances"
+    
+    def __init__(
+            self, star,
+            test=False, commander=None,
+            refs=None, distances=None,
+            ):
+        assert isinstance(star, str)
+        assert isinstance(test, bool)
+        if refs:
+            assert isinstance(refs, list)
+        self.test = test
+        self.name = star.upper()
+        self.refs = refs or []
+        if distances:
+            if isinstance(distances, list):
+                for name, dist in distances:
+                    self.add_distance(name, dist)
+            elif isinstance(distances, dict):
+                for name, dist in distances.items():
+                    self.add_distance(name, dist)
+            else:
+                raise SubmissionError("Invalid distances parameter")
+        if commander:
+            self.commander = commander
+    
+    def __repr__(self):
+        return (
+            "StarSubmission("
+                "test={}, star=\"{}\", commander=\"{}\", refs={}"
+            ")".format(
+                self.test,
+                self.name,
+                self.commander,
+                self.refs,
+            )
+        )
+
+
+    def add_distance(self, name, dist):
+        assert isinstance(name, str)
+        assert isinstance(dist, (float, int))
+        assert name.upper() != self.name
+        
+        name = name.upper()
+        for i, ref in enumerate(self.refs):
+            if ref['name'] == name:
+                ref['dist'] = dist
+                return
+        
+        self.refs.append({'name': name, 'dist': dist})
+
+
+    def submit(self):
+        assert len(self.refs) != 0
+        
+        headers = { 'Content-Type': 'application/json; charset=utf-8' }
+        data = {
+            'data': {
+                'test': self.test,
+                'ver': 2,
+                'p0': { 'name': self.name },
+                'refs': self.refs
+            },
+        }
+        if self.commander:
+            data['data']['commander'] = self.commander
+        
+        jsonData = json.dumps(data, indent=None, separators=(',', ':'))
+        
+        url = self.baseURL + self.apiCall
+        req = requests.post(
+            url,
+            headers=headers,
+            data=jsonData
+        )
+        resp = req.text
+        if not resp.startswith('{'):
+            edsc_log(self.apiCall, repr(self), error=resp)
+            raise SubmissionError("Server Side Error: " + resp)
+        
+        try:
+            respData = json.loads(resp)
+        except Exception:
+            edsc_log(self.apiCall, repr(self), error=resp)
+            raise SubmissionError("Invalid server response: " + resp)
+        edsc_log(self.apiCall, repr(self), respData)
+        try:
+            innerData = respData['d']
+        except KeyError:
+            raise SubmissionError("Server Error: " + resp)
+        
+        return innerData
+
+
+if __name__ == "__main__":
+    print("Requesting recent, non-test, coords-known, cr >= 2 stars")
+    edsq = StarQuery(test=False, confidence=2, known=1)
+    data = edsq.fetch()
+    
+    if edsq.status['statusnum'] != 0:
+        raise Exception("Query failed: {} ({})".format(
+                    edsq.status['msg'],
+                    edsq.status['statusnum'],
+                ))
+    
+    date = data['date']
+    systems = data['systems']
+    
+    for sysinfo in systems:
+        print("{:<30s} {:11f} {:11f} {:11f} {}".format(
+            sysinfo['name'].upper(),
+            sysinfo['coord'][0],
+            sysinfo['coord'][1],
+            sysinfo['coord'][2],
+            sysinfo['createdate'],
+        ))
+

tradedangerous/misc/edsm.py

@@ -0,0 +1,121 @@
+#! /usr/bin/env python
+
+"""
+based on edsc.py
+uses EDSM - https://www.edsm.net/api
+"""
+
+import json
+import requests
+
+
+def edsm_log(apiCall, url, params, jsonData=None, error=None):
+    """
+    Logs an EDSM query and it's response to tmp/edsm.log
+    """
+    try:
+        with open("tmp/edsm.log", "a", encoding="utf-8") as fh:
+            print('-'*70, file=fh)
+            print("API:", apiCall, file=fh)
+            print("REQ:", str(params), file=fh)
+            print("URL:", url, file=fh)
+            if jsonData:
+                print("REP:", json.dumps(jsonData, indent=1), file=fh)
+            if error:
+                print("ERR:", error)
+            print(file=fh)
+    except FileNotFoundError:
+        pass
+
+
+class EDSMQueryBase:
+    """
+    Base class for creating an EDSM Query class, do not use directly.
+    
+    Derived class must declare "apiCall" which is appended to baseURL
+    to form the query URL.
+    """
+    
+    baseURL = "https://www.edsm.net/api-v1/"
+    
+    def __init__(self, log=False, known=1, coords=1, **kwargs):
+        self.log = log
+        self.url = self.baseURL + self.apiCall
+        self.params = {
+            'known': known,
+            'coords': coords,
+        }
+        for k, v in kwargs.items():
+            self.params[k] = v
+    
+    def fetch(self):
+        res = requests.get(self.url, self.params)
+        self.status = res.status_code
+        
+        try:
+            data = res.json()
+        except:
+            data = None
+            pass
+        
+        if self.log:
+            edsm_log(self.apiCall, res.url, self.params, data)
+        
+        return data
+
+
+class StarQuerySingle(EDSMQueryBase):
+    """
+    Query EDSM System.
+    
+    provide:
+        systemName
+    """
+    apiCall = "system"
+
+class StarQueryMulti(EDSMQueryBase):
+    """
+    Query EDSM Systems.
+    
+    provide:
+        systemName
+    """
+    apiCall = "systems"
+
+class StarQuerySphere(EDSMQueryBase):
+    """
+    Query EDSM Systems.
+    provide:
+        systemName or center-coords as x, y and z
+        radius N.NN
+    """
+    apiCall = "sphere-systems"
+
+class DistanceQuery(EDSMQueryBase):
+    """
+    Request distances from EDSM.
+    """
+    apiCall = "distances"
+
+
+if __name__ == "__main__":
+    print("Requesting Azrael, coords-known")
+    edsq = StarQuerySingle(log=True, systemName="Azrael")
+    data = edsq.fetch()
+    print("{:<30s} {:11f} {:11f} {:11f}".format(
+        data['name'].upper(),
+        data['coords']['x'],
+        data['coords']['y'],
+        data['coords']['z'],
+    ))
+    
+    print("Requesting 10ly sphere of Sol, coords-known")
+    edsq = StarQuerySphere(systemName="Sol", radius=10)
+    data = edsq.fetch()
+    for sysinfo in data:
+        print("{:<30s} {:11f} {:11f} {:11f}".format(
+            sysinfo['name'].upper(),
+            sysinfo['coords']['x'],
+            sysinfo['coords']['y'],
+            sysinfo['coords']['z'],
+        ))

tradedangerous/misc/importeddbstats.py

@@ -0,0 +1,54 @@
+import csvexport
+import misc.eddb
+import tradedb
+
+# Build an ID=>Name mapping for EDDB systems
+tdb = tradedb.TradeDB()
+systems = {}
+tdSysLookup = tdb.systemByName.get
+for s in misc.eddb.SystemsQuery():
+    tdSys = tdSysLookup(s['name'].upper(), None)
+    if tdSys and tdSys.stations:
+        systems[s['id']] = { stn.dbname.upper(): stn for stn in tdSys.stations }
+
+def matching_stations():
+    # generator that searches the eddb station set for entries that
+    # match tdb entries and yields the tuple (tdStn, eddbStn)
+    
+    for eddbStn in misc.eddb.StationsQuery():
+        stationList = systems.get(eddbStn['system_id'], None)
+        if not stationList:
+            continue
+        name = eddbStn['name'].upper()
+        tdStn = stationList.get(name, None)
+        if tdStn:
+            yield tdStn, eddbStn
+
+
+updateStation = tdb.updateLocalStation
+
+bool_trans = { None: '?', 0: 'N', 1: 'Y' }
+
+updates = 0
+for tdStn, eddbStn in matching_stations():
+    mps = eddbStn['max_landing_pad_size'] or '?'
+    if updateStation(
+            station=tdStn,
+            lsFromStar=eddbStn['distance_to_star'],
+            maxPadSize=mps,
+            market=bool_trans[eddbStn['has_commodities']],
+            blackMarket=bool_trans[eddbStn['has_blackmarket']],
+            shipyard=bool_trans[eddbStn['has_shipyard']],
+            outfitting=bool_trans[eddbStn['has_outfitting']],
+            rearm=bool_trans[eddbStn['has_rearm']],
+            refuel=bool_trans[eddbStn['has_refuel']],
+            repair=bool_trans[eddbStn['has_repair']],
+            modified='now',
+            commit=False,
+            ):
+        updates += 1
+
+if updates:
+    tdb.getDB().commit()
+    csvexport.exportTableToFile(tdb, tdb.tdenv, "Station")
+    print("Updated Station.csv: {} updates".format(updates))