def _prepare(self, id_or_name): """ Get's the Teams from a live game by Summoner Name or from an old Match by Match ID :param id_or_name: either a Summoner Name or a Match ID :return: iterator of the prepared teams; if not exits None """ # Setting the Api key for Cassiopeia and the default region cass.set_riot_api_key(self.key) cass.set_default_region('EUW') if type(id_or_name) is str: summoner = cass.get_summoner(name=id_or_name, region='EUW') try: current_game = summoner.current_match() except Exception as e: print(str(e)) return None else: try: current_game = cass.get_match(id_or_name, region='EUW') except Exception as e: print(str(e)) return None if current_game.mode == cass.data.GameMode.aram: print('there are no lanes in Aram') return None # Preparing the participants per team for team in current_game.teams: yield self._prepare_team(team), team
def aggregate_batched_matches(batch, region, summoner_id): try: # init cass.get_realms(region=region).load() #old = time.time() * 1000 matchlist = [] for m_id in batch: match_id = int(m_id) matchlist.append(cass.get_match(id=match_id, region=region)) pool = Pool(len(matchlist)) pool.map(load_match, matchlist) pool.close() pool.join() #print("fetch:", time.time()*1000 - old) #old = time.time() * 1000 aggregate_user_matches(matchlist, summoner_id, region) #print("total:", time.time()*1000 - old) except Exception as e: if pool is not None: pool.close() log.warn("Failed to aggregate batched matches", e, stack_info=True) aggregate_batched_matches.retry(exc=e)
def collectMatches(): summoner = Summoner(name="Ung5r", region="NA") # A default summoner to pull matches from patchNo = Patch.from_str('8.2', region="NA") # Create some sorted lists to store the IDs of players and matches being analyzed. # Match info can only be pulled on a player basis so we'll have to pull each player # from a match to then get further match info. unpulledSummonerIDS = SortedList([summoner.id]) pulledSummonerIDS = SortedList() unpulledMatchIDS = SortedList() pulledMatchIDS = SortedList() matchesList = [] while unpulledSummonerIDS and len(pulledMatchIDS) < 5000: newSummonerID = random.choice(unpulledSummonerIDS) try: newSummoner = Summoner(id=newSummonerID, region="NA") except: print("Unable to retrieve new summoner, retrying in 10s") time.sleep(10) newSummoner = Summoner(id=newSummonerID, region="NA") matches = filterHistory(newSummoner, patchNo) try: unpulledMatchIDS.update([ match.id for match in matches if match.id not in unpulledMatchIDS ]) except: print("Unable to add to unpulled matches, retrying in 10s") time.sleep(10) unpulledMatchIDS.update([ match.id for match in matches if match.id not in unpulledMatchIDS ]) unpulledSummonerIDS.remove(newSummonerID) pulledSummonerIDS.add(newSummonerID) while unpulledMatchIDS: newMatchID = random.choice(unpulledMatchIDS) try: newMatch = Match(id=newMatchID, region="NA") except: print("Unable to retrieve new match, retrying in 10s") time.sleep(10) newMatch = Match(id=newMatchID, region="NA") for participant in newMatch.participants: if participant.summoner.id not in pulledSummonerIDS and participant.summoner.id not in unpulledSummonerIDS: unpulledSummonerIDS.add(participant.summoner.id) unpulledMatchIDS.remove(newMatchID) if newMatchID not in pulledMatchIDS: pulledMatchIDS.add(newMatchID) # Populate the list of matches by match ID for entry in pulledMatchIDS: matchesList.append(kass.get_match(id=entry, region="NA")) return matchesList
def test_match_correct_return(): match_history = cassiopeia.get_match_history(summoner=SUMMONER_NAME, region="NA") first_match = match_history[0] match_from_id = cassiopeia.get_match(id=first_match.id, region="NA") assert isinstance(match_from_id, cassiopeia.Match) assert first_match.id == match_from_id.id assert first_match == match_from_id
def get_match_data(gameId: str, region: str, gameDuration): match = cass.get_match(gameId, region) match_object = Match match_object.properties["gameId"] = gameId match_object.properties["blueWins"] = match.blue_team.win #Get data for blue team get_team_data(match_object, match.blue_team, gameDuration, "blue", region) get_team_data(match_object, match.red_team, gameDuration, "red", region) return match_object
def test_match_correct_return(): match_history = cassiopeia.get_match_history(SUMMONER_NAME) first_match = match_history[0] first_match_data = first_match._data[cassiopeia.core.match.MatchData]._dto match_from_id = cassiopeia.get_match(first_match.id) match_from_id_data = match_from_id._data[cassiopeia.core.match.MatchData]._dto assert isinstance(match_from_id, cassiopeia.Match) #assert first_match_data == match_from_id_data assert first_match.id == match_from_id.id
def aggregate_batched_matches(batch, region, summoner_id): # init cass.get_realms(region=region).load() matchlist = [] for m_id in batch: match_id = int(m_id) matchlist.append(cass.get_match(id=match_id, region=region)) #pool.map(load_match, matchlist) loop = asyncio.get_event_loop() tasks = [asyncio.ensure_future(fetch(m)) for m in matchlist] loop.run_until_complete(asyncio.wait(tasks))
def main(): print("Pulling data...") champion_roles = pull_data() print("Finished pulling data.") print() # Pull a summoner's most recent match using Cassiopeia match = cass.get_match(id=3344134840, region="NA") team = match.blue_team # Get the roles roles = get_team_roles(team, champion_roles) # Print the results print({role.name: champion.name for role, champion in roles.items()})
def get_match(match_id): match = cass.get_match(id=int(match_id)) red_team = match.red_team blue_team = match.blue_team red_team_stats = [ sum(map(lambda participant: participant.stats.kills, red_team.participants)), sum(map(lambda participant: participant.stats.deaths, red_team.participants)), sum(map(lambda participant: participant.stats.assists, red_team.participants)), sum(map(lambda participant: participant.stats.gold_spent, red_team.participants)), sum(map(lambda participant: participant.stats.total_minions_killed, red_team.participants)), sum(map(lambda participant: participant.stats.gold_spent // match.duration.seconds * 60, red_team.participants)), sum(map(lambda participant: participant.stats.total_damage_dealt, red_team.participants)), sum(map(lambda participant: participant.stats.total_heal, red_team.participants)), sum(map(lambda participant: participant.stats.damage_dealt_to_turrets, red_team.participants)) ] blue_team_stats = [ sum(map(lambda participant: participant.stats.kills, blue_team.participants)), sum(map(lambda participant: participant.stats.deaths, blue_team.participants)), sum(map(lambda participant: participant.stats.assists, blue_team.participants)), sum(map(lambda participant: participant.stats.gold_spent, blue_team.participants)), sum(map(lambda participant: participant.stats.total_minions_killed, blue_team.participants)), sum(map(lambda participant: participant.stats.gold_spent // match.duration.seconds * 60, blue_team.participants)), sum(map(lambda participant: participant.stats.total_damage_dealt, blue_team.participants)), sum(map(lambda participant: participant.stats.total_heal, blue_team.participants)), sum(map(lambda participant: participant.stats.damage_dealt_to_turrets, blue_team.participants)) ] duration = match.duration return render_template( 'match.html', red_team={ 'name': 'Красная команда', 'participants': red_team.participants, 'stats': red_team_stats }, blue_team={ 'name': 'Синяя команда', 'participants': blue_team.participants, 'stats': blue_team_stats }, match_duration=duration, str=str, round=round, sorted=sorted, filter=filter, sort_key=lambda item: item.name, filter_key=lambda item: item is not None )
def matches(): if request.method == 'GET': return render_template( 'matches.html' ) elif request.method == 'POST': match_id = request.form.get('match_id') try: if cass.get_match(id=int(match_id)): return redirect(f'match/{match_id}') except: return render_template( 'matches.html', message="Неверный id матча!" )
def get_match_timeline(request): region = normalize_region(request.GET['region']) match_id = int(request.GET['match_id']) try: match = cass.get_match(id=match_id, region=region) pool = Pool(2) pool.map(load_cass_obj, [match, match.timeline]) pool.close() pool.join() except: pool.close() return HttpResponse("Match does not exist", status=404) response = {} response['timeline'] = ujson.loads(match.timeline.to_json()) response['match'] = ujson.loads(match.to_json()) return JsonResponse(response)
def write_matches(summoner_name, n): """ writes n matches as csv files containing events or frames :param summoner_name: str of summoner name :param n: number of matches you want :return: void """ participant_frames_df = pd.DataFrame() events_df = pd.DataFrame() summoner = cass.get_summoner(name="Faker") match_history = cass.get_match_history(summoner=summoner) i = 0 for match in match_history: match_id = match.id match = cass.get_match(id=match_id) p_wins = get_participant_wins(match) pf_df, e_df = unpack_timeline(match.timeline, p_wins) pf_df['summoner'] = summoner_name e_df['summoner'] = summoner_name pf_df['match_id'] = match_id e_df['match_id'] = match_id participant_frames_df = pd.concat([participant_frames_df, pf_df]) events_df = pd.concat([events_df, e_df]) i += 1 if i >= n: break participant_frames_df.to_csv("participant_frames.csv", header=True, index=False) events_df.to_csv("events.csv", header=True, index=False)
print("{accountId}: {name} is a level {level} summoner on the {region} server."\ .format(accountId=summoner.id, name=summoner.name, level=summoner.level, region=summoner.region) ) # # get Faker's match history his last match # faker_match_history = summoner.match_history # print("His match history is length: {}".format(len(faker_match_history))) # faker_last_match_id = faker_match_history[0].id faker_last_match_id = 2842707542 faker_last_match = cass.get_match(faker_last_match_id) last_match_timeline = faker_last_match.timeline print("last match frames: {}".format(len(last_match_timeline.frames))) print("match length: {}".format(faker_last_match.duration)) last_match_frames = last_match_timeline.frames # make a data folder from os import path, getcwd, mkdir data_folder_name = "data" pwd = getcwd() full_path = path.join(pwd, data_folder_name) if not path.isdir(full_path): mkdir(full_path)
# Check if matchFile already exists, if so, error out try: f = open(matchFileName) except: print("matchFile named \"" + str(matchFileName) + "\" will be created") else: sys.exit("ERROR: matchFile named \"" + str(matchFileName) + "\" already existed. Exiting...") #Load Matches into a file denoted by matchFileName. that can be loaded later on matchCount = 0 curr_match_id = starting_match_id while matchCount < maxMatchCount: time.sleep(sleepTime) match = cass.get_match(curr_match_id) #If a match exists if match.exists: #If the match is a 5x5 soloque ranked mode game, add the match to the list if match.mode == cass.data.GameMode.classic and match.queue == cass.data.Queue.ranked_solo_fives: print("(" + str(matchCount + 1) + " Matches saved) Match id#" + str(match.id) + " being added...") #Load Existing Matches List from matchFile try: matchFile = open(matchFileName, 'rb') matches = pickle.load(matchFile) matchFile.close() except: matchFile = open(matchFileName, 'wb') matchFile.close() matches = []
def get_match_data(match_id, region="NA"): """Return LoL match data from the API. At random chooses red or blue team to prevent any autocorrelation of data. Keyword arguments: match_id -- the league api match data region -- the region to draw from (default NA) Returns: A dictionary of: match_id -- same as argument side -- red or blue side top_id -- the account id of the top laner on this side jun_id -- jungler mid_id -- mid laner adc_id -- bot carry sup_id -- support top_champ -- the champion id played top etc top_vs -- the vision score top etc top_cs_10 -- top cs difference at 10 top_cs_20 -- same at 20 top_xp_10 -- xp diff at 10 top_cs_20 -- same at 20 etc for other roles first_brick -- boolean for first tower first_blood -- first blood etc for herald, dragon, baron, inhib num_dragons -- number of dragons etc for barons, towers, inhibs result -- 1 for win 0 for loss """ entry = dict() entry["id"] = [match_id] match = cass.get_match(id = match_id, region="NA") side = np.random.choice(["red","blue"]) entry["side"] = side if side == "red": team = match.red_team if side == "blue": team = match.blue_team players = team.participants for num, player in enumerate(players): entry["player"+str(num)+"_id"] = [player.summoner.account_id] entry["player"+str(num)+"_role"] = [str(player.lane)+" "+str(player.role)] entry["player"+str(num)+"_champ"] = [player.champion.id] entry["player"+str(num)+"_vs"] = [player.stats.vision_score] entry["first_brick"] = [team.first_tower] entry["first_blood"] = [team.first_blood] entry["first_herald"] = [team.first_rift_herald] entry["first_dragon"] = [team.first_dragon] entry["first_baron"] = [team.first_baron] entry["first_inhib"] = [team.first_inhibitor] entry["num_dragons"] = [team.dragon_kills] entry["num_barons"] = [team.baron_kills] entry["num_towers"] = [team.tower_kills] entry["num_inhibs"] = [team.inhibitor_kills] entry["result"] = [team.win] return entry
async def summoner(ctx, name: str = None): await ctx.message.delete() key = os.environ.get('RIOT') cass.set_riot_api_key(key) lvl = '' rank = 'Нет ранга' mainer = '' win1 = '' win2 = '' win3 = '' win4 = '' ch1 = '' ch2 = '' ch3 = '' ch4 = '' wins = '' if name == None: await ctx.send('Введите ник призывателя') else: summoner = cass.get_summoner(region='RU', name=name) lvl = str(summoner.level) try: rank = str(summoner.league_entries[0].tier) + ' ' + str( summoner.league_entries[0].division) except: pass mainer = str(summoner.champion_masteries[0].champion.name) for x in cass.get_match(summoner.match_history[0].id, region='RU').red_team.participants: if x.summoner.name == summoner.name: ch1 = '(' + x.champion.name + ')' if cass.get_match(summoner.match_history[0].id, region='RU').red_team.win == False: win1 = ch1 + "Поражение:red_circle:" else: win1 = ch1 + 'Победа:green_circle:' for x in cass.get_match(summoner.match_history[0].id, region='RU').blue_team.participants: if x.summoner.name == summoner.name: ch1 = '(' + x.champion.name + ')' if cass.get_match(summoner.match_history[0].id, region='RU').blue_team.win == False: win1 = ch1 + "Поражение:red_circle:" else: win1 = ch1 + 'Победа:green_circle:' for x in cass.get_match(summoner.match_history[1].id, region='RU').red_team.participants: if x.summoner.name == summoner.name: ch2 = '(' + x.champion.name + ')' if cass.get_match(summoner.match_history[1].id, region='RU').red_team.win == False: win2 = ch2 + "Поражение:red_circle:" else: win2 = ch2 + 'Победа:green_circle:' for x in cass.get_match(summoner.match_history[1].id, region='RU').blue_team.participants: if x.summoner.name == summoner.name: ch2 = '(' + x.champion.name + ')' if cass.get_match(summoner.match_history[1].id, region='RU').blue_team.win == False: win2 = ch2 + "Поражение:red_circle:" else: win2 = ch2 + 'Победа:green_circle:' for x in cass.get_match(summoner.match_history[2].id, region='RU').red_team.participants: if x.summoner.name == summoner.name: ch3 = '(' + x.champion.name + ')' if cass.get_match(summoner.match_history[2].id, region='RU').red_team.win == False: win3 = ch3 + "Поражение:red_circle:" else: win3 = ch3 + 'Победа:green_circle:' for x in cass.get_match(summoner.match_history[2].id, region='RU').blue_team.participants: if x.summoner.name == summoner.name: ch3 = '(' + x.champion.name + ')' if cass.get_match(summoner.match_history[2].id, region='RU').blue_team.win == False: win3 = ch3 + "Поражение:red_circle:" else: win3 = ch3 + 'Победа:green_circle:' for x in cass.get_match(summoner.match_history[3].id, region='RU').red_team.participants: if x.summoner.name == summoner.name: ch4 = '(' + x.champion.name + ')' if cass.get_match(summoner.match_history[3].id, region='RU').red_team.win == False: win3 = ch4 + "Поражение:red_circle:" else: win3 = ch4 + 'Победа:green_circle:' for x in cass.get_match(summoner.match_history[3].id, region='RU').blue_team.participants: if x.summoner.name == summoner.name: ch4 = '(' + x.champion.name + ')' if cass.get_match(summoner.match_history[3].id, region='RU').blue_team.win == False: win4 = ch4 + "Поражение:red_circle:" else: win4 = ch4 + 'Победа:green_circle:' wins = win1 + '\n' + win2 + '\n' + win3 + '\n' + win4 t = 'Информация о призывателе: ' + name embed = discord.Embed(title=t, color=0xf5f5f5) embed.add_field(name='**Ранг:**', value=rank, inline=True) embed.add_field(name='**Лвл:**', value=lvl, inline=True) embed.add_field(name='**Мейн:**', value=mainer, inline=True) embed.add_field(name='**Последние игры:**', value=wins, inline=True) embed.set_thumbnail(url=summoner.profile_icon.url) embed.set_footer( text='LeagueOfBots', icon_url= 'https://cdn.discordapp.com/attachments/500621541546000388/709146278050922596/1568968178125834341.jpg' ) await ctx.send(embed=embed)
""" riot_api_key = "RGAPI-2f774048-8d86-4c98-a317-5230f8b1b898" make_data_folder() cass.set_riot_api_key(riot_api_key) cass.set_default_region("NA") summoner = cass.get_summoner(name="Faker") match_history = summoner.match_history csv_handle = open("data/faker-stats.csv", "w+") csv_writer = csv.writer(csv_handle) csv_writer.writerow(["match_id", "rowlen"] + stats) for match in match_history: match = cass.get_match(match.id) match_json = json.loads(match.to_json()) participants_list = match_json["participants"] if len(participants_list) < 2: continue faker_stats = [ player for player in participants_list if player["summonerName"] == "Faker" ][0] row = [] for stat in stats: row.append(faker_stats[stat]) row = [str(match.id), str(len(row))] + row csv_writer.writerow(row)
for player in team.participants: champion_names.append(player.champion.name) champion_keys.append(player.champion.id) return [champion_names, champion_keys] # This is a completely arbitrary starting value match_id = 3229026157 # Loop counter that only increments when a match exists successful_matches = 0 # DATABASE INSERTIONS while successful_matches < 10000: winning_champions = [] losing_champions = [] match = cass.get_match(match_id) # Check if match_id is valid # filter out bot matches if match.exists and match.mode.value == "CLASSIC" and match.map.id == 11 and ( match.queue.id in (400, 420, 430, 440)): # Collect teams blue_team = get_champions(match.blue_team) red_team = get_champions(match.red_team) # For Blue Team wins if match.blue_team.win: winning_champions = blue_team losing_champions = red_team # For Red Team wins
def getMatch(self, match_id): return cass.get_match(match_id)
import cassiopeia as cass import requests import ujson ##################################################################################################################################################################### ## Settings ######################################################################################################################################################### ##################################################################################################################################################################### settDefault = cass.get_default_config() print(settDefault) ##################################################################################################################################################################### ## getMatchByID ##################################################################################################################################################### ##################################################################################################################################################################### cass.get_match()
def getRedSideByMatch(id): return cass.get_match(id).red_team.to_json()
# Pickle data to disk print("Pickling...") print("Matches analyzed so far: " + str(i)) print("Unique drafts analyzed: " + str(len(data))) # print("Rejected: " + str(rejected)) with open('../input/data.pickle', 'wb') as handle: pickle.dump(data, handle, protocol=pickle.HIGHEST_PROTOCOL) # Don't waste time accessing the match if we know it's old. if int( ids[i] ) < 2893574694: # Smaller than this and the match is definitely old. continue # print(ids[i]) match = cass.get_match(int(ids[i])) # print(match) # print(match.patch, match.is_remake, match.blue_team) # print(str(match.patch)) if str(match.patch) not in ["8.24", "8.23", "8.22", "8.21"]: # Recent games only print(str(i) + " – BAD (old)") print(str(match.patch)) continue if match.is_remake: # No remakes print(str(i) + " – BAD (remake)") continue if match.blue_team.win: winning_team = match.blue_team
def getBlueSideByMatch(id): return cass.get_match(id).blue_team.to_json()
def getGameByMatchID(id): return cass.get_match(id).to_json()
def get_match_records(filename: str, start_id: int, max_records: int, sleep_time: int) -> None: """Retrieves the first n match records that are valid and is also a '5v5 ranked solo queue' game mode from the Riot API. Args: filename: Name of the file to save the League of Legends match records start_id: Match ID to begin looking from (will decrement from said ID number) max_records: Total number of successful records to be retrieved sleep_time: Number of seconds to wait between each API call Returns: Does not return anything. However, the data will be written to the filename as specified. """ # Remember to remove the API key when pushing commits to GitHub cassiopeia.set_riot_api_key('RGAPI-KEY-GOES-HERE') cassiopeia.set_default_region('NA') # Iterate matches by ID number and only store matches that are of the "5v5 solo queue ranked" game mode read_records = 0 current_id = start_id while read_records < max_records: # Cassiopeia API wrapper handles rate-limiting, but apparently its not suited for a personal API key time.sleep(sleep_time) match = cassiopeia.get_match(current_id) if not match.exists: print(f"Match ID {match.id} does not exist.") elif match.mode != cassiopeia.data.GameMode.classic or match.queue != cassiopeia.data.Queue.ranked_solo_fives: print( f"Match ID {match.id} does not match criteria of '5v5 ranked solo queue'." ) else: print( f"Match ID {match.id} added. ({read_records + 1} matches out of {max_records} saved to disk) " ) # a+ is similar to r+ to read and write to a file, but a+ also creates the file if it is missing and # appends additional text to the end of the file with open(filename, 'a+', newline='', encoding='utf-8') as file: csv_writer = csv.writer(file) # Write header once at the beginning of the file if read_records == 0: csv_writer.writerow([ "id", "version", "side", "win", "ban1", "ban2", "ban3", "ban4", "ban5", "champion1", "champion2", "champion3", "champion4", "champion5", "tower_kills", "inhibitor_kills", "dragon_kills", "rift_herald_kills", "baron_kills", "first_tower", "first_inhibitor", "first_dragon", "first_rift_herald", "first_baron" ]) # Write blue team information into csv bteam_info = get_team_stats('blue', match) csv_writer.writerow(bteam_info) # Write red team information into csv rteam_info = get_team_stats('red', match) csv_writer.writerow(rteam_info) read_records += 1 # This should be in the else statement current_id -= 1 # This should not be within the else statement