matrix-lolbot/lolbot.py

from matrix_bot_api.matrix_bot_api import MatrixBotAPI
from matrix_bot_api.mhandler import MHandler
from matrix_bot_api.mregex_handler import MRegexHandler
from matrix_bot_api.mcommand_handler import MCommandHandler

import configparser
import math
import operator
import cassiopeia as cass
from  cassiopeia import Summoner, Match, Item, Items, Champion, Role
from cassiopeia.data import Season, Queue
from itemshortener import renamer

from collections import Counter

def history_callback(room,event):
    args = event['content']['body'].split(" ",1)[1]
    return_str = ""
    summoner = Summoner(name = args, region ="NA")
    match_history = summoner.match_history
    match_history(seasons={Season.season_8}, queues={Queue.ranked_solo_fives})

    champion_id_to_name_mapping = {champion.id: champion.name for champion in cass.get_champions(region="NA")}
    for x in range(0,20):
        champ_id = match_history[x].participants[summoner.name].champion.id
        player =  match_history[x].participants[summoner.name]
        kills =  player.stats.kills
        deaths =  player.stats.deaths
        assists =  player.stats.assists

        return_str += champion_id_to_name_mapping[champ_id]
        for x in range(0,14 - len(champion_id_to_name_mapping[champ_id])):
            return_str += " "
        return_str += "\t"
        return_str += str(kills) + "/" + str(deaths)+ "/" + str(assists) + "\t"
        return_str += "Win " if player.stats.win else "Loss "
        return_str += "\t"
        return_str += player.summoner_spell_d.name + " / " + player.summoner_spell_f.name
        for x in range(0,10 - len(player.summoner_spell_f.name)):
            return_str +=" "
        return_str += "\t"
        for item in player.stats.items:
            if item is not None:
                try:
                    return_str += str(renamer(item.name))
                except KeyError:
                    return_str += str(item.name)
                return_str += ", "
        return_str += "\n"


    room.send_notice(return_str)

def mains_callback(room, event):
    args = event['content']['body'].split(" ",1)[1]
    #names can have spaces
    #summoner = Summoner(name="Kalturi", account=34718348, id=21359666, region="NA")
    name = "Kalturi"
    #account = 34718348
    #id = 21359666
    region = "NA"
    summoner = Summoner(name=args,region=region)
    match_history = summoner.match_history
    match_history(seasons={Season.season_8}, queues={Queue.ranked_solo_fives})
    champion_id_to_name_mapping = {champion.id: champion.name for champion in cass.get_champions(region="NA")}
    played = Counter()
    for match in match_history:
        champion_id = match.participants[summoner.name].champion.id
        champion_name = champion_id_to_name_mapping[champion_id]
        played[champion_name] += 1

    return_str = ""
    room.send_notice("Top 5 champions {} played:".format(summoner.name))
    for champion_name, count in played.most_common(5):
        return_str += champion_name +"  "+str(count) + "\n"
    room.send_notice(return_str)

def rank_callback(room,event):
    args = event['content']['body'].split(" ",1)[1].rsplit(" ",1)[0]
    tiers = {'Tier.diamond':'D', 'Tier.master':'M', 'Tier.challenger':'C', 'Tier.platinum':'P', 'Tier.gold':'G', 'Tier.silver':'S','Tier.bronze':'B'}
    divisions = {'Division.one':'1','Division.two':'2','Division.three':'3','Division.four':'4','Division.five':'5'}
    return_str = ""
    summoner = Summoner(name=args,region="NA")
    positions = summoner.league_positions
    try:
        if positions.fives.promos is not None:
            return_str += "Promos: "
            for match in positions.fives.promos.progress:
                return_str += ("W-" if match else "L-")
            return_str += "\n"
        league = positions.fives
        return_str += tiers[str(league.tier)] + divisions[str(league.division)] + " " + str(league.league_points) + "LP " + str(league.wins) + "W " + str(league.losses) + "L"
        ratio = '{0:.2f}'.format(100 * league.wins / (league.wins + league.losses))
        return_str += " " + str(ratio) + "% WR"
    except Exception:
        return_str += "unranked"
    room.send_notice(return_str)

