def get_tilt(area, summoner_name): try: watcher = RiotWatcher(API_KEY, default_region=area) champions_dict = get_champions_data(watcher) # check if we have API calls remaining if watcher.can_make_request(): current_app.logger.debug('Requests to API available') else: current_app.logger.error('Too many requests. ' 'Please try again later.') sys.exit(2) try: player = watcher.get_summoner(name=summoner_name, region=area) except LoLException: current_app.logger.debug('Summoner {0} not found.'.format( summoner_name)) raise SummonerNotFound( 'Summoner {0} not found in {1} server.'.format( summoner_name, area.upper())) recent_games = watcher.get_recent_games(player['id'])['games'] response = {"status": 200, "wins": get_wins_number(recent_games), "metadata": { "background": get_random_background_url( champions_dict), "display": get_random_display()}, "stats": get_stats(recent_games, champions_dict), "summoner_name": summoner_name, "tilt_level": get_tilt_level(recent_games)} return response except: current_app.logger.error(traceback.format_exc()) raise
def main(): w = RiotWatcher(constants.riot_id) db = sqlite3.connect('matchdb') cursor = db.cursor() cursor.execute( '''SELECT DISTINCT match_id FROM match_by_tier ORDER BY match_id ASC''' ) if not os.path.exists("matches_silver"): os.makedirs("matches_silver") os.chdir("matches_silver"); for row in cursor: match_id = row[0] print(match_id) match_filename = get_match_filename(match_id) if (os.path.isfile(match_filename)): print("Skipping: {}".format(match_filename)) else: try: match_json = w.get_match(match_id, include_timeline=True) with open(match_filename, 'w') as f: f.write(json.dumps(match_json)) print("Writing: {}".format(match_filename)) except Exception as e: print("Failed: {0} with {1}".format( match_filename, e )) time.sleep(1.2)
def import_champs(): w = RiotWatcher(os.environ.get('RIOT_API_KEY')) champs = w.static_get_champion_list() new_champs = {} for champ in champs['data'].itervalues(): new_champs[champ['id']] = champ['name'] return new_champs
def getMatch(matchList, server): key = readApiKey() w = RiotWatcher(key, server) try: match = w.get_match(matchList['matchId'], server) except Exception: pass return match
class LeagueGrind(object): def __init__(self, spreadSheetName): # Establish Google Drive Connection json_key = json.load(open('credentials.json')) scope = ['https://spreadsheets.google.com/feeds'] credentials = SignedJwtAssertionCredentials(json_key['client_email'], json_key['private_key'].encode(), scope) gc = gspread.authorize(credentials) self.spreadsheet = gc.open("League Grinds") #Establish Riot API Connection self.riotWatcher = RiotWatcher(getDevKey()) def update_player(self, playerName): # Get the current spread sheet for playerName # If it does not exist, create one for them try: worksheet = self.spreadsheet.worksheet("API-"+playerName) except: self.spreadsheet.add_worksheet("API-"+playerName,1,8) worksheet = self.spreadsheet.worksheet("API-"+playerName) self.init_player_spreadsheet(worksheet) # Determine Last Entered Match rows = worksheet.row_count if rows == 1: lastTimeStamp = 0 else: lastTimeStamp = worksheet.cell(rows,2).value # Get Summoner ID while self.riotWatcher.can_make_request() == False: continue player = self.riotWatcher.get_summoner(name=playerName) playerID = player['id'] # Request Match Meta Data while self.riotWatcher.can_make_request() == False: continue match_list = self.riotWatcher.get_match_list(playerID,region='na',season='SEASON2016') # Send all new Matches to SpreadSheet for f in match_list['matches'][::-1]: if f['timestamp'] > int(lastTimeStamp): Match(playerID,self.riotWatcher,f).log(worksheet) def init_player_spreadsheet(self,worksheet): worksheet.update_cell(1,1,"MatchID") worksheet.update_cell(1,2,"Timestamp") worksheet.update_cell(1,3,"Champion") worksheet.update_cell(1,4,"Kills") worksheet.update_cell(1,5,"Deaths") worksheet.update_cell(1,6,"Assists") worksheet.update_cell(1,7,"KDA") worksheet.update_cell(1,8,"Outcome")
def getSummonerMatchList(summonerId, server, queue, season): key = readApiKey() w = RiotWatcher(key, server) try: info = w.get_match_list(summonerId, server, champion_ids=None, #Aqui obtiene las partidas jugadasde un jugador (son muchas) ranked_queues=queue, season=season) except Exception: pass return info['matches']
def initChallengerTierList(server): key = readApiKey() if os.path.isfile('data.json') == False: with open('data.json', 'w') as f: w = RiotWatcher(key, server) challenger_tier = w.get_challenger(server) json.dump(challenger_tier, f) print 'CACHE NOT FOUND, CREATING JSON..' data = challenger_tier return data else: with open('data.json') as data_file: print 'CACHE FOUND, LOADING...' data = json.load(data_file) return data
def main(): p_ids = [] with open("player_tiers.csv") as csvfile: reader = csv.DictReader(csvfile) p_ids = [row["user_id"] for row in reader if row["tier"] == "SILVER"] db = sqlite3.connect("matchdb") cursor = db.cursor() cursor.execute( """ CREATE TABLE IF NOT EXISTS match_by_tier( user_id INTEGER KEY, match_id INTEGER KEY, tier VARCHAR(255), UNIQUE (user_id, match_id) ON CONFLICT REPLACE); """ ) db.commit() db.close() w = RiotWatcher(constants.riot_id) db = sqlite3.connect("matchdb") cursor = db.cursor() curTime = long(time.time() * 1000) for user_id in p_ids: cursor.execute("""SELECT DISTINCT user_id FROM match_by_tier WHERE user_id=?""", (user_id,)) if cursor.fetchone() is None: match_list = [] try: match_list = w.get_match_list( str(user_id), region=NORTH_AMERICA, begin_time=curTime - 1000 * 60 * 60 * 24 * 30, end_time=curTime )["matches"] except Exception as e: print(e) filtered_matches = [m for m in match_list if m["queue"] == "RANKED_SOLO_5x5"] retVal = filtered_matches[:10] time.sleep(2) user_matches = [(user_id, m["matchId"], "SILVER") for m in retVal] cursor.executemany("""INSERT INTO match_by_tier (user_id, match_id, tier) VALUES (?,?, ?)""", user_matches) db.commit() print("Dealt with {0}".format(user_id)) else: print("Skipped {0}".format(user_id)) db.close()
def __init__(self): """Set up the initial values for the class and read from the config file""" jsonConfig = open("./config.json").read() self.config = json.loads(jsonConfig) self.api = RiotWatcher(self.config["api-key"], default_region=self.config["region"]) self.canMakeRequest = True self.callCount = 10
def __init__(self, spreadSheetName): # Establish Google Drive Connection json_key = json.load(open('credentials.json')) scope = ['https://spreadsheets.google.com/feeds'] credentials = SignedJwtAssertionCredentials(json_key['client_email'], json_key['private_key'].encode(), scope) gc = gspread.authorize(credentials) self.spreadsheet = gc.open("League Grinds") #Establish Riot API Connection self.riotWatcher = RiotWatcher(getDevKey())
class LeagueGrind(object): def __init__(self, spreadSheetName): # Establish Google Drive Connection json_key = json.load(open('credentials.json')) scope = ['https://spreadsheets.google.com/feeds'] credentials = SignedJwtAssertionCredentials(json_key['client_email'], json_key['private_key'].encode(), scope) gc = gspread.authorize(credentials) self.spreadsheet = gc.open("League Grinds") #Establish Riot API Connection self.riotWatcher = RiotWatcher(getDevKey()) def update_player(self, playerName): player = self.riotWatcher.get_summoner(name=playerName) playerID = player['id'] match_list = self.riotWatcher.get_match_list(playerID,region='na',season='SEASON2016') if raw_input("Get Match Data? yes/no\n") == "yes": matches = [Match(playerID,self.riotWatcher,f) for f in match_list['matches']]
def on_button_click(self): self.error_label.configure(text='validating...') w = RiotWatcher(self.apikey.get()) #validate summoner name and api key try: me = w.get_summoner(name=self.summoner.get(), region=self.region_var.get()) print me #save new settings self.settings['summonerName'] = self.summoner.get() self.settings['region'] = self.region_var.get() self.settings['apikey'] = self.apikey.get() with open('settings.json', 'w') as f: json.dump(self.settings, f) self.error_label.configure(text='settings saved!') except Exception as error: if error.error == "Unauthorized": self.error_label.configure(text='API Key is invalid!') else: self.error_label.configure(text='Summoner does not exist!')
class CallCounter: """Class to control the rate of requests""" def __init__(self): """Set up the initial values for the class and read from the config file""" jsonConfig = open("./config.json").read() self.config = json.loads(jsonConfig) self.api = RiotWatcher(self.config["api-key"], default_region=self.config["region"]) self.canMakeRequest = True self.callCount = 10 def get_call_count(self): return self.callCount def decrease_call_count(self): self.callCount -= 1 if self.callCount == 0: self.canMakeRequest = False def reset_call_count(self): self.callCount = 10 self.canMakeRequest = True def get_match_details_from_id(self, match_id): """Gets match details for the given match_id. Returns a list of match details""" if self.canMakeRequest: time.sleep(1) print("Getting match details for game id: " + str(match_id)) md = self.api.get_match(match_id, include_timeline=True) print(md) return md def get_match_ids_for_team(self): """Gets the latest games for the team. Returns a list of strings with the game ids""" if self.canMakeRequest: time.sleep(1) print("Getting match history for team id " + self.config["team-id"]) return self.api.get_team(self.config["team-id"])
class Request: def __init__(self): self.riot = RiotWatcher(LoL.API_KEY) self.champions = self._getChampions() def _getChampions(self): champion_list = {} champions = self.riot.static_get_champion_list() for champion in champions["data"]: champion_list[champions["data"][champion]["id"]] = champion return champion_list def _checkRequestStatus(self): return self.riot.can_make_request() def retrievePlayerData(self, playerId): while not self._checkRequestStatus(): sleep(2.6) else: player = {} player["id"] = playerId player["summoner"] = self.riot.get_summoner(name=playerId) player["match_history"] = self.riot.get_match_history(player["summoner"]["id"]) return player
def home(request): summoner_name = request.GET.get('summoner_name') region = request.GET.get("region") # Get Api key cur_path = os.getcwd() file = open(os.path.join(cur_path, '_info', 'api.txt'), "r") #path to api key APIKey = file.read() watcher = RiotWatcher(APIKey) try: summoner_data = watcher.summoner.by_name(region, summoner_name) except ApiError as e: status_code = e.response.status_code return render(request, "summoner/error.html", { "summonerData": { "name": summoner_name }, "status": status_code }) # if summoner not found if "status" in summoner_data: return render(request, "summoner/error.html", {"summonerData": { "name": summoner_name }}) match_list = watcher.match.matchlist_by_account(region, summoner_data["accountId"], end_index=25)['matches'] matches = {} champion_ids = {} for match in match_list[:min(25, len(match_list))]: match_by_id = watcher.match.by_id(region, match["gameId"]) # 0th index = blue team, 1st index = red team for ban in zip(match_by_id['teams'][0]['bans'], match_by_id['teams'][1]['bans']): for i in range(len(ban)): id = str(ban[i]['championId']) if id not in champion_ids: champion_json = riot.getStaticChampionInfo(id) champion_ids[id] = champion_json league_data = watcher.league.by_summoner(region, summoner_data["id"]) #Static content version = watcher.data_dragon.versions_for_region(region)['v'] champions = watcher.data_dragon.champions(version)['data'] items = watcher.data_dragon.items(version)['data'] profile_icons = watcher.data_dragon.profile_icons(version)['data'] summoner_spells = watcher.data_dragon.summoner_spells(version)['data'] # runes = watcher.data_dragon.runes(version) not working?? context = { "summonerData": summoner_data, "matches": match_list, "leagues": league_data, "champions": champions, "items": items, "profile_icons": profile_icons, "summoner_spells": summoner_spells, "champion_ids": Champion_Id.objects.in_bulk() } return render(request, 'summoner/home.html', context)
def __init__(self, key, default_region=EUROPE_WEST): self.lol_watcher = RiotWatcher(key, default_region=default_region) self.wait() self.champion_list = self.lol_watcher.static_get_champion_list( )['data']
for ind in range(20): try: last_match = watcher.match.by_id( my_region, recent_matches['matches'][ind]['gameId']) print_match_info(last_match, champion, enemy_champion) except ChampNotFoundException: print(".") continue break # print(json.dumps(last_match, indent=4, sort_keys=True)) try: watcher = RiotWatcher(open('riot-api-key.txt', 'r').read()) my_region = 'na1' me = watcher.summoner.by_name(my_region, 'iqiq') champ_data = watcher.static_data.champions(my_region)['data'].items() champion_name_to_id_map = {key: value['id'] for key, value in champ_data} champion = sys.argv[1] enemy_champion = sys.argv[2] if len(sys.argv) > 3: game_index = int(sys.argv[3]) else: game_index = -1
# these tests are pretty bad, mostly to make sure no exceptions are thrown import time from riotwatcher import RiotWatcher, NORTH_AMERICA key = '<YOUR KEY HERE>' # if summoner doesnt have ranked teams, teams tests will fail # if summoner doesnt have ranked stats, stats tests will fail # these are not graceful failures, so try to use a summoner that has them summoner_name = 'YOUR NAME HERE' w = RiotWatcher(key) def wait(): while not w.can_make_request(): time.sleep(1) def champion_tests(): wait() temp = w.get_all_champions() wait() w.get_champion(temp['champions'][0]['id']) def game_tests(summoner): wait() w.get_recent_games(summoner['id'])
import requests import logging import configparser from io import BytesIO from PIL import Image from riotwatcher import RiotWatcher from riotwatcher import EUROPE_WEST from riotwatcher import NORTH_AMERICA from riotwatcher import LoLException, error_404, error_429 logger = logging.getLogger("scuript_logger.league") w = RiotWatcher('b6e57fc8-b03e-40ce-8c84-55d616941248') #static_champ_list = w.static_get_champion_list() #logger.debug(static_champ_list) #CONSTANTS UNKNOWN = 'unknown' config = configparser.ConfigParser() config.read('../cfg/regions.txt') queue_types = { 0 : 'CUSTOM', # Custom games 2 : 'NORMAL 5x5 BLIND', # Normal 5v5 blind pick 8 : 'NORMAL 3x3', # Normal 3v3 games 14 : 'NORMAL 5x5 DRAFT', # Normal 5v5 Draft Pick games 16 : 'ODIN 5x5 BLIND', # Dominion 5v5 Blind Pick games
import cassiopeia as cass from riotwatcher import RiotWatcher import settings from requests import HTTPError from utils.regions import get_region watcher = RiotWatcher(settings.RIOT_API_KEY) summoner = watcher.summoner.by_name(region=get_region('eune'), summoner_name='xerrion') league = watcher.league.positions_by_summoner(get_region('eune'), summoner['id']) print(summoner) print(league[0])
def __init__(self, bot): self.bot = bot self.watcher = RiotWatcher('RIOT API')
from decimal import * import sys import datetime from riotwatcher import RiotWatcher from libraries.perms import * from libraries.library import * from urllib import request import linecache import ast ApiKey = getApiKey() w = RiotWatcher(ApiKey) ##################################################################################################################################################### def getSummonerInfo(summoner): """Récupère les données d'un invocateur""" try: user = w.get_summoner(name=summoner) return user except LoLException as e: if e == error_429: error = '```py\nWe should retry in {} seconds.\n```'.format(e.headers['Retry-After']) return error elif e == error_404: error = '```py\nSummoner not found.\n```' return error
def league_rank(self, **options): try: from riotwatcher import RiotWatcher, LoLException except ImportError: log.error('Missing required module for League Rank module: riotwatcher') return False source = options['source'] message = options['message'] bot = options['bot'] riot_api_key = self.settings['riot_api_key'] summoner_name = self.settings['default_summoner'] def_region = self.settings['default_region'] region_list = ['br', 'eune', 'euw', 'kr', 'lan', 'las', 'na', 'oce', 'ru', 'tr'] if message: summoner_name = message.split()[0] try: region = message.split()[1].lower() except IndexError: region = def_region.lower() if region not in region_list: bot.whisper(source.username, 'Region is not valid. Please enter a valid region, region is optional and the default region is {}'.format(def_region.upper())) return False else: pass else: region = def_region.lower() error_404 = "Game data not found" error_429 = "Too many requests" try: rw = RiotWatcher(riot_api_key, default_region=region) summoner = rw.get_summoner(name=summoner_name) summoner_id = str(summoner['id']) summoner_name = summoner['name'] except LoLException as e: if e == error_429: bot.say('Too many requests. Try again in {} seconds'.format(e.headers['Retry-After'])) return False elif e == error_404: bot.say('The summoner not found. Use a valid summoner name (remove spaces) and region FailFish') return False try: summoner_league = rw.get_league_entry(summoner_ids=(summoner_id, )) tier = summoner_league[summoner_id][0]['tier'] division = summoner_league[summoner_id][0]['entries'][0]['division'] league_points = summoner_league[summoner_id][0]['entries'][0]['leaguePoints'] bot.say('The Summoner {} on region {} is currently in {} {} with {} LP 4Head'.format(summoner_name, region.upper(), tier, division, league_points)) except LoLException as e: if e == error_429: bot.say('Too many requests. Try again in {} seconds'.format(e.headers['Retry-After'])) return False elif e == error_404: bot.say('The Summoner {} on region {} is currently UNRANKED.. FeelsBadMan'.format(summoner_name, region.upper())) return False else: bot.say('Trouble fetching summoner rank.. Kappa Try again later!') return False
# Generated by Django 2.0.2 on 2018-04-08 16:49 #from .models import * from django.db import migrations from riotwatcher import RiotWatcher from ..static.python import APIKey Key = APIKey.riot_key() watcher = RiotWatcher(Key) region = 'na1' def genChampions(apps, schema_editor): static_champ_list = watcher.static_data.champions(region, tags = 'all') champion_keys = static_champ_list['keys'] data = static_champ_list['data'] Champion = apps.get_model('league','Champion') champ_objects = [] for key,name in champion_keys.items(): champ = data[name] img = 'http://stelar7.no/cdragon/latest/champion-icons/' + str(champ['id']) +'.png' passive = champ['passive'] passiveImg = 'http://ddragon.leagueoflegends.com/cdn/6.24.1/img/passive/' + passive['image']['full'] Champion.objects.create(champion_id=int(key),name=champ['name'],image=img,title=champ['title'], passiveName=passive['name'],passiveDescription=passive['sanitizedDescription'],passiveImage=passiveImg).save() def genSpells(apps, schema_editor): static_spell_list = watcher.static_data.summoner_spells(region, tags = 'all') spell_objects = [] data = static_spell_list['data']
import time import pymysql from cassiopeia import Summoner, Match, Patch, Champion from cassiopeia.core import MatchHistory from cassiopeia import Queue from discord.ext import commands from riotwatcher import RiotWatcher from requests import HTTPError bot = commands.Bot( command_prefix=("!", "@LeagueBot"), description='Bot for League of Legends') champion_gg_api_key = config.championGGAPI kass.set_riot_api_key(config.riotAPI) watcher = RiotWatcher(config.riotAPI) all_champions = kass.Champions(region="NA") latestLeaguePatch = kass.get_versions(region="NA") #StoreMatches.populateTables() # Shows when bot is ready @bot.event async def on_ready(): print('Logged in as ' + bot.user.name) # Simple hello command @bot.command()
def league_rank(self, **options): try: from riotwatcher import RiotWatcher, LoLException except ImportError: log.error('Missing required module for League Rank module: riotwatcher') return False source = options['source'] message = options['message'] bot = options['bot'] riot_api_key = self.settings['riot_api_key'] summoner_name = self.settings['default_summoner'] def_region = self.settings['default_region'] if len(riot_api_key) == 0: log.error('Missing riot API key in settings.') return False region_list = ['br', 'eune', 'euw', 'kr', 'lan', 'las', 'na', 'oce', 'ru', 'tr'] if message: summoner_name = message.split()[0] try: region = message.split()[1].lower() except IndexError: region = def_region.lower() if region not in region_list: bot.whisper(source.username, 'Region is not valid. Please enter a valid region, region is optional and the default region is {}'.format(def_region.upper())) return False else: pass else: region = def_region.lower() if len(summoner_name) == 0 or len(region) == 0: return False error_404 = 'Game data not found' error_429 = 'Too many requests' try: rw = RiotWatcher(riot_api_key, default_region=region) summoner = rw.get_summoner(name=summoner_name) summoner_id = str(summoner['id']) summoner_name = summoner['name'] except LoLException as e: if e == error_429: bot.say('Too many requests. Try again in {} seconds'.format(e.headers['Retry-After'])) return False elif e == error_404: bot.say('The summoner not found. Use a valid summoner name (remove spaces) and region FailFish') return False else: log.info('Something unknown went wrong: {}'.format(e)) return False try: summoner_league = rw.get_league_entry(summoner_ids=(summoner_id, )) tier = summoner_league[summoner_id][0]['tier'] division = summoner_league[summoner_id][0]['entries'][0]['division'] league_points = summoner_league[summoner_id][0]['entries'][0]['leaguePoints'] bot.say('The Summoner {} on region {} is currently in {} {} with {} LP 4Head'.format(summoner_name, region.upper(), tier, division, league_points)) except LoLException as e: if e == error_429: bot.say('Too many requests. Try again in {} seconds'.format(e.headers['Retry-After'])) return False elif e == error_404: bot.say('The Summoner {} on region {} is currently UNRANKED.. FeelsBadMan'.format(summoner_name, region.upper())) return False else: bot.say('Trouble fetching summoner rank.. Kappa Try again later!') return False
import sys from riotwatcher import RiotWatcher import mysql.connector as sql from mysql.connector import Error watcher = RiotWatcher("RGAPI-a15d5a32-06e3-475d-a59b-a2880f1ca49f") def connect(query, status): conn = None cursor = None records = None try: conn = sql.connect(host='localhost', database='league_api', user='******', port=3306, password='******') cursor = conn.cursor() cursor.execute(query) if status == "insert": conn.commit() elif status == "select": records = cursor.fetchall() except Error as e: print(e)
async def on_ready(bot): # Obtain all static data required watcher = RiotWatcher(bot.configurations['discrank.py']['token']) if not watcher.can_make_request(): raise BotException(ErrorTypes.STARTUP, EXCEPTION, "The given Riot API token cannot get requests.") # Add champions by ID and name, and skills by ID champions = watcher.static_get_champion_list(data_by_id=True)['data'] champions_named = watcher.static_get_champion_list()['data'] champions_named = dict( (key.lower(), value) for key, value in champions_named.items()) champions.update(champions_named) spells = watcher.static_get_summoner_spell_list(data_by_id=True)['data'] # Add game modes by queue type and name modes = { "0": "Custom", "8": "Normal 3v3", "2": "Normal", "14": "Normal Draft", "4": "Dynamic Queue", "6": "Dynamic Queue", "9": "Ranked 3v3", "41": "Ranked 3v3", "42": "Ranked 5v5", "16": "This Gamemode doesn't even exist anymore", "17": "Same with this one", "7": "Co-op vs AI", "25": "Co-op vs AI", "31": "Co-op vs AI", "32": "Co-op vs AI", "33": "Co-op vs AI", "52": "Co-op vs AI (3v3)", "61": "Team Builder", "65": "ARAM", "70": "One For All", "72": "Magma Chamber 1v1", "73": "Magma Chamber 2v2", "75": "Hexakill", "76": "URF", "83": "Co-op vs AI (URF)", "91": "Doom Bots Lv 1", "92": "Doom Bots Lv 2", "93": "Doom Bots Lv 3", "96": "Ascension", "98": "Hexakill", "100": "Bilgewater", "300": "Legend of the Poro King", "313": "Bilgewater ARAM", "400": "Team Builder", "410": "Dynamic Queue", "CUSTOM": "0", "NORMAL_3x3": "8", "NORMAL_5x5_BLIND": "2", "NORMAL_5x5_DRAFT": "14", "RANKED_SOLO_5x5": "4", "RANKED_PREMADE_5x5*": "6", "RANKED_PREMADE_3x3*": "9", "RANKED_TEAM_3x3": "41", "RANKED_TEAM_5x5": "42", "ODIN_5x5_BLIND": "16", "ODIN_5x5_DRAFT": "17", "BOT_5x5*": "7", "BOT_ODIN_5x5": "25", "BOT_5x5_INTRO": "31", "BOT_5x5_BEGINNER": "32", "BOT_5x5_INTERMEDIATE": "33", "BOT_TT_3x3": "52", "GROUP_FINDER_5x5": "61", "ARAM_5x5": "65", "ONEFORALL_5x5": "70", "FIRSTBLOOD_1x1": "72", "FIRSTBLOOD_2x2": "73", "SR_6x6": "75", "URF_5x5": "76", "BOT_URF_5x5": "83", "NIGHTMARE_BOT_5x5_RANK1": "91", "NIGHTMARE_BOT_5x5_RANK2": "92", "NIGHTMARE_BOT_5x5_RANK5": "93", "ASCENSION_5x5": "96", "HEXAKILL": "98", "BILGEWATER_ARAM_5x5": "100", "KING_PORO_5x5": "300", "COUNTER_PICK": "310", "BILGEWATER_5x5": "313", "TEAM_BUILDER_DRAFT_UNRANKED_5x5": "400", "TEAM_BUILDER_DRAFT_RANKED_5x5": "410" } bot.data['discrank.py'] = [watcher, champions, spells, modes]
from riotwatcher import RiotWatcher from pprint import pprint from riotwatcher import KOREA from riotwatcher import EUROPE_WEST w = RiotWatcher('API KEY') def outFile(aFile, write): f = open(aFile, 'w') f.write(write) f.close() #NORTH_AMERICA challenger = w.get_challenger() #pprint(challenger) #KOREA challengerKR = w.get_challenger(region=KOREA) #pprint(challengerKR) #EUROPE_WEST challengerEUW = w.get_challenger(region=EUROPE_WEST) #pprint(challengerEUW)
from riotwatcher import RiotWatcher from riotwatcher import EUROPE_WEST import operator #Your API key here w = RiotWatcher('') if w.can_make_request(): dict = {} num_players = input('How many players are we comparing?\n') for x in range(0, num_players): player_name = raw_input('Enter player name\n') player = w.get_summoner(name = player_name, region = EUROPE_WEST) #Hihgly complex algorithm designed to predict a players ability to play legaue dict[player['name']] = player['id']/player['profileIconId'] + player['revisionDate']/player['id'] sortDic = sorted(dict.items(), key=operator.itemgetter(1)) print "The best player is:\n" print dict.keys()[0] else: print "You aren't allowed to"
async def league(summonername: str): watcher = RiotWatcher('League Of Legends API required') my_region = 'na1' try: me = watcher.summoner.by_name(my_region, summonername) my_ranked_stats = watcher.league.positions_by_summoner( my_region, me['id']) print(my_ranked_stats) solo_tier = None solo_rank = None solo_win = None solo_lose = None flex_tier = None flex_rank = None flex_win = None flex_lose = None if len(my_ranked_stats) == 0: await bot.say('You currently aren\'t placed in rank.') else: for x in range(0, len(my_ranked_stats)): if my_ranked_stats[x]['queueType'] == 'RANKED_FLEX_SR': flex_tier = my_ranked_stats[x]['tier'] flex_rank = my_ranked_stats[x]['rank'] flex_win = my_ranked_stats[x]['wins'] flex_lose = my_ranked_stats[x]['losses'] winpercentflex = round( (flex_win / (flex_win + flex_lose)) * 100, 1) elif my_ranked_stats[x]['queueType'] == 'RANKED_SOLO_5x5': solo_tier = my_ranked_stats[x]['tier'] solo_rank = my_ranked_stats[x]['rank'] solo_win = my_ranked_stats[x]['wins'] solo_lose = my_ranked_stats[x]['losses'] winpercentsolo = round( (solo_win / (solo_win + solo_lose)) * 100, 1) if flex_rank == None and solo_rank != None: await bot.say('Your Solo rank is: ' + str(solo_tier) + ' ' + str(solo_rank) + ' and your Flex rank is: Unranked.') await bot.say('Your Solo winrate is: ' + str(winpercentsolo) + '%.') elif flex_rank != None and solo_rank == None: await bot.say('Your Solo rank is: Unranked' + ' and your Flex rank is: ' + str(flex_tier) + ' ' + str(flex_rank) + '.') await bot.say('Your Flex winrate is: ' + str(winpercentflex) + '%.') elif flex_rank != None and solo_rank != None: await bot.say('Your Solo rank is: ' + str(solo_tier) + ' ' + str(solo_rank) + ' and your Flex rank is: ' + str(flex_tier) + ' ' + str(flex_rank) + '.') await bot.say('Your Solo winrate is: ' + str(winpercentsolo) + '% and your Flex winrate is: ' + str(winpercentflex) + '%.') except HTTPError as err: if err.response.status_code == 429: await bot.say('We should retry in {} seconds.'.format( e.headers['Retry-After'])) await bot.say( 'this retry-after is handled by default by the RiotWatcher library' ) await bot.say( 'future requests wait until the retry-after time passes') elif err.response.status_code == 404: await bot.say('Summoner with that ridiculous name not found.') else: raise
import json from riotwatcher import RiotWatcher jsonConfig = open("./config.json").read() config = json.loads(jsonConfig) api = RiotWatcher(config["api-key"], default_region=config["region"]) match_id = 2483005284 details = api.get_match(match_id, include_timeline=True) # def split_match_details(details): participantIdentities = details["participantIdentities"] participants = details["participants"] del details["participantIdentities"] del details["participants"] print(details) print(participantIdentities) print(participants)
import os.path from urllib2 import HTTPError error_400 = "Bad request" error_401 = "Unauthorized" error_403 = "Blacklisted key" error_404 = "Game data not found" error_429 = "Too many requests" error_500 = "Internal server error" error_503 = "Service unavailable" error_504 = 'Gateway timeout' startup = time.time() w = RiotWatcher(apikey) challenger = w.get_challenger() masters = w.get_master() tier_dict = {x:i for i, x in enumerate(['CHALLENGER', 'MASTER', 'DIAMOND', 'PLATINUM', 'GOLD', 'SILVER', 'BRONZE'])} player_tiers = {x['playerOrTeamId']:0 for x in challenger['entries']} #player_tiers.update({x['playerOrTeamId']:1 for x in masters['entries']}) players = Queue.PriorityQueue() a = [players.put((player_tiers[x['playerOrTeamId']],x['playerOrTeamId'])) for x in challenger['entries']]# + masters['entries']] epoch = datetime.datetime.utcfromtimestamp(0)
import datetime import json from modules.champions import Champions from objects.player import Player from requests import HTTPError from riotwatcher import RiotWatcher # Load the config file with open('config.json') as json_data_file: data = json.load(json_data_file) # Store config details key = data['key'] watcher = RiotWatcher(key) default_region = 'na1' class Match: def __init__(self, match_id: int): self.match_id = match_id self.raw_match = watcher.match.by_id(default_region, self.match_id) # Information on the match self.season = self.raw_match['seasonId'] self.queue = self.raw_match['queueId'] self.game_duration = self.raw_match['gameDuration'] self.game_creation = datetime.datetime.fromtimestamp( self.raw_match['gameCreation'] / 1000.0).strftime('%m-%d-%Y %H:%M:%S')
def lol_connect(): file_json = get_json_secret() return RiotWatcher(file_json['riot_key'])
class Lol: def __init__(self, key, default_region=EUROPE_WEST): self.lol_watcher = RiotWatcher(key, default_region=default_region) self.wait() self.champion_list = self.lol_watcher.static_get_champion_list( )['data'] def wait(self): while not self.lol_watcher.can_make_request(): time.sleep(1) def test_map(self, _id): if _id == 1: return "Summoner's Rift" elif _id == 2: return "Summoner's Rift" elif _id == 3: return "The Proving Grounds (tuto)" elif _id == 4: return "Twisted Treeline" elif _id == 8: return "The Crystal Scar" elif _id == 10: return "Twisted Treeline" elif _id == 11: return "Summoner's Rift" elif _id == 12: return "Howling Abyss" elif _id == 14: return "Butcher's Bridge" def test_queue(self, _id): if _id == 0: return "Custom" elif _id == 2: return "Normal 5v5 blind" elif _id == 4: return "Ranked Solo 5v5" elif _id == 6: return "Ranked Premade 5v5" elif _id == 7: return "Coop vs ia 5v5" elif _id == 8: return "Normal 3v3" elif _id == 9: return "Ranked flex" elif _id == 14: return "Normal Draft 5v5" elif _id == 16: return "Odin 5v5 Blind" elif _id == 17: return "Odin 5v5 Draft" elif _id == 25: return "Coop vs ia 5v5" elif _id == 31: return "Coop vs ia (intro)" elif _id == 32: return "Coop vs ia (beginner)" elif _id == 33: return "Coop vs ia (Intermediate)" elif _id == 41: return "Ranked Team 3v3" elif _id == 52: return "Ranked Team 5v5" elif _id == 61: return "GROUP_FINDER_5v5" elif _id == 65: return "Aram" elif _id == 70: return "One For All" elif _id == 72: return "FIRSTBLOOD_1v1" elif _id == 73: return "FIRSTBLOOD_2v2" elif _id == 75: return "Hexakill" elif _id == 76: return "URF" elif _id == 78: return "One For All" elif _id == 83: return "Bot URF" elif _id == 91: return "DOOM Bot (rank 1)" elif _id == 92: return "DOOM Bot (rank 2)" elif _id == 93: return "DOOM Bot (rank 5)" elif _id == 96: return "Ascension" elif _id == 98: return "Hexakill" elif _id == 100: return "BILGEWATER_ARAM_5v5" elif _id == 300: return "Poro King" elif _id == 310: return "COUNTER_PICK" elif _id == 313: return "BILGEWATER_5v5" elif _id == 315: return "Siege" elif _id == 317: return "Definitly Not Dominion" elif _id == 318: return "Aram URF" elif _id == 400: return "Normal Draft" elif _id == 410: return "Ranked" elif _id == 420: return "Ranked Solo/Duo" elif _id == 440: return "Ranked Flex" def test_champ(self, _id): temp = [] for k in self.champion_list: temp.append(self.champion_list[k]) temp = [nb for nb in temp if nb['id'] == _id] return temp[0]['name'] def test_ranked_stats(self, stats, key): stats = stats['champions'] stats = [nb for nb in stats if nb['id'] == 0] stats = stats[0]['stats'] return stats[key] def test_team(self, _id): if _id == 100: return ":large_blue_circle:" else: return ":red_circle:" def check_lol(self, player, region): try: self.wait() return self.lol_watcher.get_summoner(name=player, region=region) except LoLException as e: if e == error_429: return ":x: Resseye dans {} secondes.".format( e.headers['Retry-After']) elif e == error_404: return ":x: Summoner inconnu : {}".format(player) def message_lol(self, summoner): message = ":information_source: {} :video_game:\n\n".format( summoner['name']) message += " :information_source: Général Stats\n" message += " **ID**: {}\n".format(summoner['id']) message += " **Level**: {}\n".format(summoner['summonerLevel']) self.wait() temp = self.lol_watcher.get_league(summoner_ids=[summoner['id']]) rank = [] for i in temp[str(summoner['id'])]: rank.append(i['queue'] + " " + i['tier']) message += " **Rank**: {}\n".format(rank) #message += " **Mastery Levels**: {}\n".format() #message += " **Mastery Points**: {}\n".format() #message += " **Mastery Tokens**: {}\n".format() self.wait() player_stats = self.lol_watcher.get_stat_summary( summoner['id'])['playerStatSummaries'] player_stats = [ nb for nb in player_stats if nb['playerStatSummaryType'] == 'Unranked' ] player_stats = player_stats[0] message += " **Wins**: {}\n".format(player_stats['wins']) message += " **Kills**: {}\n".format( player_stats['aggregatedStats']['totalChampionKills']) message += " **Assistances**: {}\n".format( player_stats['aggregatedStats']['totalAssists']) message += " **Creeps tués**: {}\n".format( player_stats['aggregatedStats']['totalMinionKills']) message += " **Tourelles détruite**: {}\n\n".format( player_stats['aggregatedStats']['totalTurretsKilled']) #message += " **Dernière connexion**: {}\n\n".format() message += ":information_source: Ranked Stats :\n" try: self.wait() ranked_stats = self.lol_watcher.get_ranked_stats(summoner['id']) message += " **Win:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalSessionsWon')) message += " **Loose:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalSessionsLost')) message += " **Kill:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalChampionKills')) message += " **Assistance:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalAssists')) message += " **Damages infligés:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalDamageDealt')) message += " **Damages Reçus:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalDamageTaken')) message += " **Argent gagné:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalGoldEarned')) message += " **Creeps tués:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalMinionKills')) message += " **Tourelles détruites:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalTurretsKilled')) message += " **Double kills:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalDoubleKills')) message += " **Triple kills:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalTripleKills')) message += " **Quadra kills:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalQuadraKills')) message += " **Penta kills:** {}\n".format( self.test_ranked_stats(ranked_stats, 'totalPentaKills')) message += " **Total Killing Spree:** {}\n\n".format( self.test_ranked_stats(ranked_stats, 'killingSpree')) except: message += "**Aucune Stats de Ranked n'a été trouvée !**\n\n" message += ":information_source: Game en cours :\n" try: self.wait() temp = self.lol_watcher.get_current_game(summoner['id']) message += " **ID Partie:** {}\n".format(temp['gameId']) message += " **GameMode:** {}\n".format(temp['gameMode']) message += " **GameType:** {}\n".format(temp['gameType']) message += " **ID Queue:** {}\n".format( self.test_queue(temp['gameQueueConfigId'])) message += " **ID Platform:** {}\n".format(temp['platformId']) message += " **ID Map:** {}\n".format(self.test_map(temp['mapId'])) for i in temp['participants']: message += " " + i['summonerName'] + " (" + self.test_champ( i['championId']) + ") Team: " + self.test_team( i['teamId']) + "\n" except: message += "**Aucune game en cours...**" return message
import json # Library for ease of Riot Game API use. # https://riot-watcher.readthedocs.io/en/latest/ from riotwatcher import RiotWatcher, ApiError import RequestMatchlist.requestMatchlists as RequestMatchlists # print(json.load(open("keys.json", encoding="UTF-8"))['apiKey']) api = RiotWatcher(json.load(open("keys.json", encoding="UTF-8"))['apiKey']) ''' PlayerInfo object defines all the information that makes up a summoner information search window. Error Handling: if error == 'init' then either the league API is down, the API key is out of date, or the player name doesn't exist if wins == 'none then there was no information in last week search ''' class PlayerInfo(): # Iterates through JSON return of API request to return JSON object of current season RANKED SOLO 5x5 information. def summonerSearch(self, id, region): stats = api.league.by_summoner(region, id) for stat in stats: if stat['queueType'] == "RANKED_SOLO_5x5": return stat # Iterates though a game and searches for the JSON array with the given player name to retrieve information. def gameWinLoss(self, game): for player in game['participantIdentities']: if player['player']['summonerName'].lower() == "mccloudi": return game['participants'][player['participantId'] -
from riotwatcher import RiotWatcher import time import json watcher = RiotWatcher('RGAPI-b17a8469-7cf1-4f9d-bbd7-e244a4225b92') my_region = 'jp1' ''' me = watcher.summoner.by_name(my_region, 'test') print(me) # all objects are returned (by default) as a dict # get my 1 mastery page i keep changing my_mastery_pages = watcher.masteries.by_summoner(my_region, me['id']) print(my_mastery_pages) # lets see if i got diamond yet (i probably didnt) my_ranked_stats = watcher.league.leagues_by_summoner(my_region, me['id']) print(my_ranked_stats) # Lets some champions static_champ_list = watcher.static_data.champions(my_region) print(static_champ_list) # Error checking requires importing HTTPError from requests ''' from requests import HTTPError # For Riot's API, the 404 status code indicates that the requested data wasn't found and # should be expected to occur in normal operation, as in the case of a an # invalid summoner name, match ID, etc. #
from riotwatcher import RiotWatcher import csv api_key = input( 'Enter your Riot Games API Key. (https://developer.riotgames.com/)\n') watcher = RiotWatcher(api_key) my_region = 'na1' version = watcher.data_dragon.versions_for_region(my_region)['v'] dragon = watcher.data_dragon.champions(version) champ_data = dragon['data'] begin = 0 end = 100 champs_played = [] game_ids = [] champion_ids = {} champion_wins = {} champion_losses = {} champion_kills = {} champion_deaths = {} champion_assists = {} win_counter = 0 loss_counter = 0 kill_counter = 0 death_counter = 0 assist_counter = 0 double_counter = 0 triple_counter = 0 quadra_counter = 0 penta_counter = 0 damage_dealt = 0 #************** End Initial Setup ******************************************************
import sys import time from riotwatcher import RiotWatcher, NORTH_AMERICA, LoLException from tools import save_obj def secondsToStr(t): rediv = lambda ll,b : list(divmod(ll[0],b)) + ll[1:] return "%d:%02d:%02d.%03d" % tuple(reduce(rediv,[[t*1000,],1000,60,60])) #key = #PUT YOUR API KEY HERE w = RiotWatcher(key) def get_participants_for_further_pulls(match): """ This function takes a riot api 'match' and returns only selected participant information. You may add to the returned information if you want. The return value is a list of dictionaries, one for each participant in the match. """ participants = [ {} for i in range(len(match['participants'])) ] for i,p in enumerate(match['participants']): participants[i]['highestAchievedSeasonTier'] = p['highestAchievedSeasonTier'] participants[i]['summonerId'] = match['participantIdentities'][p['participantId']-1]['player']['summonerId'] return participants def get_match_information_to_save(match): """ This function takes a riot api 'match' and parses through it to save only the information you want. You can choose to save everything, or only specific things. The return value is a dictionary containing only the information you want to save for the match. """ # Uncomment the following line to save all the data
def league_rank(self, bot, source, message, **rest): try: from riotwatcher import RiotWatcher, LoLException except ImportError: log.error( "Missing required module for League Rank module: riotwatcher") return False riot_api_key = self.settings["riot_api_key"] summoner_name = self.settings["default_summoner"] def_region = self.settings["default_region"] if len(riot_api_key) == 0: log.error("Missing riot API key in settings.") return False region_list = [ "br", "eune", "euw", "kr", "lan", "las", "na", "oce", "ru", "tr" ] if message: summoner_name = message.split()[0] try: region = message.split()[1].lower() except IndexError: region = def_region.lower() if region not in region_list: bot.whisper( source, f"Region is not valid. Please enter a valid region, region is optional and the default region is {def_region.upper()}", ) return False else: pass else: region = def_region.lower() if len(summoner_name) == 0 or len(region) == 0: return False error_404 = "Game data not found" error_429 = "Too many requests" try: rw = RiotWatcher(riot_api_key, default_region=region) summoner = rw.get_summoner(name=summoner_name) summoner_id = str(summoner["id"]) summoner_name = summoner["name"] except LoLException as e: if e == error_429: bot.say( f"Too many requests. Try again in {e.headers['Retry-After']} seconds" ) return False elif e == error_404: bot.say( "The summoner not found. Use a valid summoner name (remove spaces) and region FailFish" ) return False else: log.info(f"Something unknown went wrong: {e}") return False try: summoner_league = rw.get_league_entry(summoner_ids=(summoner_id, )) tier = summoner_league[summoner_id][0]["tier"] division = summoner_league[summoner_id][0]["entries"][0][ "division"] league_points = summoner_league[summoner_id][0]["entries"][0][ "leaguePoints"] bot.say( f"The Summoner {summoner_name} on region {region.upper()} is currently in {tier} {division} with {league_points} LP 4Head" ) except LoLException as e: if e == error_429: bot.say( f"Too many requests. Try again in {e.headers['Retry-After']} seconds" ) return False elif e == error_404: bot.say( f"The Summoner {summoner_name} on region {region.upper()} is currently UNRANKED.. FeelsBadMan" ) return False else: bot.say( "Trouble fetching summoner rank.. Kappa Try again later!") return False
def main(): # gets key from file api_key = get_file("api.key") ## init RiotWatcher rw = RiotWatcher(api_key.strip()) # location of the matchIDs if you want AP_ITEM_DATASET change to # the appropriate directory dir_location = "../info/BILGEWATER_DATASET/BILGEWATER" files_dir = os.listdir(dir_location) for file in files_dir: # For every file that doesn't end in _info.json loop through it # expecting a list of MatchIDs and then preform API calls to get the match info # and then write to a file with ending "_info.json" if "_info.json" not in file: new_file_name = file.replace(".json","_info.json") print "Generating %s"%(new_file_name) print_file = open(dir_location + "/" + new_file_name ,"w+") # opens the file and reads contents file_info = get_file(dir_location + "/" + file) # turns the string representation of a list of MatchIDs # into an actual list of MatchIDs match_list = ast.literal_eval(file_info) # variables to display progress in processing MatchIDs count = 1 match_len = len(match_list) # Begins writing the output file with beginning of the list print_file.write("[") # For every MatchId in the MatchList for matchID in match_list: # Sets default value for match_info match_info = {} # used to gauge 429 responses later on gotitbool = False # Loops until gotitbool is found while not gotitbool: try: # checks if queue is clear if not waits until it is wait(rw) # attempts to get the match information given MatchID match_info = rw.get_match(matchID, region=file.replace(".json","").lower(), include_timeline=True) # if it got this far it successful and gotitbool is set to True gotitbool = True except LoLException as e: # This trips if an LoLException is raised from RiotWatcher print e.error # If this is not a 429 error then it can't wait a time span # to find a solution to it if e.error not in [error_429, error_503, error_500]: # a 400, 401, 404 error print "error from server: %s"%(e.error) return # Prints out all the applicable headers used for debugging for header in e.response.headers: if header not in ['access-control-allow-headers','content-encoding','transfer-encoding','x-newrelic-app-data','server','connection','cache-control','date','access-control-allow-origin','access-control-allow-methods','content-type','content-length']: print "headers: %s"%(header) if 'Retry-After' in e.response.headers: # If the client receives a Rate Limit Exceeded response the client # should process this response and halt future API calls for the duration, # in seconds, indicated by the Retry-After header time.sleep(int(e.response.headers['Retry-After'])) else: # Else if no Retry-After header wait a reasonable time (1sec) # and then try agian if e.error in [error_500,error_503]: time.sleep(30) else: time.sleep(1) except Exception as e: # An error occured that was not anticipated print str(e) return # Dumps the json information into the output file print_file.write(str(json.dumps(match_info))) # If not the end of the file adds a ",\n" which is # needed to properly process the file later if count != match_len: print_file.write(",\n") # Prints progress in processing the file print "%s: %s/%s"%(str(file), count, match_len) # Moves counter up by 1 count += 1 # closing off the list of matches print_file.write("]") print_file.close()
__author__ = 'Vixus' from riotwatcher import RiotWatcher w = RiotWatcher('eda1ed56-6ae8-41bf-97b7-acaa970537dc') # check if we have API calls remaining print(w.can_make_request()) me = w.get_summoner(name='vixus360') print(me) # championList = w.static_get_champion_list() # print championList # print w.get_champion(championList['data']['Lux']['id']) def print_tabs(count): for i in range(count): print '\t', def print_data(obj,tabCount=-1): if type(obj) == dict: for key, value in obj.items(): print_tabs(tabCount) if hasattr(value, '__iter__'): print key,":" print_data(value,tabCount+1) else: print '%s : %s' % (key, value) elif type(obj) == list: for value in obj:
#------------------------------------------------------------------------------- # Name: module1 # Purpose: # # Author: James # # Created: 28/01/2015 # Copyright: (c) James 2015 # Licence: <your licence> #------------------------------------------------------------------------------- #!/usr/bin/env python from riotwatcher import RiotWatcher import pygametools as pt w = RiotWatcher('e4a0c61e-4a2b-41b2-9b98-5f95f745b1b7') # check if we have API calls remaining #print(w.can_make_request()) me = w.get_summoner(name='salvsis') print(me) a = pt.Linesoftext([str(me['name'])],(300,50),True) a.test((600,300)) #print(w.get_stat_summary(me['id']))
import logging logging.basicConfig(filename='example.log', level=logging.DEBUG) sys.setrecursionlimit(100000) patchMillSecs = 1548316800000 #game version 9.2 path = 'F:/lolMatchData/data/matches/' count = 0 matchIDsDownloaded = [] matchIDsDownloading = [] summonerIDsDownloaded = [] summonerIDsDownloading = [] watcher = RiotWatcher('RGAPI-753fa9d9-7ec6-4b63-bd92-9428824c4484') #将match中的summonerId判断后,放入指定缓存容器 def appendSummonerId(match): SummonerIdInThisMatch = [] playerNum = len(match['participantIdentities']) for i in range(0, playerNum): SummonerIdInThisMatch.append( match['participantIdentities'][i]['player']['accountId']) for SummonerId in SummonerIdInThisMatch: if SummonerId not in summonerIDsDownloaded and SummonerId not in summonerIDsDownloading: summonerIDsDownloading.append(SummonerId) return
import random from riotwatcher import RiotWatcher, EUROPE_WEST, LoLException from tools import save_obj, load_obj unpulled_summoners = [52333251,72343187,22403890] #Insert some starting summoner ids here pulled_summoners = list() #matchId : file number pulled_matches = list() pulled_matches_count = 0 #saved_files = 0 #match_data_to_save = [] data_file = open("data_composition.tab","a") BLUE = 100 RED = 200 w = RiotWatcher("YOUR-API-KEY", default_region=EUROPE_WEST) def wait_for_request_availability(w): while not w.can_make_request(): time.sleep(0.2) champions = w.get_all_champions() if not os.path.isfile('pulled_matches.txt'): data_file.write("matchId\tcreateDate\t") for champion in champions['champions']: data_file.write("b chmp " + str(champion['id']) + "\t") for champion in champions['champions']: data_file.write("r chmp " + str(champion['id']) + "\t") data_file.write("winner\n") data_file.write("c\t"*2)
def __init__(self, region, api_key): self._region = region self._watcher = RiotWatcher(api_key)
import os import os.path import time import zipfile import random from riotwatcher import RiotWatcher, EUROPE_WEST, LoLException from tools import save_obj, load_obj unpulled_summoners = [35076397, 41527671, 80239244, 78377150] #Insert some starting summoner ids here pulled_summoners = list() #matchId : file number pulled_matches = dict() pulled_matches_count = 0 saved_files = 0 match_data_to_save = [] w = RiotWatcher("YOUR-API-KEY", default_region=EUROPE_WEST) def wait_for_request_availability(w): while not w.can_make_request(): time.sleep(0.2) #alt_list is for further prevention of requestion same match_ids multiple times def get_match_details_from_history(match_history, match_created, num_old_matches=10, alt_list = []): if 'matches' not in match_history: #history is empty return [] newer_match_ids = [match['matchId'] for match in match_history['matches'] if match['timestamp'] > match_created] older_match_ids = [match['matchId'] for match in match_history['matches'] if match['timestamp'] < match_created] #this is to avoid queries that take way too long if len(newer_match_ids)>40: #-1 means skip this summoner - too many matches to get - time consuming
from pymongo import MongoClient import pymongo import riotwatcher as rw from riotwatcher import RiotWatcher from riotwatcher import LoLException import time from optparse import OptionParser import json #frodo621 key key = "45fbe47f-84f1-43b6-9394-9f433a23d522" watcher = RiotWatcher(key) print watcher.static_get_versions(region = 'na')
import urllib2, json, sys, os from riotwatcher import RiotWatcher from datetime import datetime today = datetime.now() if len(sys.argv) != 3: print "Usage: python summonerids.py [max_summoners] [API_KEY]" sys.exit(0) max_summoners = int(sys.argv[1]) # input q = [] API_KEY = sys.argv[2] w = RiotWatcher(API_KEY) startid = '20120281' q.append(int(startid)) # opening a json gamehistory file if w.can_make_request() == True: readfile = urllib2.urlopen('https://na.api.pvp.net/api/lol/na/v1.3/game/by-summoner/' + startid + '/recent?api_key=' + API_KEY) data = json.load(readfile) for game in data["games"]: if game["subType"] == "RANKED_SOLO_5x5": for player in game["fellowPlayers"]: if player["summonerId"] not in q: q.append(player["summonerId"]) # print q i = 1 while len(q) < max_summoners: if w.can_make_request() == True: if i >= len(q): print "only scraped " + str(i) + " summoners" max_summoners = len(q)
from django.shortcuts import render from django.http import HttpResponse from django.http import HttpResponseRedirect from .models import Tutorial from .forms import SummonerForm from django.views.generic import TemplateView from riotwatcher import RiotWatcher, ApiError watcher = RiotWatcher('RGAPI-5c43a0af-efb8-48c0-8225-d8c4ff2eef73') my_region = 'na1' name = 'ellls' sum_spell_json = { 4: "http://ddragon.leagueoflegends.com/cdn/10.2.1/img/spell/SummonerFlash.png", 21: "http://ddragon.leagueoflegends.com/cdn/10.2.1/img/spell/SummonerBarrier.png", 7: "http://ddragon.leagueoflegends.com/cdn/10.2.1/img/spell/SummonerHeal.png", 14: "http://ddragon.leagueoflegends.com/cdn/10.2.1/img/spell/SummonerIgnite.png" } def summonerSpellKey(dict, key): if key in dict.keys(): return dict[key] else: return key
from riotwatcher import RiotWatcher import time leagueApi = RiotWatcher('04328930-7ab0-4e23-8c83-af1bbc4147ea') #Get Summoner ID and Stats summoner = raw_input("Enter your summoner name: ") opponent = raw_input("Enter your opponent's summoner name:") if leagueApi.can_make_request(): summonerId = leagueApi.get_summoner(name=summoner) opponentId = leagueApi.get_summoner(name=opponent) print print "Welcome Summoner!" bet = raw_input("Enter the amount of $ you would like to bet: ") print print "You've bet", bet, "dollars" lastPlayedGame = leagueApi.get_recent_games(summonerId['id'])['games'][0]['createDate'] currentDate = lastPlayedGame print "Waiting for you to play a game!" while lastPlayedGame == currentDate: #Checks every 10 seconds for new game time.sleep(10) currentDate = leagueApi.get_recent_games(summonerId['id'])['games'][0]['createDate'] #Need to also make a check to see if the other player was playing summonerGameId = leagueApi.get_recent_games(summonerId['id'])['games'][0]['gameId'] opponentGameId = leagueApi.get_recent_games(opponentId['id'])['games'][0]['gameId']
# these tests are pretty bad, mostly to make sure no exceptions are thrown import time from riotwatcher import RiotWatcher, NORTH_AMERICA key = '9213b085-ed48-4bf0-af91-d8fa519e3b35' # if summoner doesnt have ranked teams, teams tests will fail # if summoner doesnt have ranked stats, stats tests will fail # these are not graceful failures, so try to use a summoner that has them summoner_name = 'rias' w = RiotWatcher(key) def wait(): while not w.can_make_request(): time.sleep(1) def champion_tests(): wait() temp = w.get_all_champions() wait() w.get_champion(temp['champions'][0]['id']) def game_tests(summoner): wait() w.get_recent_games(summoner['id'])
def __init__(self): self.riot = RiotWatcher(LoL.API_KEY) self.champions = self._getChampions()
titleFont = wx.Font(55, wx.ROMAN, wx.ITALIC, wx.BOLD) miniFont = wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL) miniBoldFont = wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD) textColor = constants['colors']['text_color'] titleColor = constants['colors']['title_color'] lighterTextColor = constants['colors']['lighter_text_color'] lighterBlue = constants['colors']['lighter_blue'] lightBlue = constants['colors']['light_blue'] lighterRed = constants['colors']['lighter_red'] lightRed = constants['colors']['light_red'] #Three API keys = thrice the calls before rate limit order = [] if len(config['api_key_1']) > 0: watcher1 = RiotWatcher(config['api_key_1'], default_region=NORTH_AMERICA) order.append(watcher1) if len(config['api_key_2']) > 0: watcher2 = RiotWatcher(config['api_key_2'], default_region=NORTH_AMERICA) order.append(watcher2) if len(config['api_key_3']) > 0: watcher3 = RiotWatcher(config['api_key_3'], default_region=NORTH_AMERICA) order.append(watcher3) #Finds out which API key is usable def getWatcher(): temp = order.pop(0) order.append(temp) try: temp.get_summoner(name)
import discord from riotwatcher import RiotWatcher, ApiError import time import random from requests import get from requests.exceptions import RequestException from contextlib import closing from bs4 import BeautifulSoup import keys watcher = RiotWatcher(keys.riotAPI) champData = watcher.data_dragon.champions('9.6.1') #Creating id dictionaries to reference champion_key_dic = {} for champ in champData['data']: champion_key_dic[champData['data'][champ] ['key']] = champData['data'][champ]['name'] def simple_get(url): try: with closing(get(url, stream=True)) as resp: if is_good_response(resp): return resp.content else: return None except:
async def on_message(msg): if msg.author.id != client.user.id: # ignore our own commands if msg.content.startswith(conf['invoker']): command = msg.content[len(conf['invoker']):] print(command) if command == 'help': g_4 = '\n' + conf['invoker'] g_3 = '{0}{1}'.format(conf['invoker'], g_4.join(os.listdir('audio/'))) g_3 = g_3.lower().replace(conf['fileformat'], '') g_2 = 'Comandos para o ' + conf['bot'] + ':\n' + \ g_3 + '\n' if not msg.channel.is_private: await client.send_message(msg.channel, g_2) elif command.startswith('lol'): player_name = command.lstrip('lol ') watcher = RiotWatcher(lol_token) region = 'br1' player = watcher.summoner.by_name(region, player_name) ranked = watcher.league.positions_by_summoner( region, player['id']) for lists in ranked: for items in ranked: name = items['playerOrTeamName'] tier = items['tier'].lower() rank = items['rank'] wins = str(items['wins']) loss = str(items['losses']) if items['queueType'] == 'RANKED_FLEX_TT': fila = 'Twisted Treeline' elif items['queueType'] == 'RANKED_SOLO_5x5': fila = 'Summoners Rift Solo/Duo' elif items['queueType'] == 'RANKED_FLEX_SR': fila = 'Summoners Rift Flex' if player['summonerLevel'] < 30: await client.send_message( msg.channel, player['name'] + ' is currently level ' + str(player['summonerLevel'])) elif ranked == []: await client.send_message( msg.channel, player['name'] + ' is not ranked.') else: em = discord.Embed(title=fila) em.add_field(name="Rank", value=tier.capitalize() + ' ' + rank, inline=True) em.add_field(name="Wins", value=wins, inline=True) em.add_field(name="Loss", value=loss, inline=True) em.set_author(name=name, icon_url=client.user.default_avatar_url) await client.send_message(msg.channel, embed=em) print(player) print(ranked) elif command.startswith('ow'): battletag = command.lstrip('ow ') owclient = AsyncOWAPI() owdata = {} async with aiohttp.ClientSession( connector=aiohttp.TCPConnector( verify_ssl=False)) as session: owdata[PC] = await owclient.get_stats( battletag.capitalize(), session=session, platform=PC) d = owdata[PC]['us']['competitive']['overall_stats'] em = discord.Embed(title='Overwatch Stats: ') for k, v in d.items(): # if k == 'comprank': em.add_field(name=k, value=v, inline=True) print(k, v) #await client.send_message(msg.channel, str(k) + str(v)) # em.set_author(name=battletag, icon_url=client.user.default_avatar_url) await client.send_message(msg.channel, embed=em) else: if msg.author.voice_channel: try: message = msg.author.voice_channel voice = await client.join_voice_channel(message) player = voice.create_ffmpeg_player( 'audio/' + command + conf['fileformat'], use_avconv=True) player.volume = 0.3 player.start() print("sound played!") except: pass else: await client.send_message( msg.channel, 'voce nao esta em um canal de voz!') while True: try: if player.is_done(): await voice.disconnect() break except: break
def __init__(self, keys): RiotWatcher.__init__(self, keys[0]) self.keys = keys[1:]
class LeagueBot(DiscordBot): def __init__(self, client): super(LeagueBot, self).__init__(client, 'leaguebot') self.storage_manager = CouchbaseManager( os.environ.get('MATCH_HISTORY_BUCKET')) self.riot = RiotWatcher(os.environ.get('RIOT_API_KEY'), default_region=EUROPE_WEST) self.players = self.load_player_list() self.champions = self.load_champions() self.memes = self.load_memes() self.cleverbot = cleverbot.Cleverbot() def load_player_list(self): try: players = self.storage_manager.get('players') except FileNotFoundError: players = {} return players def load_champions(self): try: champs = self.storage_manager.get('champions') except FileNotFoundError: champs = import_champs() self.storage_manager.set('champions', champs) return champs def load_memes(self): try: memes = self.storage_manager.get('memes') except FileNotFoundError: memes = [] return memes @DiscordBot.add_command('add') def add_player(self, *args): """Adds a player to be tracked""" player = ''.join(args) if player.lower() not in self.players: try: summoner = self.riot.get_summoner(name=player) except LoLException as e: if e == error_404: self.send_message( 'Error - Player {} does not exist'.format(player)) else: self.send_message( 'An unknown error occurred, let Matt know!') league_bot_logger.warning(e) return self.players[summoner['name'].lower()] = summoner['id'] self.send_message('Added {} to list of players'.format(player)) self.storage_manager.set('players', self.players) else: self.send_message( '{} already in the list of players'.format(player)) @DiscordBot.add_command('list') def print_players(self, *_): """Prints out the list of players""" if self.players: player_list = '\n' for player, player_id in self.players.iteritems(): try: number_of_games = len( self.storage_manager.get( 'matches-{}'.format(player_id))['games']) except FileNotFoundError: number_of_games = 0 player_list += '{} - {} games\n'.format( player, number_of_games) self.send_message(player_list) else: self.send_message('Player list empty') @DiscordBot.add_command('current-games') def get_current_games(self, *_): for player in self.players: self.get_current_game(player) @DiscordBot.add_command('current-game') def get_current_game(self, *args): """Gets current-game information for the provided player""" player = ''.join(args).lower() if player not in self.players.keys(): try: summoner = self.riot.get_summoner(name=player) except LoLException as e: if e == error_404: self.send_message( 'Error - Player {} does not exist'.format(player)) else: self.send_message( 'An unknown error occurred, let Matt know!') league_bot_logger.warning(e) return else: player_id = summoner['id'] else: player_id = self.players[player] try: curr_game = self.riot.get_current_game(player_id) except LoLException as e: if e == error_404: self.send_message('{} is not in a game'.format(player)) else: league_bot_logger.warning(e) else: game_length = (int(curr_game['gameLength']) / 60) + 3 for participant in curr_game['participants']: if participant['summonerName'].lower() == player.lower(): champion = self.champions[str(participant['championId'])] lolnexus_url = ( 'http://www.lolnexus.com/EUW/search?name={}®ion=EUW' .format(player)) self.send_message( '{} has been in a game for {} minutes - Playing {}\n' 'Link to game: {}'.format(player, game_length, champion, lolnexus_url)) break @DiscordBot.add_command('stats') def summarise_stats(self, *args): """Prints out average stats for the given player""" player = ' '.join(args).lower() if player not in self.players: self.send_message( '{} not in list of players, no stats found'.format(player)) matches = self.storage_manager.get('matches-{}'.format( self.players[player])) stat_averages = defaultdict(list) match_counter = 0 for match in matches['games']: if match['subType'] in WANTED_SUB_TYPES: match_counter += 1 for stat, value in match['stats'].iteritems(): stat_averages[stat].append(value) output = '' for stat, value in OrderedDict(sorted( stat_averages.items())).iteritems(): try: output += '{} - {:.3f}\n'.format( stat, float(sum(value)) / match_counter) except TypeError: pass output += 'Games - {}'.format(match_counter) self.send_message(output) @DiscordBot.add_command('is Neku eloboosted?') def dank_meme(self, *args): """'Nuff said""" self.send_message( "It's not boosting, it's just elo rushing, he is entitled to be there" ) @DiscordBot.add_command('help') def list_commands(self, *args): """Lists all commands and their purpose""" command_str = 'List of commands:' for command in sorted(self.__class__.commands): command_str += '\n{} - {}'.format(command, self.commands[command].__doc__) self.send_message(command_str) @DiscordBot.add_command('meme add') def add_meme(self, *args): """Adds a new meme""" meme = ' '.join(args) if meme not in self.memes: self.memes.append(meme) self.storage_manager.set('memes', self.memes) self.send_message("Added '{}' to list of memes".format(meme)) else: self.send_message('No reposts pls') @DiscordBot.add_command('meme me') def random_meme(self, *args): """Prints a random meme""" self.send_message(random.choice(self.memes)) @DiscordBot.add_command('chat') def ask_cleverbot(self, *args): """Have a conversation with leaguebot""" response = self.cleverbot.ask(' '.join(args)) self.send_message(response)