edsmAround.py

@@ -1,25 +1,15 @@
 import requests as r
 import re
 import json
-from datetime import datetime as dt
-from math import floor
 
 #IMPORTANT BITS
 
 ###This is the name of the sector you want to search into (Do not use caps!)
-sectorName = "Phleedgaa"
-
-
-### "weights" to query, beware of big results when searching for lighter systems in more dense area
-weightsToQuery = ["a","b","c","d","e"]
-
-
-### postFix List, modify as needed
-#postFixList =["AA-A","BA-A","CL-Y","DL-Y","EG-Y","FG-Y","YE-A","ZE-A"]
-postFixList =["UJ-Q"]
-
+name = "Cleeque"
 
 
+### don't touch any of this. Or do, I'm a comment, not a cop.
+postFixList =["AA-A","BA-A","CL-Y","DL-Y","EG-Y","FG-Y","YE-A","ZE-A"]
 
 ###Call to EDSM API, don't run this script too much in a short timeframe.
 def apiCall(systemName):
@@ -27,94 +17,89 @@ def apiCall(systemName):
     return systems
 
 
-# takes a sector name, a postfix and a weight, returns list of known systems in EDSM matching that
-def fetchEdsmSystems(sectorName, postFix, weight):
-    hasMultipleHyphens = False
-    systemList = []
-    pattern = re.compile(f".*{postFix} {weight}.*")
-    for system in json.loads(apiCall(sectorName +" "+postFix).content):
-        if pattern.match(system['name']):
-            systemList.append(system['name'])
-        hasMultipleHyphens = system['name'].count("-") > 1 # if at least one of those has multiple hyphens, we consider all of them do
-    return systemList, hasMultipleHyphens
 
-#given a list of systems (assumed to be all the same weight and postfix) returns the maximum value of the integer value in the system name for that list
-def maxSystemValue(systemList):
-    currentMax = 0
-    patternWithoutHyphen = re.compile(f".*[A-Z][A-Z]-[A-Z] [A-Za-z]([0-9]+)")
-    patternWithHyphen = re.compile(f".*[A-Z][A-Z]-[A-Z] [A-Za-z][0-9]*-([0-9]+)")
-    for system in systemList:
-        val = 0
-
-        if system.count("-") > 1:
-            match = patternWithHyphen.match(system)
-        else:
-            match = patternWithoutHyphen.match(system)
-
-        val = int(match.group(1))
-        if val > currentMax:
-            currentMax = val
-    return currentMax
+patternh = re.compile(".*[ABCDEFGYZ][ACELGGZ]-[AYDE] [h].*")
+patterng = re.compile(".*[ABCDEFGYZ][ACELGGZ]-[AYDE] [g].*")
 
 
-#dict of dict of systems keyed by postfix, keyed by weight ( dict["AA-A"]["g"] gives back all the AA-A GXXX systems)
-sysWeightDict = {}
-
-#dict of dict of systems maximum value by postfix, keyed by weight ( dict["AA-A"]["g"] gives back the maximum recorded value for X where X is the integer in a system name : AA-A GX)
-sysMaxDict = {}
-
-postFixWithMultipleHyphens = {} # deals with system names like "Sector AA-A e5-8"
-
-#dict of dict of all the systems in a sector keyed by postfix, keyed by weight, used later for substracting EDSM values from ALL systems
-sysCandidates = {}
+listH = []
+listG = []
+lh = {}
+lmaxh = {}
+lg = {}
+lmaxg = {}
+lcandidates = {}
 
 
-base = ""
-reference = ""
+#fetch sector + postfix data from edsm
+for p in postFixList:
+    for s in json.loads(apiCall(name +" "+p).content):
 
+        if patternh.match(s['name']):
+            #print(f"adding {s['name']} to list")
+            listH.append(s['name'])
+        elif patterng.match(s['name']):
+            #print(f"adding {s['name']} to list")
+            listG.append(s['name'])
 
-#for each weight class, we initialize our dicts with our postfix list
-for weight in weightsToQuery:
-    sysWeightDict[weight] = {}
-    sysMaxDict[weight] = {}
-    sysCandidates[weight] = {}
-    postFixWithMultipleHyphens[weight] = {}
+    # also prepare dictionnary for later
 
-    #then we populate our dicts with the provided postfix
-
-    for postfix in postFixList:
-        sysWeightDict[weight][postfix], postFixWithMultipleHyphens[weight][postfix] = fetchEdsmSystems(sectorName, postfix, weight) # this is reversed from IG "AA-A G"
-        sysMaxDict[weight][postfix] = maxSystemValue(sysWeightDict[weight][postfix])
-
-        #now we generate the inverse of the known system list
-
-        # for all systems indexes to the max known index
-        sysCandidates[weight][postfix] = []
-
-        if len(sysWeightDict[weight][postfix]) > 0:
-
-            if postFixWithMultipleHyphens[weight][postfix]: #if we have multiple hyphens we take the first system to see what's in front of the hyphen
-                reference = sysWeightDict[weight][postfix][0]
-                base = reference[:reference.rfind("-")+1]
-                print(f"Warning, sector {sectorName} {postfix} has multiple hyphens, predictions may be wrong!")
-            else:
-                base =f"{sectorName} {postfix} {weight}"
-
-            for i in range(sysMaxDict[weight][postfix]):
-                candidate = f"{base}{i}"
-                if candidate not in sysWeightDict[weight][postfix]:
-                    sysCandidates[weight][postfix].append(candidate)
+    lh[p] = []
+    lmaxh[p] = 0
+    lg[p] = []
+    lmaxg[p] = 0
+    lcandidates[p] = []
 
 
 
+#Sorting H systems into postfix dict entries
+for s in listH:
+    for pre in postFixList:
+        if pre in s:
+            length = len(f"{name} {pre} h") ##TODO replace this bullshit
+            cur = int(s[length:])
+            if cur > lmaxh[pre]:
+                lmaxh[pre] = cur
+            lh[pre].append(s)
 
-print("These are the systems known to EDSM")
-print(sysMaxDict)
+#Same with G systems
+for s in listG:
+    for pre in postFixList:
+        if pre in s:
+            length = len(f"{name} {pre} g")
+            cur = int(s[length:])
+            if cur > lmaxg[pre]:
+                lmaxg[pre] = cur
+            lg[pre].append(s)
 
 
+print("These are the H sized systems known to EDSM")
+print(lmaxh)
+
+print("These are the G sized systems known to EDSM")
+print(lmaxg)
+
+#generate all the systems for H and adds it to the candidate dict only if its not on EDSM
+
+for i in postFixList:
+    maxi = lmaxh[i]
+    for j in range(maxi):
+        sys = f"{name} {i} h{j}"
+        if sys not in lh[i]:
+            lcandidates[i].append(sys)
+
+#same for G systems
+
+for i in postFixList:
+    maxi = lmaxg[i]
+    for j in range(maxi):
+        sys = f"{name} {i} g{j}"
+        if sys not in lg[i]:
+            lcandidates[i].append(sys)
+
 #Finally writes the results to a JSON file.
-with open(f"{floor(dt.now().timestamp())}-{sectorName}-RESULTS-v2.json",'w') as f:
-    f.write(json.dumps(sysCandidates, indent=4))
+with open(f"{name}-RESULTS.json",'w') as f:
+    f.write(json.dumps(lcandidates, indent=4))