def opgg_callback(room,event):
    args = event['content']['body'].split(" ",1)[1]
    room.send_notice("http://na.op.gg/summoner/userName="+args)

def lolhelp_callback(room,event):
    help_str = "!history  -  Returns past 20 games and some data on them. \n"
    help_str += "!mains  -  Return most played champions of past several games. \n"
    help_str += "!op.gg  -  Posts an op.gg link if you want more info. \n"
    help_str += "!winrate  -  Returns highest winrate champion of a role. \n"
    help_str += "!lolhelp  -  Prints this."
    room.send_notice(help_str)

def winrate_callback(room,event):
    argz = event['content']['body'].split()
    if len(argz) == 1:
        room.send_notice("Need a role (top/jungle/mid/adc/support)")
        return
    argz.pop(0)
    args = argz[0]
    if len(argz) == 1:
        sorter = True
    if len(argz) == 2:
        sorter = (True if argz[1] == "worst" else False)
    else:
        room.send_notice("error")
        return

    roles = {"top","jungle","mid","adc","support"}
    if args not in roles:
        room.send_notice("invalid")
        return

    win_rates = {}
    role_converter = {}
    role_converter["top"] = Role.top
    role_converter["jungle"] = Role.jungle
    role_converter["mid"] = Role.middle
    role_converter["adc"] = Role.adc
    role_converter["support"] = Role.support
    champ_id_to_name_mapping = {champion.id: champion.name for champion in cass.get_champions(region="NA")}
    return_str = ""
    patcher = Champion(name="Annie", id=1,region="NA")
    #return_str += "Patch: " + str(patcher.championgg.championgg_metadata["patch"]) + "\n"
    for champ in cass.get_champions(region="NA"):
            win_rates[champ.id] = champ.championgg.win_rate[role_converter[args]]
    sorted_x = sorted(win_rates.items(),key=operator.itemgetter(1),reverse=True)
    for x in range(0,5):
        return_str += champ_id_to_name_mapping[sorted_x[x][0]] + "\t\t" + str('{0:.2f}'.format(100*sorted_x[x][1])) + "%\n"
    room.send_notice(return_str)

def main():
    config = configparser.ConfigParser()
    config.read("config.ini")
    username = config.get("Matrix","Username")
    password = config.get("Matrix","Password")
    server = config.get("Matrix", "Homeserver")
    riot_key = config.get("Riot","API_key")


    #cass.set_default_region("NA")
    championgg_api_key = "b53dd758c723794046a42f669e83bbf0"

    config = cass.get_default_config()
    config["pipeline"]["ChampionGG"] = {
            "package": "cassiopeia_championgg",
            "api_key": championgg_api_key
        }
    cass.apply_settings(config)
    cass.set_riot_api_key("RGAPI-1f6885c3-cb39-4ab1-b61b-f2fa06dc6d1f")
    bot = MatrixBotAPI(username, password, server)

    m_history_handler = MCommandHandler('history', history_callback)
    bot.add_handler(m_history_handler)

    m_mains_handler = MCommandHandler('mains', mains_callback)
    bot.add_handler(m_mains_handler)

    m_rank_handler = MCommandHandler('rank', rank_callback)
    bot.add_handler(m_rank_handler)

    m_opgg_handler = MCommandHandler('opgg', opgg_callback)
    bot.add_handler(m_opgg_handler)

    m_winrate_handler = MCommandHandler('winrate',winrate_callback)
    bot.add_handler(m_winrate_handler)

    m_lolhelp_handler = MCommandHandler('lolhelp',lolhelp_callback)
    bot.add_handler(m_lolhelp_handler)

    bot.start_polling()
    while True:
        input()

if __name__ == "__main__":
    main()