def _prepare(self, id_or_name):
"""
Get's the Teams from a live game by Summoner Name or from an old Match by Match ID
:param id_or_name: either a Summoner Name or a Match ID
:return: iterator of the prepared teams; if not exits None
"""
# Setting the Api key for Cassiopeia and the default region
cass.set_riot_api_key(self.key)
cass.set_default_region('EUW')
if type(id_or_name) is str:
summoner = cass.get_summoner(name=id_or_name, region='EUW')
try:
current_game = summoner.current_match()
except Exception as e:
print(str(e))
return None
else:
try:
current_game = cass.get_match(id_or_name, region='EUW')
except Exception as e:
print(str(e))
return None
if current_game.mode == cass.data.GameMode.aram:
print('there are no lanes in Aram')
return None
# Preparing the participants per team
for team in current_game.teams:
yield self._prepare_team(team), team
def __init__(self, region, key):
if region.upper() not in validRegions:
raise Exception("Invalid Region")
cass.set_riot_api_key(key)
cass.set_default_region(region)
self.region = region
def init(bot: commands.Bot, cfg: dict):
config.update(cfg[__name__])
riotapi.set_default_region(config["api_region"])
riotapi.set_riot_api_key(config["api_key"])
from .trivia import LoLTrivia
bot.add_cog(LoLTrivia(bot))
def buttonClick():
if inputNick.get() != "":
summoner = cassiopeia.get_summoner(name=inputNick.get(),
region=serversList.get())
if summoner.exists:
cassiopeia.set_default_region(serversList.get())
t = threading.Thread(target=showSummoners, args=[summoner])
t.start()
def __init__(self, riot_api_key, default_region="NA"):
"""
:param riot_api_key: the key you will be using today
"""
self.riot_api_key = riot_api_key
cass.set_riot_api_key(riot_api_key)
cass.set_default_region(default_region)
def __init__(self, client):
self.characters = string.ascii_uppercase + string.digits
self.file_service = FileService()
self.discord_service = DiscordService(client)
self.client = client
self.command_texts = self.file_service.load_json_file(
"resources/command_texts.json")
self.settings = self.file_service.load_json_file(
"resources/settings.json")
self.verify_pending = []
cass.set_riot_api_key(self.settings["riot_api_key"])
cass.set_default_region("TR")
def setup_cassiopeia(api_key, region="NA"):
"""
Sets up Cassiopeia with a given api_key and region
Parameters
----------
api_key : string
The API key that will be used by Cassiopeia to communicate with the Riot
Games API
region : string (defaults to "NA" - North America)
The region that will be used by Cassiopeia when searching for a given user.
Cassiopeia can only search for a user in the region where their account was
created. For example when searching for a user in North America, cassiopeia
must be set up with the "NA" region.
Returns
-------
Nothing is printed if there are no errors setting up Cassiopeia to
communicate with the Riot API.
If the provided region is not valid, a list of all the supported regions will
be printed and the program will exit.
"""
cass.set_riot_api_key(api_key) # Set the api key for cassiopeia to use
try:
# Try to set the region of cassiopeia to our provided region
cass.set_default_region(region)
except:
# Catch errors when the region is not valid, and print the valid list of
# supported regions
print(
"Region was not valid. Please enter a valid region from the list",
"below:")
region_list = [
"NA", "BR", "EUNE", "LAN", "LAS", "OCE", "RU", "TR", "JP", "PH",
"SG", "TW", "VN", "TH", "KR", "CN", "PBE"
]
# Cycle through the region list and print each region with a dash in front
for region in region_list:
print("-", region)
#Exit the program, since there was error
os._exit(1)
def get_summ(summ="Fodder1969", region="NA"):
cass.set_riot_api_key(
"RGAPI-18f8d037-17c8-4add-b6b5-0eac3011adb0"
) # This overrides the value set in your configuration/settings.
cass.set_default_region("NA")
output = {}
summoner = cass.get_summoner(name=summ)
output[
'summoner'] = "{name} is a level {level} summoner on the {region} server.".format(
name=summoner.name, level=summoner.level, region=summoner.region)
champions = cass.get_champions()
mastery_champions = summoner.champion_masteries.filter(
lambda cm: cm.level >= 6)
output['champ'] = "He enjoys playing champions such as {name}.".format(
name=[cm.champion.name for cm in mastery_champions])
return output
def __init__(self, api_key, region):
self.valid_regions = VeigarStatics.get_valid_regions()
self.cass_worker_manager = CassWorkerManager()
if api_key is None:
raise RuntimeError("Bad API Key: {0}".format(api_key))
cass.set_riot_api_key(api_key)
logger.info("Setting Riot API Key")
# set region
if region in self.valid_regions:
logger.info("Setting Region: {0} ".format(region))
cass.set_default_region(region)
else:
logger.info(
"Setting to [DEFAULT] Region: {0} ".format(DEFAULT_REGION))
cass.set_default_region(DEFAULT_REGION)
async def summoner(ctx, region, *, nam):
cass.set_riot_api_key(
"ba8b90da"
) # This overrides the value set in your configuration/settings.
try:
cass.set_default_region(region)
summoner = cass.get_summoner(name=str(nam))
good_with = summoner.champion_masteries.filter(
lambda cm: cm.level >= 6)
q = str(summoner.name)
q = str.title(q)
x = str(summoner.region)
x = x[7:]
x = str.title(x)
user = nam.replace(' ', '+')
link = "http://" + region + ".op.gg/summoner/userName="******"Summoner Info",
description="Here's what I could find",
color=0xff71ce)
embed.add_field(name="Summoner Name", value=q, inline=True)
embed.add_field(name="Summoner Level",
value="Level {}".format(summoner.level),
inline=True)
embed.add_field(name="Region", value=x, inline=True)
embed.add_field(name="Good With (M6 Or Higher)",
value=[cm.champion.name for cm in good_with],
inline=True)
embed.add_field(name="OP.GG Link", value=link, inline=True)
embed.set_footer(text="League of Legends")
embed.set_thumbnail(url=str(icons))
await client.say(embed=embed)
except commands.CommandOnCooldown:
await client.say("Command is on Cooldown 3 Uses Per 5 Second")
except Exception as e:
await client.say("No Summoner Found Or Region Is Wrong!")
import cassiopeia as cass
import os
from cassiopeia import Summoner
import datetime
import pycurl
import certifi
import arrow
curl = pycurl.Curl()
curl.setopt(pycurl.CAINFO, certifi.where())
API_KEY = os.environ.get("RIOT_API_KEY")
cass.set_riot_api_key(API_KEY)
cass.set_default_region("NA")
person = "snowcola"
summoner = Summoner(name=person, region="NA")
positions = summoner.league_positions
print(f"{positions.fives.tier} {positions.fives.division}")
#print(f"{wins} {total_games} {wins/total_games*100}")
def __init__(self, region="EUNE"):
cass.set_default_region(region)
cass.set_riot_api_key(config("RIOT_API"))
import config
import random
import cassiopeia as cass
# This overrides the value set in your configuration/settings.
cass.set_riot_api_key(config.API_KEY_CAMILO)
cass.set_default_region("LAN")
summoner = cass.get_summoner(name="Santoyft")
champions = cass.get_champions()
good_with = summoner.champion_masteries.filter(lambda cm: cm.level == 7)
for i in good_with:
print(i)
historial = summoner.match_history()
for data in historial[:5]:
print(data)
from datetime import datetime
import hashlib
import sys
from funcoes import data, email, usuario, criador_de_conta, functions, conta, bd1, equipes
from cassiopeia import Champion, Champions
import cassiopeia as cass
from validador import email, usuario, data
from utils.senha import gerador
import smtplib, ssl
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
cass.set_riot_api_key(
"RGAPI-88430039-1aec-4fba-b04c-9634d1bf52d73"
) # This overrides the value set in your configuration/settings.
cass.set_default_region("BR")
#cores
class color:
PURPLE = '\033[95m'
CYAN = '\033[96m'
DARKCYAN = '\033[36m'
BLUE = '\033[94m'
GREEN = '\033[92m'
YELLOW = '\033[93m'
RED = '\033[91m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
END = '\033[0m'
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:
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
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)
async def lol(self, ctx):
def check3(m):
return m.content and m.author == ctx.author
embed = utils.baseEmbed()
embed.description = self.zt.lang(ctx, "Lol")["Embed2"][0]
embed.timestamp = ctx.message.created_at
a = await ctx.send(embed=embed)
await ctx.message.delete()
try:
msg = await self.zt.wait_for('message', check=check3, timeout=180)
region = msg.content
cass.set_default_region(region)
embed1 = utils.baseEmbed()
embed1.description = self.zt.lang(ctx, "Lol")["Embed2"][1]
embed1.timestamp = ctx.message.created_at
await a.edit(embed=embed1)
try:
await msg.delete()
except:
pass
msg2 = await self.zt.wait_for('message', check=check3, timeout=180)
nickname = msg2.content
summoner = cass.get_summoner(name=nickname)
try:
await msg2.delete()
except:
pass
await a.delete()
champ = " "
try:
for mastery in summoner.champion_masteries[:5]:
champ += ("**• {}:** ``{}``\n".format(
mastery.champion.name,
mastery.points).replace(" ", ""))
except:
pass
embed2 = utils.baseEmbed()
embed2.description = "**Perfil de " + summoner.name + "**"
embed2.timestamp = ctx.message.created_at
embed2.set_thumbnail(url=summoner.profile_icon.url)
embed2.add_field(name=self.zt.lang(ctx, "Lol")["Embed"][0],
value=f'**{summoner.name}**',
inline=False)
embed2.add_field(name=self.zt.lang(ctx, "Lol")["Embed"][1],
value=f'**{summoner.level}**',
inline=False)
try:
embed2.add_field(name=self.zt.lang(ctx, "Lol")["Embed"][2],
value=f'**{summoner.rank_last_season}**',
inline=False)
except:
pass
try:
embed2.add_field(name=self.zt.lang(ctx, "Lol")["Embed"][3],
value=(f'\n{champ}').replace("[", "").replace(
"'", "").replace("]", "").replace(
",", "\n").replace('"', ''),
inline=False)
except:
pass
await ctx.send(embed=embed2)
except Exception as e:
embed3 = utils.baseEmbed()
embed3.description = f'<{self.zt.emoji("Error")}> **| {self.zt.lang(ctx, "Lol")["Embed"][4]}**'
await ctx.send(embed=embed3)
import discord
import requests
import cassiopeia
import json
import spotipy
from apikeys import *
client = discord.Client()
auth = spotipy.oauth2.SpotifyClientCredentials(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET)
spotify = spotipy.Spotify(client_credentials_manager=auth)
location = "https://na1.api.riotgames.com/" #change this for other regions
cassiopeia.set_riot_api_key(RIOT_APIKEY)
cassiopeia.set_default_region("NA")
champs = cassiopeia.get_champions()
@client.event
async def on_ready():
print('We have logged in as {0.user}'.format(client))
@client.event
async def on_message(message):
if message.author == client.user:
return
if message.content.startswith('~hello'):
await message.channel.send('Hello!')
elif message.content.startswith('~lol'):
xs = message.content.split(' ')
import cassiopeia as kassadin
import keys
kassadin.set_riot_api_key(keys.dank_keys())
kassadin.set_default_region("NA")
name = input("Enter first and last name ")
userName = input("What is your username in game")
summoner = kassadin.get_summoner(name=userName)
level = summoner.level
rank = summoner.league_entries
this_mans_champion_masteries = summoner.champion_masteries
favoriteRoles = []
while True:
roles = input("List your favorite roles to play")
if roles == "Q":
break
else:
favoriteRoles.append(roles)
favoriteChampions = []
while True:
champions = input("List your favorite champions to play as of late (just to make your profile up to date)")
if champions == "Q":
break
else:
favoriteChampions.append(champions)
def player_report(player_name, user_name, player_level, player_role, player_favorite_champions, player_rank, this_mans_champion_masteries):
print("=== LEAGUE PLAYER REPORT ===")
print(f"Full name is {player_name}")
print(f"Username is {user_name}")
print(f"Level is {player_level}")
async def live(ctx, name: str = None):
if name == None:
await ctx.send('Введите никнейм призывателя')
await ctx.message.delete()
else:
await ctx.message.delete()
key = os.environ.get('RIOT')
cass.set_riot_api_key(key)
cass.set_default_region("RU")
summoner = cass.get_summoner(name=name)
match = cass.get_current_match(summoner)
rt = summoner.current_match.red_team.participants
rteam = ""
bteam = ""
masters = {
'7': '<:Level_7:736291517676912660>',
'6': '<:Level_6:736291517592764426>',
'5': '<:Level_5:736291517416603658>',
'4': '<:Level_4:736291517068738631>',
}
tiers = {
'Iron': '<:Iron:736282364874850386>',
'Bronze': '<:Bronze:736282364984164503>',
'Silver': '<:Silver:736282365177102436>',
'Gold': '<:Gold:736282364866723861>',
'Platinum': '<:Platinum:736282365252337724>',
'Diamond': '<:Diamond:736282364795420773>',
'Master': '<:Master:736282365202006131>',
'Grandmaster': '<:Grandmaster:736282364849684531>',
'Challenger': '<:Challenger:736282365504127047>',
}
for x in rt:
cm = ''
tier = ''
try:
tier = str(x.summoner.league_entries[0].tier)
tier = tiers[tier]
cmm = cass.get_champion_mastery(x.summoner,
x.champion,
region='RU')
cm = masters[str(cmm.level)]
except:
pass
rteam = rteam + '\n' + '(' + str(
x.summoner.level
) + ')' + x.summoner.name + ' - ' + cm + x.champion.name + ' ' + tier
bt = summoner.current_match.blue_team.participants
for x in bt:
cm = ''
tier = ''
try:
tier = str(x.summoner.league_entries[0].tier)
tier = tiers[tier]
cmm = cass.get_champion_mastery(x.summoner,
x.champion,
region='RU')
cm = masters[str(cmm.level)]
except:
pass
bteam = bteam + '\n' + '(' + str(
x.summoner.level
) + ')' + x.summoner.name + ' - ' + cm + x.champion.name + ' ' + tier
mode = match.map.name
ava = summoner.profile_icon.url
t = 'Лайв игра: ' + name
em = discord.Embed(title=t, color=0xf5f5f5)
em.add_field(name='Синяя команда:', value=bteam, inline=True)
em.add_field(name='Красная команда:', value=rteam, inline=True)
em.set_footer(text=str(mode), icon_url=ava)
await ctx.send(embed=em)
def index(request):
cass.set_riot_api_key("RGAPI-daa909e6-146f-4c9d-a03a-2ff08bac37be")
cass.set_default_region("NA")
na_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5')
# euw_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='EUW')
# eune_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='EUNE')
# kr_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='KR')
# jp_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='JP')
# br_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='BR')
# ru_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='RU')
# lan_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='LAN')
# las_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='LAS')
# oce_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='OCE')
# tr_challenger_players = cass.get_challenger_league(queue='RANKED_SOLO_5x5', region='TR')
for p in na_challenger_players:
obj, created = NA_Pros.objects.update_or_create(
summoner_ID=p.summoner.id,
defaults={'summoner_name': p.summoner.name})
if created:
print('Created entry: ' + obj.summoner_name)
else:
print('Found entry: ' + obj.summoner_name)
# for p in euw_challenger_players:
# obj, created = EUW_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in eune_challenger_players:
# obj, created = EUNE_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in kr_challenger_players:
# obj, created = KR_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in jp_challenger_players:
# obj, created = JP_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in br_challenger_players:
# obj, created = BR_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in ru_challenger_players:
# obj, created = RU_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in lan_challenger_players:
# obj, created = LAN_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in las_challenger_players:
# obj, created = LAS_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in oce_challenger_players:
# obj, created = OCE_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in tr_challenger_players:
# obj, created = TR_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
na_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5')
# euw_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='EUW')
# eune_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='EUNE')
# kr_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='KR')
# jp_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='JP')
# br_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='BR')
# ru_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='RU')
# lan_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='LAN')
# las_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='LAS')
# oce_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='OCE')
# tr_master_players = cass.get_master_league(queue='RANKED_SOLO_5x5', region='TR')
for p in na_master_players:
obj, created = NA_Pros.objects.update_or_create(
summoner_ID=p.summoner.id,
defaults={'summoner_name': p.summoner.name})
if created:
print('Created entry: ' + obj.summoner_name)
else:
print('Found entry: ' + obj.summoner_name)
# for p in euw_master_players:
# obj, created = EUW_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in eune_master_players:
# obj, created = EUNE_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in kr_master_players:
# obj, created = KR_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in jp_master_players:
# obj, created = JP_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in br_master_players:
# obj, created = BR_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in ru_master_players:
# obj, created = RU_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in lan_master_players:
# obj, created = LAN_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in las_master_players:
# obj, created = LAS_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in oce_master_players:
# obj, created = OCE_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
# for p in tr_master_players:
# obj, created = TR_Pros.objects.update_or_create(summoner_ID=p.summoner.id, defaults={'summoner_name':p.summoner.name})
# if created:
# print('Created entry: ' + obj.summoner_name)
# else:
# print('Found entry: ' + obj.summoner_name)
#
return render(request, 'getpros/header.html')
# add participant info to table
durations.append(match.duration.seconds)
champions.append(p.champion.name)
wins.append(p.team.win)
kills.append(p.stats.kills)
deaths.append(p.stats.deaths)
df = pd.DataFrame(
list(zip(durations, champions, wins, kills, deaths)),
columns=['durations', 'champions', 'win', 'kills', 'deaths'])
return df
# set up riot / discord API
cass.set_riot_api_key(secrets.riot_token)
cass.set_default_region("OCE")
discord_token = secrets.discord_token
client = discord.Client()
# bot command prefix
prefix = '&karg'
# bot events
# bot is connected and ready
@client.event
async def on_ready():
for guild in client.guilds:
print(f'Connected to {guild.name} (id: {guild.id})')
import random
import cassiopeia as cass
api_key = 'api goes here'
cass.set_riot_api_key(api_key)
cass.set_default_region('NA')
summoner = cass.get_summoner(name='Kalturi')
print(
f'{summoner.name} is a level {summoner.level} cummoner on the {summoner.region} server'
)
champions = cass.get_champions()
random_champion = random.choice(champions)
print(f'He enjoys playing champions such as {random_champion.name}')
def to_dict(self):
return {
"champion": self.campione.name,
"kills": round(self.kills / self.games, 2),
"deaths": round(self.deaths / self.games, 2),
"assists": round(self.assists / self.games, 2),
"cs/min": round(self.cs / self.time, 2),
"winrate": str(round(self.wins / self.games, 2) * 100) + "%",
"games": self.games,
"kda": round((self.kills + self.assists) / max(self.deaths, 1), 3),
}
# cassiopeia setup
cass.set_riot_api_key("INSERT_API_KEY")
cass.set_default_region("EUW")
# dates to be considered
begin_data = datetime.strptime("08/01/20 00:00", "%d/%m/%y %H:%M")
end_data = datetime.now()
players = {
"faker": ["Hide on Bush"],
# short_name: exact summoner name, list for more than one
}
for player_name, player_accounts in players.items():
matchups: Dict[str, Matchup] = {}
if os.path.isfile(f"{player_name}.csv"):
continue
for account in player_accounts:
summoner = cass.get_summoner(name=account, region=Region.europe_west)
##Commands_start
@bot.event
async def on_ready():
print('------')
print('Logged as')
print(bot.user.name)
print(bot.user.id)
print('------')
game = discord.Game("disc bot start")
await bot.change_presence(status=discord.Status.online, activity=game)
###LOL API
cass.set_riot_api_key(key)
cass.set_default_region("EUW") #Default region
#############################################################################
# SQL #
#############################################################################
#Select
class updateDB:
def __init__(self, dic):
self.summoner = dic['summoner']
self.soloq = dic['Queue.ranked_solo_fives']
self.flexq = dic['Queue.ranked_flex_fives']
def entryExists(self, table=None):
SID = self.summoner["summoner_id"]
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():
try:
with open(OUTPUT_FILE, 'w') as f:
json.dump(player_history, f, indent=4, default=str)
'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():
res[i.id] = i
return res
cass.set_default_region("NA")
champs = load_champions()
if len(sys.argv) < 2:
cass.set_default_region("NA")
region = 'NA'
else:
cass.set_default_region(sys.argv[1])
region = sys.argv[1]
def write_match(match, timeline):
role_index = {'top': 0, 'jgl': 1, 'mid': 2, 'bot': 3, 'sup': 4}
try:
roles = roleml.predict(match, timeline, True)
except:
# Generated by Django 2.0.2 on 2018-04-08 16:49
# from .models import *
from django.db import migrations
import cassiopeia as cass
from league.static.python.APIKey import riot_key
from league.static.python import APIKey
cass.set_riot_api_key(riot_key())
cass.set_default_region(cass.Region.europe_west)
def gen_champions(apps, schema_editor):
# static_champ_list = watcher.static_data.champions(region, tags='all')
static_champ_list = cass.Champions()
# champion_keys = static_champ_list['keys']
# data = static_champ_list['data']
# noinspection PyPep8Naming
Champion = apps.get_model('league', 'Champion')
champ_objects = []
for champ in static_champ_list:
# champ = data[name]
img = 'http://stelar7.no/cdragon/latest/champion-icons/' + str(
champ.id) + '.png'
passive = champ.passive
passive_img = 'http://ddragon.leagueoflegends.com/cdn/6.24.1/img/passive/' + passive.image_info.full
Champion.objects.create(
champion_id=champ.id,
name=champ.name,
image=img,
title=champ.title,
'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()
