def create_all_stats_from_id(id_: str, rank: int = None, replay_ids: List[str] = None, playlist: int = 13, win: bool = None, session=None) -> PlayerDataPoint: game_count = player_wrapper.get_total_games(session, id_) if game_count == 0: raise UserHasNoReplays() if rank is None: rank = get_rank(id_) averaged_stats = player_stat_wrapper.get_averaged_stats(session, id_, redis=get_redis(), raw=True, rank=rank, replay_ids=replay_ids, playlist=playlist, win=win) if len(id_) == 11 and id_[0] == 'b' and id_[-1] == 'b': names_and_counts: List[Tuple[str, int]] = session.query(PlayerGame.name, func.count(PlayerGame.name).label('c')) \ .filter(PlayerGame.player == id_) \ .group_by(PlayerGame.name).order_by(desc('c'))[:5] id_ = names_and_counts[0][0] playstyle_data_raw: PlayerDataPoint = PlayerDataPoint(name=id_, data_points=[ DataPoint(explanations[ k].field_rename if k in explanations else k, averaged_stats[k]) for k in averaged_stats ]) return playstyle_data_raw
def create_from_id(cls, id_: str, raw=False, rank=None, replay_ids=None, playlist=13, win=None, session=None): game_count = player_wrapper.get_total_games(session, id_) if game_count == 0: raise UserHasNoReplays() if rank is None: rank = get_rank(id_) try: averaged_stats = player_stat_wrapper.get_averaged_stats(session, id_, redis=get_redis(), raw=raw, rank=rank, replay_ids=replay_ids, playlist=playlist, win=win) except NoResultFound: raise NoReplaysForPlaylist(playlist) spider_charts_groups = player_stat_wrapper.get_stat_spider_charts() play_style_chart_datas: List[PlayStyleChartData] = [] for spider_chart_group in spider_charts_groups: title = spider_chart_group['title'] chart_data_points = [ ChartDataPoint(name=explanations[name].short_name if name in explanations else name, value=averaged_stats[name]) for name in spider_chart_group['group'] ] play_style_chart_datas.append(PlayStyleChartData(title, chart_data_points)) return PlayStyleResponse( chart_datas=play_style_chart_datas, show_warning=game_count <= cls.showWarningThreshold )
def ping(session=None): r = get_redis() result = r.get('global_stats') if result is not None: return jsonify({'result': json.loads(result)}) elif is_local_dev(): wrapper = global_stats_wrapper.GlobalStatWrapper() result = wrapper.get_global_stats(sess=session, with_rank=False) return jsonify(result)
def vanity_to_steam_id(vanity): key = 'vanity_' + vanity try: redis_instance = get_redis() except: redis_instance = None if redis_instance is not None: match = redis_instance.get(key) if match is not None: return json.loads(match) steam_url = 'http://api.steampowered.com/ISteamUser/ResolveVanityURL/v0001/?key={steamKey}&vanityurl={steamID}'.format( steamKey=STEAM_API_KEY, steamID=vanity) resp = requests.get(steam_url) resp.raise_for_status() if resp.json()['response']['success'] == 42: return None else: if redis_instance is not None: redis_instance.set(key, json.dumps(resp.json()), ex=60 * 60 * 24) return resp.json()
def steam_id_to_profile(steam_id): key = 'steam_id_' + steam_id try: redis_instance = get_redis() except: redis_instance = None if redis_instance is not None: match = redis_instance.get(key) if match is not None: return json.loads(match) profile_url = 'http://api.steampowered.com/ISteamUser/GetPlayerSummaries/v0002/?key={steamKey}&steamids={steamID}'.format( steamKey=STEAM_API_KEY, steamID=steam_id) resp = requests.get(profile_url) resp.raise_for_status() if len(resp.json()['response']['players']) == 0: return None else: if redis_instance is not None: redis_instance.set(key, json.dumps(resp.json()), ex=60 * 60 * 24) profile = resp.json()['response']['players'][0] add_or_update_steam_player(profile) # return the normal JSON to not change anything else return resp.json()
def get_rank_batch(ids, offline_redis=None, use_redis=True): """ Gets a batch of ranks based on ids. Returns fake data if there is no API key available. :param ids: ids to get from RLAPI :param offline_redis: Redis to use if not in the application context :return: rank information """ rank_datas_for_players = {} if fake_data or RL_API_KEY is None: return make_fake_data(ids) try: _redis = get_redis() except KeyError: _redis = None ids_to_find = ids except RuntimeError: # we're not in application context, use our own redis if offline_redis is None and use_redis: offline_redis = redis.Redis(host='localhost', port=6379) _redis = offline_redis if _redis is not None: ids_to_find = [] for steam_id in ids: try: result = _redis.get(steam_id) except redis.ConnectionError: logger.error('Error connecting to redis') _redis = None ids_to_find = ids break if result is not None: # logger.debug('Rank is cached') rank_datas_for_players[steam_id] = json.loads( result.decode("utf-8")) elif steam_id != '0': ids_to_find.append(steam_id) else: rank_datas_for_players['0'] = {} if len(ids_to_find) == 0: return rank_datas_for_players else: logger.debug(ids_to_find) else: ids_to_find = ids url = "https://api.rocketleague.com/api/v1/steam/playerskills/" headers = { 'Authorization': f'Token {RL_API_KEY}', 'Referer': 'http://api.rocketleague.com' } ids_dict = list( filter(lambda x: x['platformId'] == 'steam', [{ 'platformId': get_platform_id(i), 'uniqueId': i } for i in ids_to_find])) post_data = {'player_ids': [p['uniqueId'] for p in ids_dict]} data = requests.post(url, headers=headers, json=post_data) if data.status_code >= 300: return {**rank_datas_for_players, **get_empty_data(ids_to_find)} try: data = data.json() except Exception as e: print(e) return get_empty_data(ids) if 'detail' in data: return {str(i): {} for i in ids} for player in data: rank_datas = {} unique_id = player['user_id'] names = { '13': 'standard', '11': 'doubles', '10': 'duel', '12': 'solo', '27': 'hoops', '28': 'rumble', '29': 'dropshot', '30': 'snowday' } if 'player_skills' in player: found_modes = [] for playlist in player['player_skills']: if 'tier' in playlist and str( playlist['playlist']) in names: # excludes unranked mode = names[str(playlist['playlist'])] found_modes.append(mode) rank_data = { 'mode': mode, 'rank_points': playlist['skill'], 'tier': playlist['tier'], 'division': playlist['division'], 'string': tier_div_to_string(playlist['tier'], playlist['division']) } rank_datas[str(playlist['playlist'])] = rank_data for idx, mode in names.items(): if mode not in found_modes: rank_datas[idx] = { 'mode': mode, 'rank_points': 0, 'tier': 0, 'division': 0, 'string': tier_div_to_string(None) } if _redis is not None: _redis.set(unique_id, json.dumps(rank_datas), ex=2 * 60) rank_datas_for_players[unique_id] = rank_datas else: rank_datas_for_players[unique_id] = {} return rank_datas_for_players
def create_by_rank() -> List['GlobalStatsGraph']: r = get_redis() return json.loads(r.get('global_stats_by_rank'))
def create() -> List['GlobalStatsGraph']: r = get_redis() return json.loads(r.get('global_distributions'))