OWL ELO

import requests,random
from operator import itemgetter

class Team:
    def __init__(self, name, abbrev,maps):
        self.name=name
        self.abbrev=abbrev
        self.elo=1000
        self.maps = maps
        self.assaultdraws = 0
        self.assaultdrawable = 0
        self.hybriddraws = 0
        self.hybriddrawable = 0

def expected(A, B):
    return 1 / (1 + 10 ** ((B - A) / 400))
def elo(old, exp, score, k=24):
    return old + k * (score - exp)

control = ["0x08000000000007E2","0x080000000000066D","0x08000000000004B7"]
def tiebreakmap(mcmap):
    tiebreaks = []
    for cmap in control:
        if mcmap != cmap:
            tiebreaks.append(cmap)
    return random.choice(tiebreaks)
trials = 100000
def simulate(A, B, gamemaps):
    scorehist = {}
    for i in range(trials):
        score = (0,0)
        for map in gamemaps:

            if map in assault:
                if random.random() < (((float(A.assaultdraws)/A.assaultdrawable)+(float(B.assaultdraws)/B.assaultdrawable))/2):
                    continue
            if map in hybrid:
                if random.random() < (((float(A.hybriddraws)/A.hybriddrawable)+(float(B.hybriddraws)/B.hybriddrawable)/2)):
                    continue


            if random.random() < expected(A.maps[map],B.maps[map]):
                score = (score[0]+1,score[1])
            else:
                score = (score[0],score[1]+1)

        if score[0] == score[1]: # just in case of a (1,1) draw
            tiebreak = tiebreakmap(gamemaps[0])
            if random.random() < expected(A.maps[tiebreak],B.maps[tiebreak]):
                score = (score[0]+1,score[1])
            else:
                score = (score[0],score[1]+1)

        if score in scorehist.keys():
            scorehist[score] += 1
        else:
            scorehist[score] = 1

    return scorehist

def printhistogram(hist):
    for score in hist.keys():
        print("{0}-{1}: {2:.3f}".format(score[0],score[1],float(hist[score])/trials))




