def test_can_get_league_entries():
config_backup = cassiopeia.configuration.settings
cassiopeia.apply_settings({"global": {"default_region": "NA"}})
summoner = cassiopeia.Summoner(name=SUMMONER_NAME)
summoner.league_entries
# restore global settings to not affect other tests if they are run in one session
cassiopeia.apply_settings(config_backup)
def main() -> None:
args = create_parser().parse_args()
cassiopeia.apply_settings({'logging': {'print_calls': False}})
cassiopeia.set_riot_api_key(args.api_key)
bot = Bot(command_prefix=args.prefix,
description=__doc__,
max_messages=None)
print("starting up")
bot.add_cog(ErrorHandler())
bot.add_cog(MasteryRole(dsn=args.dsn))
bot.add_cog(MasteryTable(dsn=args.dsn))
bot.run(args.token)
def main(argv):
cass.apply_settings(os.path.join(os.getcwd(), 'settings.json'))
all_commands_map = command_map.CommandMap.get_default()
if len(argv) <= 1:
print(f'Invalid usage. Usage: {sys.argv[0]} <command> [args...]\n')
all_commands_map.commands['help'].run([])
sys.exit(1)
try:
command = all_commands_map.commands[argv[1]]
except KeyError:
print(f'Unknown command "{argv[1]}"')
print(f'Usage: {sys.argv[0]} <command> [args...]\n')
all_commands_map.commands['help'].run([])
sys.exit(1)
command.run(argv[2:])
# Write some code to process matches
# FIXME: refactoring.
import db
import cassiopeia as cass
from datapipelines import NotFoundError
from collections import defaultdict
cass.apply_settings('processor-settings.json')
counts = defaultdict(int)
match_ids = db.get_timeline_ids_from_diskstore('store')
for index, match_id in enumerate(match_ids):
try:
match = cass.Match(id=match_id)
match.timeline.load()
match.load()
game_mode = match.mode
if game_mode in (cass.GameMode.classic, cass.GameMode.aram):
for team in match.teams:
for participant in team.participants:
# print(participant.champion.id)
counts[participant.champion.id] += 1
if index != 0 and index % 2000 == 0:
print(index, '/', len(match))
except NotFoundError as e:
pass
import datetime
import cassiopeia as cass
from cassiopeia import Summoner
import discord
from discord.ext import commands
from objects.player import Player
from riotwatcher import ApiError, LolWatcher
from settings import RIOT_API_TOKEN
cass.apply_settings(cass.get_default_config())
cass.set_riot_api_key(RIOT_API_TOKEN)
cass.set_default_region("las")
watcher = LolWatcher(RIOT_API_TOKEN)
default_region = "la2"
class Summoners(commands.Cog):
def __init__(self, bot):
self.bot = bot
@commands.command()
async def info(self, ctx, *, name: str):
"""Display information on a summoner"""
author = ctx.author
player = None
try:
player = Player(name)
except ApiError as err:
if err.response.status_code == 429:
def ready(self):
cass.set_riot_api_key(riot_key())
cass.apply_settings(cass.Settings({"logging": {"print_calls": False}}))
cass.set_default_region(cass.Region.europe_west)
'server_url': os.getenv('API_KERNEL_URL'),
'port': os.getenv('API_KERNEL_PORT')
}
}
elif apiMode == 'riot':
settings['pipeline'] = {
'Cache': {},
'SimpleKVDiskStore': {
'package': 'cassiopeia_diskstore',
'path': cwd + '\\tmp'
},
'DDragon': {},
'RiotAPI': {
'api_key': os.getenv('API_RIOT_KEY')
}
}
else:
exit(1)
lolapi.apply_settings(settings)
region = os.getenv('DEFAULT_REGION')
if region != '':
lolapi.set_default_region(region)
else:
lolapi.set_default_region('EUNE')
# cache champs
champions = lolapi.get_champions()
# constants
API_KEY = 'RGAPI-ed3facc5-b751-4caa-9e38-b8f282455a53'
API_REGION = Region.europe_west
CURRENT_SEASON = Season.season_9
QUEUES = {Queue.ranked_solo_fives}
COMPUTABLE_MATCH_COUNT = 5
OUTPUT_FILE = 'players.json'
player_history = {}
SAVE_AFTER_RECORD = True
TIME_DIFFERENCE_CHECK = 1 # in hours
# library settings
settings = cass.get_default_config()
settings['logging']['print_calls'] = False
cass.apply_settings(settings)
cass.set_riot_api_key(API_KEY) # This overrides the value set in your configuration/settings.
cass.set_default_region(API_REGION)
# functions
def load_players():
global player_history
try:
with open(OUTPUT_FILE, 'r') as f:
player_history = json.load(f)
except:
pass
def save_players():
from sql_tools import *
# CONFIG CONSTANTS
MIN_TIME = 7200
ALLOWED_VERSIONS = ['10.18', '10.19', '10.20', '10.21', '10.22', '10.23']
cass.apply_settings({
'global': {
'version_from_match': 'patch',
'default_region': None
},
'plugins': {},
'pipeline': {
'Cache': {},
'DDragon': {},
'RiotAPI': {
'api_key': 'RIOT_API_KEY'
}
},
'logging': {
'print_calls': False,
'print_riot_api_key': False,
'default': 'WARNING',
'core': 'WARNING'
}
})
cass.set_riot_api_key(API_KEY)
def load_champions():
res = {}
for i in cass.get_champions():
cass.apply_settings({
"global": {
"default_region": None
},
"pipeline": {
"Cache": {
"expirations": {
"ChampionStatusData": datetime.timedelta(hours=6),
"ChampionStatusListData": datetime.timedelta(hours=6),
"Realms": datetime.timedelta(hours=6),
"Versions": datetime.timedelta(hours=6),
"Champion": datetime.timedelta(days=20),
"Rune": datetime.timedelta(days=20),
"Item": datetime.timedelta(days=20),
"SummonerSpell": datetime.timedelta(days=20),
"Map": datetime.timedelta(days=20),
"ProfileIcon": datetime.timedelta(days=20),
"Locales": datetime.timedelta(days=20),
"LanguageStrings": datetime.timedelta(days=20),
"SummonerSpells": datetime.timedelta(days=20),
"Items": datetime.timedelta(days=20),
"Champions": datetime.timedelta(days=20),
"Runes": datetime.timedelta(days=20),
"Maps": datetime.timedelta(days=20),
"ProfileIcons": datetime.timedelta(days=20),
"ChampionMastery": datetime.timedelta(days=7),
"ChampionMasteries": datetime.timedelta(days=7),
"LeagueEntries": datetime.timedelta(hours=6),
"League": datetime.timedelta(hours=6),
"ChallengerLeague": datetime.timedelta(hours=6),
"MasterLeague": datetime.timedelta(hours=6),
"Match": 0,
"Timeline": 0,
"Summoner": datetime.timedelta(minutes=2),
"ShardStatus": datetime.timedelta(hours=1),
"CurrentMatch": 0,
"FeaturedMatches": 0
}
},
"DDragon": {},
"RiotAPI": {
"api_key": os.environ["RIOT_API_KEY"]
},
},
"logging": {
"print_calls": True,
"print_riot_api_key": False,
"default": "WARNING",
"core": "WARNING"
}
})
import cassiopeia as cass
from cassiopeia import Summoner, Queue, Champion, Patch
import csv
from scoutahead.db import ChampionRole, db
import random
from itertools import combinations
region = "NA"
start_patch = "10.9"
end_patch = "10.18"
# Cassiopeia settings
cass.apply_settings('cass_settings.json')
cass.set_default_region(region)
def get_comps(summoners):
if len(summoners) < 5:
# return None
pass
champion_pool = []
# Maps names to champions so we don't have to make individual calls to the API
name_mapping = {
champion.id: champion.name
for champion in cass.get_champions(region=region)
}
count = 0
import json
import requests
from bottle import request, route, run
import cassiopeia as cass
from cassiopeia import Queue
from cassiopeia.core import Summoner, Match
cass.apply_settings("Backend/src/Server/lolApi/cass_config.json")
known_summoners = dict()
http = requests.session()
@route('/summonerId', method='GET')
def get_summoner_id():
summoner_name = request.query.name
summoner = Summoner(name=summoner_name)
return {"id": summoner.id}
@route('/summonerInformation', method='GET')
def get_summoner_information():
summoner_id = request.query.id
if summoner_id in known_summoners:
summoner = known_summoners[summoner_id]
else:
summoner = Summoner(id=summoner_id)
known_summoners[summoner_id] = summoner
'path': cassiopeia_path,
},
'DDragon': {},
},
}
# Set up Cassiopeia, either with local key or proxy kernel
try:
if not os.path.exists('.env'):
raise Exception('No .env file found')
load_dotenv('.env')
cassiopeia.set_riot_api_key(os.getenv('RIOT_API_KEY'))
cassiopeia_settings['pipeline']['RiotAPI'] = {
'api_key': os.getenv('RIOT_API_KEY'),
}
print('USING: Development Key (RIOT\'s servers)')
except Exception:
cassiopeia_settings['pipeline']['Kernel'] = {
'server_url': 'https://mhk-api.zbee.dev',
'port': '443',
}
print('USING: Kernel with key (zbee\'s servers)')
# Load basic settings for Cassiopeia
cassiopeia.apply_settings(cassiopeia_settings)
cassiopeia.set_default_region(settings.region)
# Set up user control
users = hinter.users.Users()
import config, requests
from discord.ext import commands
from bs4 import BeautifulSoup
import cassiopeia as cass
cass.apply_settings(config.casstuff)
gchamps = cass.get_champions(region="NA")
def listToString(lst):
main = ""
for item in lst:
main += item + " "
main = main.strip()
return main
def toMulti(lst):
base = """"""
count = 1
for i in lst:
if count == len(lst):
break
base += i + " \n "
count += 1
base += i
return base
class League(commands.Cog):
#######LEAGUE BLOCK
cass.apply_settings({
"global": {
"version_from_match": "patch",
"default_region": None
},
"pipeline": {
"Cache": {
"expirations": {
"Realms": datetime.timedelta(hours=6),
"Versions": datetime.timedelta(hours=6),
"Champion": 0,
"Rune": 0,
"Item": 0,
"SummonerSpell": 0,
"Map": 0,
"ProfileIcon": 0,
"Locales": datetime.timedelta(days=20),
"LanguageStrings": datetime.timedelta(days=20),
"SummonerSpells": 0,
"Items": 0,
"Champions": 0,
"Runes": 0,
"Maps": 0,
"ProfileIcons": 0,
"ChampionMastery": 0,
"ChampionMasteries": 0,
"LeagueEntries": 0,
"League": 0,
"ChallengerLeague": 0,
"MasterLeague": 0,
"Match": 0,
"Timeline": 0,
"Summoner": 0,
"ShardStatus": datetime.timedelta(hours=1),
"CurrentMatch": 0,
"FeaturedMatches": datetime.timedelta(hours=0.5),
}
},
"DDragon": {},
"RiotAPI": {
"api_key": os.environ['RIOT_API_KEY'],
"request_error_handling": {
"404": {
"strategy": "throw"
},
"429": {
"service": {
"strategy": "exponential_backoff",
"initial_backoff": 1.0,
"backoff_factor": 2.0,
"max_attempts": 4
},
"method": {
"strategy": "retry_from_headers",
"max_attempts": 5
},
"application": {
"strategy": "retry_from_headers",
"max_attempts": 5
}
},
"500": {
"strategy": "exponential_backoff",
"initial_backoff": 1.0,
"backoff_factor": 2.0,
"max_attempts": 4
},
"502": {
"strategy": "exponential_backoff",
"initial_backoff": 1.0,
"backoff_factor": 2.0,
"max_attempts": 4
},
"503": {
"strategy": "exponential_backoff",
"initial_backoff": 1.0,
"backoff_factor": 2.0,
"max_attempts": 8
},
"504": {
"strategy": "exponential_backoff",
"initial_backoff": 1.0,
"backoff_factor": 2.0,
"max_attempts": 4
},
"timeout": {
"strategy": "throw"
}
}
}
},
"logging": {
"print_calls": False,
"print_riot_api_key": False,
"default": "WARNING",
"core": "WARNING"
}
})
'a decent', 'a mediocre', 'a chill', 'an amazing'
]
today = datetime.datetime.now()
start_delta = datetime.timedelta(weeks=1)
last_week = int((today - start_delta).timestamp()) * 1000
client = discord.Client()
conn = sqlite3.connect('../data/data.db')
c = conn.cursor()
config = configparser.ConfigParser()
config.read('../config/config.ini')
cass.apply_settings('../config/cass.json')
cass.set_riot_api_key(config['league']['key'])
cass.set_default_region("NA")
def main():
if len(sys.argv) == 1:
print('Requires more arguments')
return
else:
summoner_name = " ".join(sys.argv[1:]).lower()
if len(summoner_name) > 16:
print('Summoner name is too long!')
return
},
...
}
where `"CHAMPIONGG_KEY"` should be replaced with your champion.gg api key or with an environment variable containing it.
"""
import cassiopeia as cass
from cassiopeia import Champion
config = cass.get_default_config()
config["pipeline"]["ChampionGG"] = {
"package": "cassiopeia_championgg",
"api_key": "CHAMPIONGG_KEY"
}
cass.apply_settings(config)
def get_champions():
annie = Champion(name="Annie", id=1, region="NA")
print(annie.name)
print(annie.championgg.win_rate)
print(annie.championgg.play_rate)
print(annie.championgg.play_rate_by_role)
print(annie.championgg.ban_rate)
print(annie.championgg.games_played)
print(annie.championgg.damage_composition)
print(annie.championgg.kills)
print(annie.championgg.total_damage_taken)
print(annie.championgg.wards_killed)
import cassiopeia import stores from .utils import cassiopeia_init, create_pipeline cassiopeia._configuration.settings.create_pipeline = create_pipeline cassiopeia.datastores.DjangoCache = stores.DjangoCache cassiopeia.datastores.Omnistone = stores.Omnistone cassiopeia.apply_settings(cassiopeia_init())
def setUp(self):
cassiopeia.apply_settings(cassiopeia.get_default_config())
cassiopeia.set_riot_api_key(os.environ.get('RIOT_API_KEY'))
cassiopeia.apply_settings({"global": {"default_region": "NA"}})
from misc import logger, get_sqlstore
logger.debug("Loading config")
from config import config, generate_cassio_conf
from manager import Manager
from crawler import Crawler
from database import SQLParticipantAdditional
import cassiopeia as cass
cass.apply_settings(generate_cassio_conf())
cass.set_default_region(config["region"])
if "api-key" in config:
cass.set_riot_api_key(config["api-key"])
manager = Manager()
sqlstore = get_sqlstore(cass)
from cassiopeia.core import League, ChallengerLeague, MasterLeague, Summoner
from cassiopeia.data import Queue
if config["seed"]["type"] == "LEAGUE":
# Load this league and use it as seeding
league = None
if config["seed"]["id"] == "CHALLENGER":
logger.info("Using challenger league as seed")
league = ChallengerLeague(queue=Queue.ranked_solo_fives)
elif config["seed"]["id"] == "MASTER":
logger.info("Using master league as seed")
league = MasterLeague(queue=Queue.ranked_solo_fives)
else:
logger.info("Using league with id=" + config["seed"]["id"] +
" as seed")
