def __init__(self, args): self.api = None self.key = None self.homies_by_id = {} self.homie_names = set() self.custom_only = False self.classic_only = True self.threshold = 4 self.gen_config = False self.monitor = args.monitor self.output_dir = args.output_dir if args.config: self.read_config(args.config) if args.key: self.key = args.key if args.summoner_list: self.read_summoners(args.summoner_list) if args.gen_config: self.gen_config = args.gen_config if not args.custom_only is None: self.custom_only = args.custom_only if not args.classic_only is None: self.classic_only = args.classic_only if not args.threshold is None: self.threshold = args.threshold if self.key: self.api = riotwatcher.RiotWatcher(self.key, enforce_limits=True)
def riot_context(mock_get: mock.MagicMock) -> MockContext: import riotwatcher api_key = "abcdefg" yield MockContext( api_key, mock_get, riotwatcher.RiotWatcher(api_key), None, )
def migrate_players(bkt): doc = bkt.get('players').value riot = riotwatcher.RiotWatcher(default_region=riotwatcher.EUROPE_WEST, key=os.environ.get('RIOT_API_KEY')) for player_id in doc.itervalues(): summoner = riot.get_summoner(_id=player_id) new_key = 'Player::{}'.format(player_id) bkt.upsert(new_key, summoner) time.sleep(5)
def mock_context(mock_get, request): import riotwatcher api_key = "abcdefg" yield MockContext( api_key, mock_get, riotwatcher.RiotWatcher(api_key, kernel_url=request.param), request.param, )
def add_champions(bkt): riot = riotwatcher.RiotWatcher(default_region=riotwatcher.EUROPE_WEST, key=os.environ.get('RIOT_API_KEY')) champs = riot.static_get_champion_list() champ_dict = {} for champ in champs['data'].itervalues(): champ_dict[int(champ['id'])] = { 'key': champ['key'], 'name': champ['name'] } bkt.upsert('Champions', champ_dict)
def __init__(self, riot=None, report_callback=default_report_callback, report_freq=default_report_freq): if riot is None: riot = riotwatcher.RiotWatcher() self.riot = riot if report_callback is None: report_callback = default_report_callback self.report_callback = report_callback self.report_freq = report_freq
def __init__(self): self.watcher = riotwatcher.RiotWatcher( default_region=riotwatcher.EUROPE_WEST, key='4f973eb3-7400-4eaf-9e6b-05b9ca56068c') self.bkt = Bucket() self.player_dict = self.get_players() self.bkt.upsert('Champions', self.watcher.static_get_champion_list()) while True: for _, v in self.player_dict.iteritems(): self.update_recent_games(v) time.sleep(SLEEP_TIME)
def __init__(self): self.riot = riotwatcher.RiotWatcher( default_region=riotwatcher.EUROPE_WEST, key=os.environ.get('RIOT_API_KEY')) self.storage_manager = CouchbaseManager( os.environ.get('MATCH_HISTORY_BUCKET')) self.player_dict = self.storage_manager.get('players') logger_datapop.info('Setup complete') while True: for _, player_id in self.player_dict.iteritems(): self.update_recent_games(player_id) time.sleep(SLEEP_TIME) self.player_dict = self.get_players()
def __init__(self): self.riot = riotwatcher.RiotWatcher( default_region=riotwatcher.EUROPE_WEST, key=os.environ.get('RIOT_API_KEY')) self.bucket = Bucket('couchbase://{}/{}'.format( os.environ.get('DB_HOST', 'localhost'), os.environ.get('DB_BUCKET_MATCH_HISTORY', 'match_history'))) self.players = self.get_players() logger_datapop.info('Setup complete') while True: for player in self.players: self.update_recent_games(player['id']) time.sleep(SLEEP_TIME) self.players = self.get_players()
def __init__(self): # read info.txt file info = {} with open("info.txt", "r") as f: for line in f: (key,value) = line.split() info[key] = value # setup bot updater = Updater(token=info['token'], use_context=True) self.dispatcher = updater.dispatcher updater.start_polling() # setup Neo4j driver self.neo4j_uri = "bolt://localhost:7687" self.neo4j_driver = GraphDatabase.driver(self.neo4j_uri, auth=("neo4j", "password")) # setup logging logging.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO) self.logger = logging.getLogger() # create handlers help_handler = CommandHandler('help', self.help) subscribe_to_summoner_handler = CommandHandler('subscribe_to', self.subscribe_to_summoner) list_subscriptions_handler = CommandHandler('subscriptions', self.list_subscriptions) unsubscribe_from_handler = CommandHandler('unsubscribe_from', self.unsubscribe_from_summoner) clear_subs_handler = CommandHandler('clear_subs', self.clear_subs) # add handlers to dispatcher self.dispatcher.add_handler(subscribe_to_summoner_handler) self.dispatcher.add_handler(list_subscriptions_handler) self.dispatcher.add_handler(unsubscribe_from_handler) self.dispatcher.add_handler(clear_subs_handler) self.dispatcher.add_handler(help_handler) #setup all we need in order to scrape self.summoner_list = [] self.dict_summ_last_status = {} # riotwatcher self.region = 'euw1' self.watcher = rw.RiotWatcher(info['riot_developer_key']) while True: with self.neo4j_driver.session() as sess: l = sess.read_transaction(get_all_summoners) self.logger.info(f"Summoners: {l}") for s in l: self.check_summoner_activity(s) time.sleep(POLL_SECONDS)
def main(): w = rw.RiotWatcher(constants.riot_id) cur_data = {} with open('player_tiers.csv') as csvfile: reader = csv.DictReader(csvfile) for row in reader: cur_data[row['user_id']] = row ids_to_crawl = {row['user_id'] for row in cur_data.viewvalues() if row['tier'] in ["SILVER"] and row['crawled'] == '0'} total_ids = set(cur_data.viewkeys()) new_data = copy.deepcopy(cur_data) for x in range(100): cur_id = ids_to_crawl.pop() print("Crawling: {0}".format(cur_id)) neighbor_ids = get_neighbors(w, cur_id) neighbor_ids -= total_ids neighbor_ids = list(neighbor_ids)[:40] neighbor_tiers = get_tiers(w, neighbor_ids) for n_id, n_tier in neighbor_tiers.viewitems(): new_data[n_id] = { 'user_id': n_id, 'tier': n_tier, 'crawled': 0, } ids_to_crawl.add(n_id) total_ids |= set(neighbor_tiers.keys()) new_data[cur_id]['crawled'] = 1 sorted_rows = new_data.values() sorted_rows.sort(key=lambda row: (1-int(row['crawled']), row['user_id'])) with open('player_tiers.csv', 'w') as csvout: writer = csv.DictWriter(csvout, fieldnames=['user_id', 'tier', 'crawled']) writer.writeheader() writer.writerows(sorted_rows)
def __init__(self, interface: CommandInterface): super().__init__(interface) self._riotwatcher = riotwatcher.RiotWatcher( api_key=self.config["Lol"]["token"]) if self.interface.name == "telegram": self.loop.create_task(self._updater(900))
def mock_context(mock_get): import riotwatcher api_key = "abcdefg" return MockContext(api_key, mock_get, riotwatcher.RiotWatcher(api_key))
def main(): id_to_name = get_id_to_name(riotwatcher.RiotWatcher()) make_columns_to_id(id_to_name)
import os import riotwatcher try: token = os.environ['LEAGUE_TOKEN'] except KeyError: raise Exception('No LEAGUE_TOKEN found. See developer.riotgames.com') riot = riotwatcher.RiotWatcher(token) def get_champ(champ_filter=None): champs = [] for champ in riot.static_get_champion_list()['data'].values(): champs.append( dict(id=champ['id'], key=champ['key'], name=champ['name'])) if not champ_filter: continue if champ_filter == champ['name'].lower(): return champs[-1:] if champ_filter: raise Exception('Could not find champion {}', champ_filter) return champs def get_item(item_filter=None): items = [] for item in riot.static_get_item_list()['data'].values():
import json from time import sleep import mysql.connector import cassiopeia as cass import riotwatcher as rw cass.set_riot_api_key("RIOT-API-KEY") cass.set_default_region("NA") matchmm = 3154904286 # 3152058384 watcher = rw.RiotWatcher('RIOT-API-KEY') my_region = 'na1' mydb = mysql.connector.connect(host="localhost", user="******", passwd="", database="lol_database") mycursor = mydb.cursor() def getRedSideByMatch(id): return cass.get_match(id).red_team.to_json() def getBlueSideByMatch(id): return cass.get_match(id).blue_team.to_json()
def setup_test_data(): import riotwatcher, collect_summoner_ids, data_path riot = riotwatcher.RiotWatcher() with open(data_path.test_store_champions_usage_data, 'w') as f: collect_summoner_ids.store_summoner_ids(f, riot, 1, 30890339)
# -*- coding: utf-8 -*- __author__ = 'Vance' import riotwatcher as rw import json import time import os w = rw.RiotWatcher('a66b170f-ecc4-4173-84cc-9371cb61ab24') player_list = [] all_match_ids = [] player_offset = 0 def get_match_from_summoner_name(summoner_name): global player_list global all_match_ids ret = 0 print 'Player:', summoner_name me = w.get_summoner(name=summoner_name) #print me my_id = me['id'] #print my_id #print w.get_ranked_stats(my_id) try: my_match_list = w.get_match_list(summoner_id=my_id, begin_time=1441065600000, ranked_queues='RANKED_SOLO_5x5') #patch 5.16 except: print 'Error in API' my_match_list = [] #print my_match_list if 'matches' in my_match_list: for match in my_match_list['matches']: #print match
def scrape(store, api_key, region, summoner_name, empty_weeks_to_stop=10, with_timeline=False, progress_callback=NotImplemented): """ Scrape the matchlist and save all matches in *store*. progress_callback (function): See #scrape_default_progress_callback(). """ watcher = riotwatcher.RiotWatcher(api_key) summoner = watcher.summoner.by_name(region, summoner_name) if progress_callback is NotImplemented: progress_callback = scrape_default_progress_callback # The Riot API only allows a time interval of one week, thus we # have to find the matches in chunks of one week. one_week = 1000 * 3600 * 24 * 7 user_abort = False for interval in store.suggest_search_intervals(summoner['accountId']): if user_abort: break if interval[1] is None: interval = (interval[0], int(time.time() * 1000)) # TODO: that region's current time empty_weeks_passed = 0 while empty_weeks_passed < empty_weeks_to_stop: begin_time = interval[1] - one_week if interval[0] and begin_time < interval[0]: begin_time = interval[0] try: matches = watcher.match.matchlist_by_account( region, summoner['accountId'], begin_time=begin_time, end_time=interval[1])['matches'] except requests.HTTPError as e: if e.response.status_code == 400: # request too far in the past? break if e.response.status_code == 404: # no matches found continue raise interval = (interval[0], begin_time) # shrink the interval if not matches: empty_weeks_passed += 1 continue # Sort by newest first, for consistency with lookback order and the # FileStore --continuous option. matches.sort(key=lambda x: -x['timestamp']) matches = [m for m in matches if not store.has_match(m['gameId'], m['timestamp'])] if progress_callback: event_data = {'beginTime': begin_time, 'matchCount': len(matches)} if progress_callback('matchlist', event_data) is False: user_abort = True break empty_weeks_passed = 0 for index, match_info in enumerate(matches): if progress_callback: event_data = {'matchIndex': index, 'matchCount': len(matches)} if progress_callback('match', event_data) is False: user_abort = True break match_data = watcher.match.by_id(region, match_info['gameId']) timeline = None if with_timeline: try: timeline = watcher.match.timeline_by_match(region, match_info['gameId']) except requests.HTTPError as e: if e.response.status_code != 404: # no timeline data raise timeline = {} # indicate that no timeline data is present store.store_match( match_info['gameId'], match_info['timestamp'], match_data, timeline ) return not user_abort
import riotwatcher watcher = riotwatcher.RiotWatcher("LOLOL") print(watcher.champion.rotations("TRLH4")) watcher.summoner.by_name("TRLH4", "Cobular")
linha = {} linha[fields[0]] = IdSummoner linha[fields[1]] = IdAccount linha[fields[2]] = tier linha[fields[3]] = rank if testarPlayer(IdAccount): print("salvando player") print(linha) csv_writer.writerow(linha) arq = open("key.txt") key = arq.readline() watcher = riotwatcher.RiotWatcher(key) ## criar uma lista com os jogadores que vai comecar players = open("playersStart.txt") ## parametros partidasPorPlayer = 5 regiao = "br1" for nome in players.readlines(): nome = nome.strip() playerDados = watcher.summoner.by_name(region=regiao, summoner_name=nome) print(playerDados) idSum = playerDados["accountId"] try: partidas = watcher.match.matchlist_by_account(region=regiao, account_id=idSum, queue=420)
import json, riotwatcher, collect_summoner_ids, collect_champions_usage riot = riotwatcher.RiotWatcher() #store_summoner_ids('summoner_ids_plat', riot, 10000, 30890339) #store_champions_usage('summoner_ids', 'champions_usage', riot) # for i in reversed(range(10)): # print('i = '+str(i)) # store_champions_usage('data/summoner_ids_plat_'+str(i), 'data/champions_usage_plat_'+str(i), riot) #collect_summoner_ids.collect_master_summoner_ids() from data_path import summoner_ids_master, champions_usage_master collect_champions_usage.store_champions_usage(summoner_ids_master, champions_usage_master, riot)