if __name__ == "__main__":
    teamresp = requests.get('https://api.overwatchleague.com/ranking')
    if teamresp.status_code != 200:
        raise ApiError('GET /ranking {}'.format(teamresp.status_code))
    mapresp = requests.get('https://api.overwatchleague.com/maps')
    if mapresp.status_code != 200:
        raise ApiError('GET /ranking {}'.format(mapresp.status_code))
    maps = {}
    assault = []
    hybrid = []
    for map in mapresp.json():
        maps[map['guid']]=map['name']['en_US']
        if map['type'] == "hybrid":
            hybrid.append(map['guid'])
        if map['type'] == "assault":
            assault.append(map['guid'])
    #print(hybrid,assault)
    #print(maps)
    #print(teamresp.json()['content'][0])
    teams = {}
    for team in teamresp.json()['content']:
        teammaps={}
        for map in maps.keys():
            teammaps[map] = 1000
        teams[team['competitor']['id']] = Team(team['competitor']['name'],team['competitor']['abbreviatedName'],teammaps)
    #for teamid in teams.keys():
        #print(teamid,teams[teamid].name)
    resp = requests.get('https://api.overwatchleague.com/schedule')
    if resp.status_code != 200:
        raise ApiError('GET /schedule {}'.format(resp.status_code))
    #print(resp.json()['data']['stages'][0]['matches'][0]['games'][0]['attributes']['mapGuid'])
    for match in resp.json()['data']['stages'][0]['matches']:
        if match['state'] != "CONCLUDED":
            break
        A = teams[match['competitors'][0]['id']]
        B = teams[match['competitors'][1]['id']]
        #print(A.name, "vs", B.name)
        for game in match['games']:
            exp = expected(A.elo,B.elo)
            gamemap = game['attributes']['mapGuid']
            mapexp = expected(A.maps[gamemap],B.maps[gamemap])
            #print("{0} vs {1} map {2} - {3} EV {4:.3f} map EV {5:.3f}".format(A.abbrev,B.abbrev,game['number'],maps[gamemap],exp,mapexp))

            assaultflag = False
            hybridflag = False
            if gamemap in assault:
                A.assaultdrawable += 1
                B.assaultdrawable += 1
                assaultflag = True
            if gamemap in hybrid:
                A.hybriddrawable += 1
                B.hybriddrawable += 1
                hybridflag = True

            points = game['points']
            if points[0] > points[1]:
                A.elo = elo(A.elo,exp,1)
                A.maps[gamemap] = elo(A.maps[gamemap],mapexp,1)
                B.elo = elo(B.elo,1-exp,0)
                B.maps[gamemap] = elo(B.maps[gamemap],1-mapexp,0)
                #print("{0} wins, ELOs {1:.1f} {2:.1f} {3:.1f} {4:.1f}".format(A.abbrev,A.elo,B.elo,A.maps[gamemap],B.maps[gamemap]))
            elif points[0] < points[1]:
                A.elo = elo(A.elo,exp,0)
                A.maps[gamemap] = elo(A.maps[gamemap],mapexp,0)
                B.elo = elo(B.elo,1-exp,1)
                B.maps[gamemap] = elo(B.maps[gamemap],1-mapexp,1)
                #print("{0} wins, ELOs {1:.1f} {2:.1f} {3:.1f} {4:.1f}".format(B.abbrev,A.elo,B.elo,A.maps[gamemap],B.maps[gamemap]))
            else:
                A.elo = elo(A.elo,exp,0.5)
                A.maps[gamemap] = elo(A.maps[gamemap],mapexp,0.5)
                B.elo = elo(B.elo,1-exp,0.5)
                B.maps[gamemap] = elo(B.maps[gamemap],1-mapexp,0.5)
                #print("draw, ELOs {0:.1f} {1:.1f} {2:.1f} {3:.1f}".format(A.elo,B.elo,A.maps[gamemap],B.maps[gamemap]))
                if assaultflag:
                    A.assaultdraws += 1
                    B.assaultdraws += 1
                if hybridflag:
                    A.hybriddraws += 1
                    B.hybriddraws += 1
            #print()
    i=1
    predictions=4
    for match in resp.json()['data']['stages'][0]['matches']:
        if match['state'] == "CONCLUDED":
            continue
        A = teams[match['competitors'][0]['id']]
        B = teams[match['competitors'][1]['id']]
        print(A.name, "vs", B.name," - prediction EV ","{0:.3f}".format(expected(A.elo,B.elo)))
        print()
        gamemaps = []
        for game in match['games']:
            gamemap = game['attributes']['mapGuid']
            gamemaps.append(gamemap)
            mapexp = expected(A.maps[gamemap],B.maps[gamemap])
            print("{0} vs {1} map {2} - {3} map EV {4:.3f}".format(A.abbrev,B.abbrev,game['number'],maps[gamemap],mapexp))
            #if gamemap in hybrid:
                #print("Hybrid draw chance: {0} {1:.3f} {2} {3:.3f}".format(A.abbrev,float(A.hybriddraws)/A.hybriddrawable,B.abbrev,float(B.hybriddraws)/B.hybriddrawable))
            #if gamemap in assault:
                #print("Assault draw chance: {0} {1:.3f} {2} {3:.3f}".format(A.abbrev,float(A.assaultdraws)/A.assaultdrawable,B.abbrev,float(B.assaultdraws)/B.assaultdrawable))
            print()

        printhistogram(simulate(A,B,gamemaps))

        i+=1
        if i>predictions:
            break
        print()
        print()


    teamelos = {}
    for teamid in teams.keys():
        teamelos[teamid]=teams[teamid].elo
    i=1
    for key, value in sorted(teamelos.items(), key = itemgetter(1), reverse = True):
        print("{0}: {1} {2:.1f}".format(i,teams[key].name,value))
        i+=1