ELOScript/writer.py at main · Gulvan0/ELOScript · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
from datetime import datetime
import json
from tabulate import tabulate
import playerinfoutils
from extractor import get_matchups

table_headers = ("#", "Player", "Rating", "Games", "Wins", "Losses", "Draws", "Score vs Runner-up")

def _export_filename():
    timestamp = str(datetime.today())
    timestamp = timestamp.split(".")[0]
    timestamp = timestamp.replace(" ", "_")
    timestamp = timestamp.replace(":", "-")
    return "rating_" + timestamp + ".txt"

def _get_str_rating(rating, total_games, calib_game_cnt):
  s = str(rating)
  if total_games < calib_game_cnt:
    s += " (?)"
  return s

def _get_str_personal_score(wins, losses, draws):
  return str(wins+draws/2)+"-"+str(losses+draws/2)

def _assemble_general_info(data):
  result = []
  for (name, playerdata) in data.items():
    if "hide" not in playerdata:
      playerinfo = {}
      playerinfo["name"] = name
      playerinfo["rating"] = playerdata["rating"]
      playerinfo["total_games_count"] = playerinfoutils.total_games(playerdata)
      playerinfo["win_count"] = playerdata["wins"]
      playerinfo["loss_count"] = playerdata["losses"]
      playerinfo["draw_count"] = playerdata["draws"]
      result.append(playerinfo)
  return result

def _enumerate_info(info):
  for index, playerinfo in enumerate(info):
    playerinfo["position"] = index + 1

def _convert_info_to_ratings(data, info, prefs):
  rating_rows = []
  for pinfo in info:
    stringified_rating = _get_str_rating(pinfo["rating"], pinfo["total_games_count"], prefs["calib_games"])
    if pinfo["position"] < len(info):
        runnerup_index = pinfo["position"] # as index = position - 1
        runnerup_login = info[runnerup_index]["name"]
        matchups_vs_runnerup = get_matchups(data, pinfo["name"], runnerup_login)[0]
        score_vs_runnerup =  _get_str_personal_score(matchups_vs_runnerup["w"], matchups_vs_runnerup["l"], matchups_vs_runnerup["d"])
    else:
        score_vs_runnerup = "Not applicable"
    row = [pinfo["position"], pinfo["name"], stringified_rating, pinfo["total_games_count"], pinfo["win_count"], pinfo["loss_count"], pinfo["draw_count"], score_vs_runnerup]
    rating_rows.append(row)
  return rating_rows

def _stringify(data, prefs):
  assembled_info = _assemble_general_info(data)
  assembled_info.sort(key = lambda playerinfo: playerinfo["rating"], reverse = True)
  _enumerate_info(assembled_info)

  rows = _convert_info_to_ratings(data, assembled_info, prefs)
  return tabulate(rows, headers = table_headers)

def print_table(data, prefs):
    print(_stringify(data, prefs))

def export_table(data, prefs):
    with open(_export_filename(), "w") as f:
        f.write(_stringify(data, prefs))

def print_matchups_of_player(data, player_login):
  playerinfo = data.get(player_login)
  if playerinfo == None:
    print("Player " + player_login + " not found, cancelling")
    return

  headers = ("Opponent", "Score", "Wins", "Losses", "Draws")
  rows = []
  for (opponent_login, matchups_vs_opponent) in playerinfo["matchups"].items():
    score_vs_opponent = _get_str_personal_score(matchups_vs_opponent["w"], matchups_vs_opponent["l"], matchups_vs_opponent["d"])
    row = [opponent_login, score_vs_opponent, matchups_vs_opponent["w"], matchups_vs_opponent["l"], matchups_vs_opponent["d"]]
    rows.append(row)
  print(tabulate(rows, headers))