continue refactor

TrueSkillWrapper.py

@@ -10,6 +10,10 @@ updateLock  = threading.RLock()
 dirty_rounds = 0
 clean_rounds = 0
 
+#####################################################
+################ HANDLE RATING INPUT ################
+#####################################################
+
 def evaluate_round(r):
         global clean_rounds
         global dirty_rounds
@@ -31,47 +35,50 @@ def evaluate_round(r):
             updateLock.release()
 
 
-def rate_teams_simple(winner_team,loser_team,weights):
+def rate_teams_simple(winner_team, loser_team, weights=None):
         global clean_rounds
-        groups = [winner_team]+[loser_team]
+        groups = [winner_team] + [loser_team]
 
         if len(groups[1]) == 0 or len(groups[0]) ==0 :
             print("WARNING: Groups were {} - {} INCOMPLETE, SKIP".format(len(groups[0]),len(groups[1])))
             return False
+
         rated = env.rate(groups,weights=weights)
         StorrageBackend.sync_to_database(rated[0],True)
         StorrageBackend.sync_to_database(rated[1],False)
         clean_rounds += 1
         return True
 
-def quality(team1,team2, names1 = [""], names2 = [""]):
-    mu1 = sum(r.mu for r in team1)
-    mu2 = sum(r.mu for r in team2)
-    mu_tot = mu1 + mu2
-    sig1 = sum(r.sigma for r in team1)
-    sig2 = sum(r.sigma for r in team2)
-    sigtot = sig1 + sig2
+#####################################################
+################### LOCK/GETTER ####################
+#####################################################
 
-    names1 = list(map(lambda x: str(x.name), names1))
-    names2 = list(map(lambda x: str(x.name), names2))
+def lock():
+    updateLock.acquire()
 
-    diff = abs(mu1 - mu2)
-    percent = 50 + diff/mu_tot*100
-    if percent > 100:
-        percent = 100
+def unlock():
+    updateLock.release()
 
-    if mu1 > mu2:
-        string = "{} win at {:.2f}% - {:.2f} to {:.2f} Uncertainty: {:.2f}%".format(\
-                        ",".join(names1), \
-                        percent, mu1, mu2, sigtot/diff*100)
-    else:
-        string = "{} win at {:.2f}% - {:.2f} to {:.2f} Uncertainty: {:.2f}%".format(\
-                        ",".join(names2), \
-                        percent, mu2, mu1, sigtot/diff*100)
-    
-    return string
+def newRating(mu=None):
+    if mu:
+        return Rating(mu=mu, sigma=env.sigma)
+    return env.create_rating()
 
-def player_debug(sid,rated,groups):
+def getEnviroment():
+    return env
+
+
+def balance(players, buddies=None):
+        raise NotImplementedError()
+
+def get_player_rating(sid, name="NOTFOUND"):
+        raise NotImplementedError()
+
+#####################################################
+############### DEBUGGING FUNCTIONS #################
+#####################################################
+
+def playerDebug(sid,rated,groups):
         
         print("winner")
         for key in groups[0]:
@@ -98,41 +105,3 @@ def player_debug(sid,rated,groups):
                 print("Before: {}".format(groups[1][p]))
                 print("After:  {}".format(rated[1][p]))
         print("\n")
-        
-
-def balance(players, buddies=None):
-        if not players:
-            return ""
-        StorrageBackend.sync_from_database(players)
-        for p in players:
-            print(p, p.rating)
-        arr = sorted(players, key=lambda x: x.rating.mu, reverse=True)
-        ret=""
-        i = 0
-        while i < len(arr):
-            ret += "{}|{},".format(players[i].name,(i%2)+2)
-            i += 1
-        return ret
-
-def get_player_rating(sid, name="NOTFOUND"):
-        try:
-            p = StorrageBackend.known_players[sid]
-            tmp = int(env.expose(p.rating))
-            return "Rating of '{}' : {} (Rank: {})".format(p.name, tmp, StorrageBackend.get_player_rank(p))
-        except KeyError:
-            return "Rating of '{}' : No Rating (yet).".format(name)
-
-def lock():
-    updateLock.acquire()
-
-def unlock():
-    updateLock.release()
-
-def new_rating(mu=None):
-    if mu:
-        return Rating(mu=mu, sigma=env.sigma)
-    return env.create_rating()
-
-def get_env():
-    return env
-