first release of V2, dynamic everything + refactor

edsmAround.py

@@ -1,105 +1,94 @@
 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!)
-name = "Cleeque"
+sectorName = "Cleeque"
+
+
+### "weights" to query, beware of big results when searching for lighter systems in more dense area
+weightsToQuery = ["h","g","f"]
 
 
 ### 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):
     systems = r.get("https://www.edsm.net/api-v1/systems", params={'systemName' : 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):
+    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'])
+    return systemList
 
-patternh = re.compile(".*[ABCDEFGYZ][ACELGGZ]-[AYDE] [h].*")
+#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
-patterng = re.compile(".*[ABCDEFGYZ][ACELGGZ]-[AYDE] [g].*")
+def maxSystemValue(systemList):
+    currentMax = 0
+    pattern = re.compile(f".*[A-Z][A-Z]-[A-Z] [A-Za-z]([0-9]+)")
+    for system in systemList:
+        val = 0
+        match = pattern.match(system)
+        val = int(match.group(1))
+        if val > currentMax:
+            currentMax = val
+    return currentMax
 
 
-listH = []
+#dict of dict of systems keyed by postfix, keyed by weight ( dict["AA-A"]["g"] gives back all the AA-A GXXX systems)
-listG = []
+sysWeightDict = {}
-lh = {}
-lmaxh = {}
-lg = {}
-lmaxg = {}
-lcandidates = {}
 
+#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 = {}
 
-#fetch sector + postfix data from edsm
+#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
-for p in postFixList:
+sysCandidates = {}
-    for s in json.loads(apiCall(name +" "+p).content):
 
-        if patternh.match(s['name']):
+#for each weight class, we initialize our dicts with our postfix list
-            #print(f"adding {s['name']} to list")
+for weight in weightsToQuery:
-            listH.append(s['name'])
+    sysWeightDict[weight] = {}
-        elif patterng.match(s['name']):
+    sysMaxDict[weight] = {}
-            #print(f"adding {s['name']} to list")
+    sysCandidates[weight] = {}
-            listG.append(s['name'])
 
-    # also prepare dictionnary for later
+    #then we populate our dicts with the provided postfix
 
-    lh[p] = []
+    for postfix in postFixList:
-    lmaxh[p] = 0
+        sysWeightDict[weight][postfix] = fetchEdsmSystems(sectorName, postfix, weight) # this is reversed from IG "AA-A G"
-    lg[p] = []
+        sysMaxDict[weight][postfix] = maxSystemValue(sysWeightDict[weight][postfix])
-    lmaxg[p] = 0
+
-    lcandidates[p] = []
+        #now we generate the inverse of the known system list
+
+        # for all systems indexes to the max known index
+        sysCandidates[weight][postfix] = []
+
+        for i in range(sysMaxDict[weight][postfix]):
+            candidate = f"{sectorName} {postfix} {weight}{i}"
+            if candidate not in sysWeightDict[weight][postfix]:
+                sysCandidates[weight][postfix].append(candidate)
 
 
 
-#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)
 
-#Same with G systems
+print("These are the systems known to EDSM")
-for s in listG:
+print(sysMaxDict)
-    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"{name}-RESULTS.json",'w') as f:
+with open(f"{floor(dt.now().timestamp())}-{sectorName}-RESULTS-v2.json",'w') as f:
-    f.write(json.dumps(lcandidates, indent=4))
+    f.write(json.dumps(sysCandidates, indent=4))