class SmallMatchListTest(TestCase):
def setUp(self):
self.matchlist = MatchList(getInfoGetter(True), 'l am eternal', 5)
def testAvgBarons(self):
self.assertEqual(.4, self.matchlist.avgBarons())
def testMatchlistOnlyHas5Matches(self):
self.assertEqual(5, len(self.matchlist.matches))
def testPctAllElemental(self):
self.assertEqual(self.matchlist.pctAllElemental(), 7 / (8 + 7) * 100)
def testPctAllElder(self):
self.assertTrue(math.isnan(self.matchlist.pctAllElders()))
def testPctDragonsKilledByType(self):
self.assertEqual(
self.matchlist.pctDragonsKilledByType(), {
Dragon.AIR: 200 / 7,
Dragon.FIRE: 100 / 7,
Dragon.EARTH: 300 / 7,
Dragon.WATER: 100 / 7,
Dragon.ELDER: 0
})
def testPctEachDragonType(self):
pctDragonsOfEachTypeKIlled = self.matchlist.pctEachDragonType()
dTypes = {
Dragon.AIR: 200 / 5,
Dragon.FIRE: 100 / 4,
Dragon.EARTH: 300 / 5,
Dragon.WATER: 100,
Dragon.ELDER: float('NaN'),
}
for k, v in pctDragonsOfEachTypeKIlled.items():
if k == Dragon.ELDER:
self.assertTrue(math.isnan(v))
else:
self.assertEqual(dTypes[k], v)
def testPctElementatKilledByOrder(self):
self.assertEqual(self.matchlist.pctElementalKilledByOrder(),
[40.0, 75.0, 25.0, 0.0, 100.0])
def testPctElderKilledByOrderIsEmpty(self):
self.assertEqual(self.matchlist.pctElderKilledByOrder(), [])
def testAvgFirstDragonTime(self):
firstDragon = self.matchlist.firstElementalDragonTime()
self.assertEqual(firstDragon.seconds, 493)
def testTimePercentEnemyContDragons(self):
result = self.matchlist.timePercentEnemyContestedElementalDragons()
self.assertEqual(result[0].seconds, 384)
self.assertEqual(result[1], 40)
def testTimePercentEnemyB2BDragons(self):
result = self.matchlist.timePercentEnemyBackToBackElementalDragons()
self.assertEqual(result[0].seconds, 426)
self.assertEqual(result[1], 60)
def testTimePercentContDragons(self):
result = self.matchlist.timePercentContestedElementalDragons()
self.assertEqual(result[0].seconds, 416)
self.assertEqual(result[1], 40)
def testTimePercentB2BDragons(self):
result = self.matchlist.timePercentBackToBackElementalDragons()
self.assertEqual(result[0].seconds, 437)
self.assertEqual(result[1], 60)
def testTowersKilledInLosses(self):
result = self.matchlist.towersKilledInLosses()
self.assertEqual(result[('OUTER_TURRET', 'TOP_LANE')][1].seconds, 963)
self.assertEqual(result[('OUTER_TURRET', 'TOP_LANE')][0],
33.333333333333336)
self.assertEqual(result[('OUTER_TURRET', 'MID_LANE')][1].seconds, 1241)
self.assertEqual(result[('OUTER_TURRET', 'MID_LANE')][0],
33.333333333333336)
self.assertEqual(result[('OUTER_TURRET', 'BOT_LANE')][1].seconds, 1282)
self.assertEqual(result[('OUTER_TURRET', 'BOT_LANE')][0],
33.333333333333336)
self.assertEqual(result[('INNER_TURRET', 'BOT_LANE')][1].seconds, 1306)
self.assertEqual(result[('INNER_TURRET', 'BOT_LANE')][0],
33.333333333333336)
self.assertEqual(result[('INNER_TURRET', 'MID_LANE')][1].seconds, 0)
self.assertEqual(result[('INNER_TURRET', 'MID_LANE')][0], 0.0)
self.assertEqual(result[('INNER_TURRET', 'TOP_LANE')][1].seconds, 0)
self.assertEqual(result[('INNER_TURRET', 'TOP_LANE')][0], 0.0)
self.assertEqual(result[('BASE_TURRET', 'MID_LANE')][1].seconds, 0)
self.assertEqual(result[('BASE_TURRET', 'MID_LANE')][0], 0.0)
self.assertEqual(result[('BASE_TURRET', 'BOT_LANE')][1].seconds, 0)
self.assertEqual(result[('BASE_TURRET', 'BOT_LANE')][0], 0.0)
self.assertEqual(result[('BASE_TURRET', 'TOP_LANE')][1].seconds, 0)
self.assertEqual(result[('BASE_TURRET', 'TOP_LANE')][0], 0.0)
self.assertEqual(result[('NEXUS_TURRET', 'MID_LANE')][1].seconds, 0)
self.assertEqual(result[('NEXUS_TURRET', 'MID_LANE')][0], 0.0)
def testTowersKilledInWins(self):
result = self.matchlist.towersKilledInWins()
self.assertEqual(result[('OUTER_TURRET', 'MID_LANE')][1].seconds, 903)
self.assertEqual(result[('OUTER_TURRET', 'MID_LANE')][0], 100.0)
self.assertEqual(result[('OUTER_TURRET', 'BOT_LANE')][1].seconds, 941)
self.assertEqual(result[('OUTER_TURRET', 'BOT_LANE')][0], 100.0)
self.assertEqual(result[('INNER_TURRET', 'MID_LANE')][1].seconds, 1242)
self.assertEqual(result[('INNER_TURRET', 'MID_LANE')][0], 100.0)
self.assertEqual(result[('BASE_TURRET', 'MID_LANE')][1].seconds, 1505)
self.assertEqual(result[('BASE_TURRET', 'MID_LANE')][0], 100.0)
self.assertEqual(result[('OUTER_TURRET', 'TOP_LANE')][1].seconds, 1336)
self.assertEqual(result[('OUTER_TURRET', 'TOP_LANE')][0], 100.0)
self.assertEqual(result[('INNER_TURRET', 'BOT_LANE')][1].seconds, 1650)
self.assertEqual(result[('INNER_TURRET', 'BOT_LANE')][0], 100.0)
self.assertEqual(result[('NEXUS_TURRET', 'MID_LANE')][1].seconds, 2002)
self.assertEqual(result[('NEXUS_TURRET', 'MID_LANE')][0], 100.0)
self.assertEqual(result[('INNER_TURRET', 'TOP_LANE')][1].seconds, 1318)
self.assertEqual(result[('INNER_TURRET', 'TOP_LANE')][0], 50.0)
self.assertEqual(result[('BASE_TURRET', 'BOT_LANE')][1].seconds, 1460)
self.assertEqual(result[('BASE_TURRET', 'BOT_LANE')][0], 50.0)
self.assertEqual(result[('BASE_TURRET', 'TOP_LANE')][1].seconds, 0)
self.assertEqual(result[('BASE_TURRET', 'TOP_LANE')][0], 0.0)
def testTowersLostInLosses(self):
result = self.matchlist.towersLostInLosses()
self.assertEqual(result[('OUTER_TURRET', 'BOT_LANE')][1].seconds, 560)
self.assertEqual(result[('OUTER_TURRET', 'BOT_LANE')][0], 100.0)
self.assertEqual(result[('OUTER_TURRET', 'TOP_LANE')][1].seconds, 818)
self.assertEqual(result[('OUTER_TURRET', 'TOP_LANE')][0], 100.0)
self.assertEqual(result[('OUTER_TURRET', 'MID_LANE')][1].seconds, 789)
self.assertEqual(result[('OUTER_TURRET', 'MID_LANE')][0], 100.0)
self.assertEqual(result[('INNER_TURRET', 'BOT_LANE')][1].seconds, 908)
self.assertEqual(result[('INNER_TURRET', 'BOT_LANE')][0], 100.0)
self.assertEqual(result[('INNER_TURRET', 'MID_LANE')][1].seconds, 1052)
self.assertEqual(result[('INNER_TURRET', 'MID_LANE')][0], 100.0)
self.assertEqual(result[('BASE_TURRET', 'MID_LANE')][1].seconds, 1205)
self.assertEqual(result[('BASE_TURRET', 'MID_LANE')][0], 100.0)
self.assertEqual(result[('INNER_TURRET', 'TOP_LANE')][1].seconds, 1185)
self.assertEqual(result[('INNER_TURRET', 'TOP_LANE')][0], 100.0)
self.assertEqual(result[('BASE_TURRET', 'TOP_LANE')][1].seconds, 1216)
self.assertEqual(result[('BASE_TURRET', 'TOP_LANE')][0],
66.66666666666667)
self.assertEqual(result[('NEXUS_TURRET', 'MID_LANE')][1].seconds, 1311)
self.assertEqual(result[('NEXUS_TURRET', 'MID_LANE')][0],
66.66666666666667)
self.assertEqual(result[('BASE_TURRET', 'BOT_LANE')][1].seconds, 1259)
self.assertEqual(result[('BASE_TURRET', 'BOT_LANE')][0],
66.66666666666667)
def testTowerLostInWins(self):
result = self.matchlist.towersLostInWins()
self.assertEqual(result[('OUTER_TURRET', 'TOP_LANE')][1].seconds, 839)
self.assertEqual(result[('OUTER_TURRET', 'TOP_LANE')][0], 50.0)
self.assertEqual(result[('OUTER_TURRET', 'MID_LANE')][1].seconds, 915)
self.assertEqual(result[('OUTER_TURRET', 'MID_LANE')][0], 50.0)
self.assertEqual(result[('OUTER_TURRET', 'BOT_LANE')][1].seconds, 1286)
self.assertEqual(result[('OUTER_TURRET', 'BOT_LANE')][0], 50.0)
self.assertEqual(result[('INNER_TURRET', 'TOP_LANE')][1].seconds, 1389)
self.assertEqual(result[('INNER_TURRET', 'TOP_LANE')][0], 50.0)
self.assertEqual(result[('BASE_TURRET', 'TOP_LANE')][1].seconds, 1404)
self.assertEqual(result[('BASE_TURRET', 'TOP_LANE')][0], 50.0)
self.assertEqual(result[('INNER_TURRET', 'BOT_LANE')][1].seconds, 1818)
self.assertEqual(result[('INNER_TURRET', 'BOT_LANE')][0], 50.0)
self.assertEqual(result[('INNER_TURRET', 'MID_LANE')][1].seconds, 1911)
self.assertEqual(result[('INNER_TURRET', 'MID_LANE')][0], 50.0)
self.assertEqual(result[('BASE_TURRET', 'MID_LANE')][1].seconds, 0)
self.assertEqual(result[('BASE_TURRET', 'MID_LANE')][0], 0.0)
self.assertEqual(result[('BASE_TURRET', 'BOT_LANE')][1].seconds, 0)
self.assertEqual(result[('BASE_TURRET', 'BOT_LANE')][0], 0.0)
self.assertEqual(result[('NEXUS_TURRET', 'MID_LANE')][1].seconds, 0)
self.assertEqual(result[('NEXUS_TURRET', 'MID_LANE')][0], 0.0)
#def testTimeFirstDragon(self):
#self.assertEqual(493, self.matchlist.avgFirstDragonTime())
'''
def search(request, name):
'''gameinfo = getInfoGetter(True)
print('creating MatchList')
ml = MatchList(gameinfo, 'l am eternal')
print("Searching for " + name)
id = gameinfo.getSummonerByName(name)['accountId']
matchtimes = []
allmatches = []
matchdetails = []
for i in range(0,HUNDREDS_OF_MATCHES):
matches = gameinfo.getMatchlistBySummonerId(id, i*100, 50)
for match in matches['matches']:
allmatches.append(match)
matchdetails.append(gameinfo.getMatchById(match['gameId']))
i = 0
winrateByTime = [[0 for x in range(2)] for y in range(4)]
for match in allmatches:
if match['queue'] == 420:
#NA: match['timestamp']/1000 IS PST OF BEGINNING OF MATCH
#VERIFIED
utctime = datetime.fromtimestamp(match['timestamp']/1000)
offset = timedelta(hours=0)
time = utctime - offset
matchtimes.append(str(time) + ' timestamp: ' +str(match['timestamp']) + ' '+ str(match['gameId']) + ' ' + str(matchdetails[i]['queueId']) + ' ' + str(win(name, matchdetails[i])))
if win(name, matchdetails[i]):
if time.hour >= 18:
winrateByTime[3][1]+=1
winrateByTime[3][0]+=1
elif time.hour >= 12:
winrateByTime[2][1]+=1
winrateByTime[2][0]+=1
elif time.hour >= 6:
winrateByTime[1][1]+=1
winrateByTime[1][0]+=1
else: #0-6
winrateByTime[0][1]+=1
winrateByTime[0][0]+=1
else:
if time.hour >= 18:
winrateByTime[3][0]+=1
elif time.hour >= 12:
winrateByTime[2][0]+=1
elif time.hour >= 6:
winrateByTime[1][0]+=1
else: #0-6
winrateByTime[0][0]+=1
i+=1
#print("not a ranked game.")
onPlayersTeam = dict()
vsPlayersTeam = dict()
for match in matchdetails:
if match['queueId'] == 420:
thisSummonersTeam = []
enemyTeam = []
thisSummonerWon = win(name, match)
thisSummonerId = 0
thisSummonersTeamId = 0
for player in match['participantIdentities']:
if player['player']['summonerName'].lower() == name:
thisSummonerId = player['participantId']
break
for participant in match['participants']:
if participant['participantId'] == thisSummonerId:
thisSummonersTeamId = participant['teamId']
break
participantIds = dict()
for player in match['participantIdentities']:
participantIds[player['participantId']] = player['player']['summonerName']
for participant in match['participants']:
if participant['teamId'] == thisSummonersTeamId:
thisSummonersTeam.append(participant['participantId'])
else:
enemyTeam.append(participant['participantId'])
if thisSummonerWon:
for particId in thisSummonersTeam:
if participantIds[particId] in onPlayersTeam:
wg = onPlayersTeam[participantIds[particId]]
onPlayersTeam[participantIds[particId]] = (wg[0]+1, wg[1]+1)
else:
onPlayersTeam[participantIds[particId]] = (1,1)
for particId in enemyTeam:
if participantIds[particId] in vsPlayersTeam:
wg = vsPlayersTeam[participantIds[particId]]
vsPlayersTeam[participantIds[particId]] = (wg[0], wg[1]+1)
else:
vsPlayersTeam[participantIds[particId]] = (0,1)
else:
for particId in thisSummonersTeam:
if participantIds[particId] in onPlayersTeam:
wg = onPlayersTeam[participantIds[particId]]
onPlayersTeam[participantIds[particId]] = (wg[0], wg[1]+1)
else:
onPlayersTeam[participantIds[particId]] = (0,1)
for particId in enemyTeam:
if participantIds[particId] in vsPlayersTeam:
wg = vsPlayersTeam[participantIds[particId]]
vsPlayersTeam[participantIds[particId]] = (wg[0]+1, wg[1]+1)
else:
vsPlayersTeam[participantIds[particId]] = (1,1)
onPlayersTeamList = []
for item in onPlayersTeam.items():
if item[1][1] > 1:
onPlayersTeamList.append(item)
onPlayersTeamList.sort(key=lambda x: x[1][1], reverse=True)
vsPlayersTeamList = []
for item in vsPlayersTeam.items():
if item[1][1] > 1:
vsPlayersTeamList.append(item)
vsPlayersTeamList.sort(key=lambda x: x[1][1], reverse=True)
print(onPlayersTeamList)
print(vsPlayersTeamList)
winratesByTime = []
if winrateByTime[3][0] != 0:
winratesByTime.append('18:00-24:00: ' + str(winrateByTime[3][1]/winrateByTime[3][0]*100) + '% of ' + str(winrateByTime[3][0]) + ' games.')
else:
winratesByTime.append('18:00-24:00: no games')
if winrateByTime[2][0] != 0:
winratesByTime.append('12:00-18:00: ' + str(winrateByTime[2][1]/winrateByTime[2][0]*100) + '% of ' + str(winrateByTime[2][0]) + ' games.')
else:
winratesByTime.append('12:00-18:00: no games')
if winrateByTime[1][0] != 0:
winratesByTime.append('6:00-12:00: ' + str(winrateByTime[1][1]/winrateByTime[1][0]*100) + '% of ' + str(winrateByTime[1][0]) + ' games.')
else:
winratesByTime.append('6:00-12:00: no games')
if winrateByTime[0][0] != 0:
winratesByTime.append('0:00-6:00: ' + str(winrateByTime[0][1]/winrateByTime[0][0]*100) + '% of ' + str(winrateByTime[0][0]) + ' games.')
else:
winratesByTime.append('0:00-6:00: no games')
print(winratesByTime)
return render(request, 'search/search.html', {
'name' : name ,
'matchtimes' : matchtimes ,
'winratesByTime' : winratesByTime ,
'onPlayersTeam' : onPlayersTeamList,
'vsPlayersTeam' : vsPlayersTeamList,
})
'''
maxMatches = int(request.session['numMatches'])
champions = request.session['champions']
role = request.session['role']
queue = request.session['queue']
if champions == "":
champions = None
if role == "":
role = None
if queue == "":
queue = None
try:
matchList = MatchList(getInfoGetter(), name, maxMatches, None, queue,
champions, role)
except RuntimeError as e:
return HttpResponse("Error: " + str(e))
#remember that you wrote the text 'in PST only' into search.html
if matchList.size() == 0:
return HttpResponse(
'no matches found with those parameters. Try a different search or include more matches.'
)
return render(
request,
'search/search.html',
{
'name':
name,
'overview':
str(matchList),
'numMatches':
maxMatches,
'matchIds':
matchList.matchIdList(),
'summonerId':
matchList.id,
#By time
'wrByTime':
matchList.winrateByTime(),
#OtherSummoners:
'otherSummonersWr':
matchList.winrateByOtherSummoners(),
#Dragons:
'pctElementals':
matchList.pctAllElemental(),
'pctElders':
matchList.pctAllElders(),
'pctOfEachType':
matchList.pctDragonsKilledByType(),
'pctOfTotalByType':
matchList.pctEachDragonType(),
'pctEleByOrder':
matchList.pctElementalKilledByOrder(),
'pctElderByOrder':
matchList.pctElderKilledByOrder(),
#Dragon time info:
'firstDragTime':
matchList.firstElementalDragonTime(),
'enemyContDragInfo':
matchList.timePercentEnemyContestedElementalDragons(),
'enemyB2BDragInfo':
matchList.timePercentEnemyBackToBackElementalDragons(),
'contDragInfo':
matchList.timePercentContestedElementalDragons(),
'b2BDragInfo':
matchList.timePercentBackToBackElementalDragons(),
#Barons:
'avgBarons':
matchList.avgBarons(),
#Towers:
'winTowersKilled':
matchList.towersKilledInWins(),
'lossTowersKilled':
matchList.towersKilledInLosses(),
'winTowersLost':
matchList.towersLostInWins(),
'lossTowersLost':
matchList.towersLostInLosses(),
#kills:
'championKills':
matchList.compileKillLists()
})