ssbu_lokrez/lokrez/__init__.py

import argparse
import configparser
import copy
import datetime
import html
import io
import json
import logging
import pathlib
import pprint
import requests
import sys
import urllib

import appdirs

from . import export
from . import resources
from . import smashgg
from . import version

from .games import ssbu, pplus, melee

# =============================================================================
__version__ = version.__version__
__license__ = version.__license__

ROOTDIR = pathlib.Path(__file__).absolute().parent

APPDIRS = appdirs.AppDirs(version.NAME, version.ENTITY)

LOG_DUMMY = logging.getLogger("dummy")
LOG_DUMMY.addHandler(logging.NullHandler())

DEFAULT_DIR_TEMPLATES = ROOTDIR / "templates"

# =============================================================================
class StoreOptionKeyPair(argparse.Action):
    def __init__(
            self,
            option_strings,
            dest,
            nargs=1,
            const=None,
            default=None,
            type=None,
            choices=None,
            required=False,
            help=None,
            metavar="KEY=VALUE",
            ):

        if nargs == 0:
            raise ValueError(
                    'nargs for append actions must be > 0; if arg '
                    'strings are not supplying the value to append, '
                    'the append const action may be more appropriate'
                    )
        if const is not None and nargs != '?':
            raise ValueError('nargs must be %r to supply const' % '?')

        super(StoreOptionKeyPair, self).__init__(
                option_strings=option_strings,
                dest=dest,
                nargs=nargs,
                const=const,
                default=default,
                type=type,
                choices=choices,
                required=required,
                help=help,
                metavar=metavar,
                )

    def __call__(self, parser, namespace, values, option_string=None):
        try:
            options = getattr(namespace, self.dest)
        except AttributeError:
            options = {}

        for kv in values:
            try:
                k,v = kv.split("=")
            except ValueError:
                k = kv
                v = True

            options[k] = v

        setattr(namespace, self.dest, options)


# =============================================================================
def get_templates_list(
        dir_templates = DEFAULT_DIR_TEMPLATES,
        ):

    templates_list = []

    dir_templates_path = pathlib.Path(dir_templates)

    for potential_template in dir_templates_path.iterdir():

        if (potential_template / "template.svg.j2").is_file():
            templates_list.append(potential_template.name)

    return templates_list

# =============================================================================
def get_infos_from_file(
        lkrz_file_path,
        options = {},
        outform = "dict",
        log = LOG_DUMMY,
        ):

    if not lkrz_file_path.exists():
        raise IOError( "lkrz file '{}' does not exist" \
                .format(str(lkrz_file_path)) )

    lkrz = configparser.ConfigParser()
    lkrz.read(str(lkrz_file_path))

    log.info("Loading data from '{}'".format(str(lkrz_file_path)))

    if s in lkrz:
        section = lkrz[s]
        if s == "Tournament":
            tournament = smashgg.Tournament(
                    id = 0,
                    name = section["name"],
                    game = section["game"],
                    slug = section["slug"],
                    startAt = datetime.datetime.strptime(
                        section["date"],
                        "%Y-%m-%d %H:%M:%S",
                        ),
                    numEntrants = int(section["numEntrants"]),
                    venueName = section["location"],
                    ) \
                            .clean_name(
                                    options.get("name_seo_delimiter", None)
                                    )

        elif s.startswith("player "):
            chars = {}
            for char in section["characters"].split(","):
                c = char.strip()
                charname = c.split("_")[0]
                charskin = c.split("_")[1].split(" ")[0]
                charscore = float(c.split("(")[1].split(")")[0])

                chars[(charname,charskin)] = charscore

            player = smashgg.Player(
                    id = 0,
                    prefix = section["team"],
                    gamerTag = section["tag"],
                    placement = section["placement"],
                    seeding = section["seeding"],
                    twitterHandle = section["twitter"],
                    chars = chars,
                    )

            top_players[player.gamerTag] = player

    # Re-sort top players by their placement
    top_players = sorted(
            top_players.values(),
            key = lambda p: p.placement,
            )

    return format_infos(
            outform,
            tournament,
            top_players,
            )

# =============================================================================
def get_infos_from_url(
        url,
        token,
        options = {},
        outform = "dict",
        top = 8,
        proxy = None,
        log = LOG_DUMMY,
        ):

    url_parsed = urllib.parse.urlparse(url)

    if url_parsed.netloc not in [ "smash.gg" ]:
        raise ValueError("Unsupported domain name")
    if outform not in [ "dict", "lkrz" ]:
        raise ValueError("Unsupported outform")

    # -------------------------------------------------------------------------
    tournament = None
    event = None

    # -------------------------------------------------------------------------
    if url_parsed.netloc == "smash.gg":

        if (url_parsed.path.split("/")[1] != "tournament"):
            log.error("Incomplete URL '{}'".format(url))
            raise Exception("No tournament found in url {}".format(url))

        try:
            tournament = url_parsed.path.split("/")[2]
        except:
            log.error("Incomplete URL '{}'".format(url))
            raise Exception("No tournament slug found in url {}".format(url))

        try:
            if (url_parsed.path.split("/")[3] == "event"):
                event = url_parsed.path.split("/")[4]
        except:
            log.info("No event slug found in url")

    # -------------------------------------------------------------------------
    return get_infos_from_id_or_slug(
            id_or_slug = tournament,
            event_slug = event,
            token = token,
            options = options,
            outform = outform,
            top = top,
            proxy = proxy,
            log = log,
            )

# =============================================================================
def get_infos_from_id_or_slug(
        id_or_slug,
        event_slug = None,
        token = "",
        options = [],
        outform = "dict",
        top = 8,
        proxy = None,
        log = LOG_DUMMY,
        ):
    # Get infos from smash.gg and write the config file
    tournament, top_players = getTournamentTop(
            id_or_slug = id_or_slug,
            event_slug = event_slug,
            import_options = options,
            top = top,
            token = token,
            proxy = proxy,
            log = log,
            )

    if tournament is None or top_players is None:
        log.error("Could not load data from smash.gg")
        raise Exception("Could not load data from smash.gg")

    return format_infos(outform, tournament, top_players)


# =============================================================================
def format_infos(
        outform,
        tournament,
        top_players,
        ):

    # -------------------------------------------------------------------------
    if outform == "dict":
        return {
                "tournament": tournament,
                "players": top_players,
                }

    # -------------------------------------------------------------------------
    if outform == "lkrz":
        return "\n".join(
                [ tournament.conf() ] \
                        + list(map(
                            lambda p:p.conf(),
                            top_players,
                            ))
                        )

# =============================================================================
def init_resources(
        imgdir,
        game,
        source = None,
        store_raw = False,
        proxy = None,
        log = LOG_DUMMY,
        ):

    # Create imgdir
    imgdir.mkdir(parents=True, exist_ok=True)

    # Start resources download according to game
    if game in ssbu.GAME.list_names():
        game = ssbu
    elif game in melee.GAME.list_names():
        game = melee
    elif game in pplus.GAME.list_names():
        game = pplus
    else:
        log.error("Unknown game '{}'".format(game))
        return 1

    resources.download_res(
            dstdir = imgdir,
            game = game,
            source = source,
            store_raw = store_raw,
            proxy = proxy,
            log = log,
            )

    return 0

# =============================================================================
def generate_pic(
        infos_or_lkrzfile = None,
        template = None,
        outform = "svg",
        options = {},
        dir_templates = DEFAULT_DIR_TEMPLATES,
        dir_res = None,
        dir_cache = None,
        log = LOG_DUMMY,
        ):

    if outform.startswith("."):
        outform = outform[1:]

    if outform not in ["svg", "png"]:
        raise Exception("Unsupported outform")

    if type(infos_or_lkrzfile) == str:
        # load lkrz as dict infos
        infos = get_infos_from_file(
                lkrz_file_path = pathlib.Path(infos_or_lkrzfile),
                options = options,
                outform = "dict",
                log = log,
                )
    else:
        infos = infos_or_lkrzfile

    # -------------------------------------------------------------------------
    # Build the context which will be passed to the template
    context = {
            "tournament": infos["tournament"].clean_name(
                options.get(
                    "name_seo_delimiter",
                    None
                    )
                ),
            "players" : sorted(
                infos["players"],
                key = lambda p: p.placement,
                ),
            "dir_res_ssbu": dir_res,
            "dir_template": str(dir_templates/template),
            "options": options,
            }

    pic = export.generate_pic(
            dir_templates,
            template,
            context,
            outform,
            log = log,
            cachedir = dir_cache,
            options = options,
            )

    if pic is None:
        raise Exception("Failed to generate pic")

    return pic

# =============================================================================
def main():

    # -------------------------------------------------------------------------
    parser = argparse.ArgumentParser(
            formatter_class = argparse.ArgumentDefaultsHelpFormatter,
            )

    subparsers = parser.add_subparsers(
            dest = "command",
            help = "commands",
            )

    parser.add_argument(
            "--proxy", "-p",
            default = None,
            help = "the proxy to use",
            )

    # -------------------------------------------------------------------------
    init_parser = subparsers.add_parser(
            "init",
            formatter_class = argparse.ArgumentDefaultsHelpFormatter,
            )

    init_parser.add_argument(
            "game",
            default = "ssbu",
            help = "The game you want to initialize the resources for",
            )

    init_parser.add_argument(
            "--source", "-s",
            default = None,
            choices = ["spriters", "smashlyon"],
            help = "From where should the resources images be downloaded",
            )

    init_parser.add_argument(
            "--imgdir", "-ID",
            type = pathlib.Path,
            default = pathlib.Path(APPDIRS.user_data_dir) / "res",
            help = "The directory we should download the resources to",
            )

    init_parser.add_argument(
            "--raw", "-r",
            action = "store_true",
            help = "Download the raw zipfiles instead of extracting them",
            )

    # -------------------------------------------------------------------------
    top8_parser = subparsers.add_parser(
            "top8",
            formatter_class = argparse.ArgumentDefaultsHelpFormatter,
            )

    top8_parser.add_argument(
            "tournament",
            default = None,
            help = "The tournament url, slug or id",
            )

    top8_parser.add_argument(
            "--token", "-t",
            default = None,
            help = "the authentication token to use ; needed if you're " \
                   "generating the top8 from a smash.gg url",
            )

    top8_parser.add_argument(
            "--playerskinsdb", "-P",
            type = (lambda s: s if s.startswith("http") else pathlib.Path(s)),
            default = ROOTDIR / "data" / "playerskinsdb.json",
            help = "A JSON file path or url matching player tags, characters,"\
                   " sponsors, and preferred skins",
            )

    top8_parser.add_argument(
            "--imgdir", "-ID",
            type = pathlib.Path,
            default = pathlib.Path(APPDIRS.user_data_dir) / "res",
            help = "The directories containing images, be careful whether " \
                   "you specify an absolute path or a relative one.",
            )
    top8_parser.add_argument(
            "--cachedir", "-CD",
            type = pathlib.Path,
            default = pathlib.Path(APPDIRS.user_cache_dir),
            help = "A directory to use for temporary files",
            )
    top8_parser.add_argument(
            "--templatesdir", "-TD",
            type = pathlib.Path,
            default = DEFAULT_DIR_TEMPLATES,
            help = "The local result templates directory",
            )

    top8_parser.add_argument(
            "--template", "-T",
            default = "rebootlyon2020",
            help = "The local result template to use",
            )
    top8_parser.add_argument(
            "--template-options", "-TO",
            nargs="+",
            action = StoreOptionKeyPair,
            default = {},
            help = "Template-specific options (like 'covid' or 'animated')",
            )
    top8_parser.add_argument(
            "--export-options", "-EO",
            nargs="+",
            action = StoreOptionKeyPair,
            default = {},
            help = "Export options (like 'svg_embed_png')",
            )

    top8_parser.add_argument(
            "--import-options", "-IO",
            nargs="+",
            action = StoreOptionKeyPair,
            default = {},
            help = "Import options (like 'use_smashgg_prefixes')",
            )

    top8_parser.add_argument(
            "--outfile", "-o",
            type = pathlib.Path,
            default = None,
            help = "The SVG or PNG local result file to output to ; if it's " \
                   "not specified, it will default to SVG and use the "       \
                   "tournament slug as name ; if you're generating a "        \
                   "localresult from a url, a LKRZ file with the same name "  \
                   "will also be generated along the image file (unless you " \
                   "use the --no-lkrz flag).",
            )

    parser.add_argument( "--no-lkrz", "-nl",
                         default = False,
                         action = "store_true",
                         help = "Do not output a LKRZ file" )

    # -------------------------------------------------------------------------
    parser.add_argument( "--verbose", "-v",
                         default = 0,
                         action = "count",
                         help = "increase verbosity" )

    parser.add_argument( "--version", "-V",
                         default = False,
                         action = "store_true",
                         help = "show version number" )

    # -------------------------------------------------------------------------
    args = parser.parse_args()

    # Set log level
    # -------------------------------------------------------------------------
    log = logging.getLogger(version.NAME)
    log.setLevel(logging.DEBUG)

    log_handler_console = logging.StreamHandler()
    log_handler_console.setLevel(logging.WARNING)

    if(args.verbose >= 2):
        log_handler_console.setLevel(logging.DEBUG)
    elif(args.verbose >=1):
        log_handler_console.setLevel(logging.INFO)
    else:
        log_handler_console.setLevel(logging.WARNING)

    log_formatter_console = logging.Formatter("%(name)s:%(levelname)s: %(message)s")

    log_handler_console.setFormatter(log_formatter_console)

    log.addHandler(log_handler_console)

    # Print all arguments in debug
    # -------------------------------------------------------------------------
    log.debug( "Command arguments:\n{}".format( pprint.pformat(vars(args))) )

    # Print version if required
    # -------------------------------------------------------------------------
    if args.version:
        print(version.VERSION_NAME)
        return 0

    # Check if command is recognized
    # -------------------------------------------------------------------------
    if args.command not in [ "init", "top8" ]:
        parser.print_help()
        return 1

    # -- init
    # -------------------------------------------------------------------------
    if args.command == "init":

        rv = init_resources(
                imgdir = args.imgdir,
                game = args.game,
                source = args.source,
                store_raw = args.raw,
                proxy = args.proxy,
                log = log,
                )

        return rv

    # -- top8
    # -------------------------------------------------------------------------
    if args.command == "top8":

        # Initialize PLAYERSKINS db
        log.debug("loading playerskins db from '{}'" \
                .format(args.playerskinsdb))
        try:
            PLAYERSKINS =  requests.get(args.playerskinsdb).json()
            smashgg.GET_PLAYERDATA = (lambda tag: PLAYERSKINS[tag.lower()])
        except:
            with args.playerskinsdb.open("r", encoding="utf8") as f:
                PLAYERSKINS = json.load(f)
                smashgg.GET_PLAYERDATA = (lambda tag: PLAYERSKINS[tag.lower()])

        #
        tournament = None
        top_players = {}
        lkrz_file = None

        all_options = {
                **args.import_options,
                **args.template_options,
                **args.export_options,
                }

        # Determine the nature of the 'tournament' argument :
        # - url
        # - id or slug
        # - lkrz file
        # url
        if (    args.tournament.startswith("http://")
             or args.tournament.startswith("https://") ):
            infos = get_infos_from_url(
                    url = args.tournament,
                    token = args.token,
                    options = args.import_options,
                    outform = "dict",
                    top = 8,
                    proxy = args.proxy,
                    log = log,
                    )

        # lkrz file
        elif pathlib.Path(args.tournament).exists():
            infos = get_infos_from_file(
                    lkrz_file_path = pathlib.Path(args.tournament),
                    options = args.import_options,
                    outform = "dict",
                    log = log,
                    )

        # id or slug
        else:
            infos = get_infos_from_id_or_slug(
                    id_or_slug = args.tournament,
                    token = args.token,
                    options = args.import_options,
                    outform = "dict",
                    top = 8,
                    proxy = args.proxy,
                    log = log,
                    )

        tournament = infos["tournament"]
        top_players = infos["players"]

        if tournament is None or top_players is None:
            log.error("Could not load data")
            return 1

        # Default outfile is 'tournament-slug.svg'
        if args.outfile is None:
            args.outfile = pathlib.Path(
                    "{}.svg".format(tournament.slug),
                    )

        # Save a lkrz file
        if not args.no_lkrz:
            lkrz_data = format_infos("lkrz", tournament, top_players)
            lkrz_file = args.outfile.with_suffix(".lkrz")

            with lkrz_file.open("w", encoding="utf8") as f:
                f.write(lkrz_data)

        # If the outfile we were asked for was a .lkrz, we're done
        if args.outfile.suffix == ".lkrz":
            return 0

        # Otherwise, let's generate the picture file
        # First build the context which will be passed to the template
        try:
            dir_res = (args.imgdir / tournament.game.name).as_uri() # not absolute => error
        except ValueError:
            dir_res = (args.imgdir / tournament.game.name).as_posix()

        pic = generate_pic(
                infos_or_lkrzfile = infos,
                template = args.template,
                outform = args.outfile.suffix,
                options = all_options,
                dir_templates = args.templatesdir,
                dir_res = dir_res,
                dir_cache = args.cachedir,
                log = log,
                )

        if pic is None:
            return 1

        log.info("Saving picture as '{}'".format(args.outfile))

        if type(pic) == io.StringIO:
            openmode = "w"
        else:
            openmode = "wb"
        with args.outfile.open(openmode) as f:
            f.write(pic.read())

        return 0

# -----------------------------------------------------------------------------
def getTournamentTop(
        id_or_slug,
        event_slug = None,
        import_options = [],
        top = 8,
        token = "",
        proxy = None,
        log=LOG_DUMMY,
        ):
    """Returns a tuple : the smashgg.Tournament object and a list of the top
    smashgg.Player in that tournament."""

    # TODO if url matches challonge
    #
    #data = challonge.get_participants(
    #        api_key = token,
    #        tournament = id_or_slug,
    #        )
    #
    #top_array = []*top
    #for p in data:
    #   top_array[p["participant"]["final_rank"]] = ...

    # -------------------------------------------------------------------------
    # Select the right event (the one with the most entrants or the most sets)
    def selectBiggestEvent(data, log=LOG_DUMMY):

        try:
            event = data["events"][0]
        except:
            log.error("No event found in data")
            log.debug(data)
            return None

        try:
            numEntrants = event["numEntrants"]
        except KeyError:
            numEntrants = event["standings"]["pageInfo"]["total"]

        for e in data["events"]:
            try:
                ne = e["numEntrants"]
            except KeyError:
                ne = e["standings"]["pageInfo"]["total"]

            if ne > numEntrants:
                event = e
                numEntrants = ne

        log.info("Selected Event '{}' with {} entrants" \
                .format(
                    event["name"],
                    numEntrants,
                    ))

        return event

    # -------------------------------------------------------------------------
    # Select the specified event
    def selectEventBySlug(data, slug, log=LOG_DUMMY):

        try:
            event = data["events"][0]
        except:
            log.error("No event found in data")
            log.debug(data)
            return None

        for e in data["events"]:
            try:
                slug_full = e["slug"]
            except KeyError:
                continue

            if (    slug == slug_full
                 or slug == slug_full.split("/")[-1] ):
                log.info("Selected Event '{}' by slug '{}'" \
                        .format(
                            e["name"],
                            slug,
                            ))
                return e


        log.error("No Event matching slug '{}' found".format(slug))
        return None

    # -------------------------------------------------------------------------
    data = None

    try:
        data = smashgg.run_query(
                query_name = "getTournamentTopById",
                variables = {
                    "id" : int(id_or_slug), # If this fails, it's a slug
                    "top": top,
                    },
                query_dir = ROOTDIR / "queries",
                token = token,
                proxy = proxy,
                log = log,
                )

    except ValueError:
        data = smashgg.run_query(
                query_name = "getTournamentTopBySlug",
                variables = {
                    "slug" : id_or_slug,
                    "top": top,
                    },
                query_dir = ROOTDIR / "queries",
                token = token,
                proxy = proxy,
                log = log,
                )

    try:
        tournament_data = data["tournament"]
    except:
        log.error("Failed to load Tournaments")
        return None,None

    if tournament_data is None:
        log.error("Failed to load Tournament")
        return None,None

    event = None
    if event_slug is None:
        event = selectBiggestEvent(tournament_data, log)
    else:
        event = selectEventBySlug(tournament_data, event_slug, log)

    if event is None :
        return None,None

    # Get the tournament
    tournament = smashgg.Tournament(
            id = tournament_data["id"],
            slug = tournament_data["slug"],
            game = event["videogame"],
            name = tournament_data["name"],
            startAt = \
                    datetime.datetime. \
                    fromtimestamp(tournament_data["startAt"]),
            numEntrants = event["standings"]["pageInfo"]["total"],
            venueAddress = tournament_data["venueAddress"],
            venueName = tournament_data["venueName"],
            city = tournament_data["city"],
            countryCode = tournament_data["countryCode"],
            hashtag = tournament_data["hashtag"],
            ) \
                    .clean_name(
                            import_options.get("name_seo_delimiter", None)
                            )


    # Get the top players
    top_players = {}

    standings = event["standings"]["nodes"]

    for standing in standings :

        seeding = None
        for seed in standing["entrant"]["seeds"]:
            # Take the seeding from the phase with *all* Event entrants
            if seed["phase"]["numSeeds"] == tournament.numEntrants:
                seeding = seed["groupSeedNum"]

        participant_data = standing["entrant"]["participants"][0]

        try:
            twitterHandle = participant_data \
                    ["player"] \
                    ["user"] \
                    ["authorizations"] \
                    [0] \
                    ["externalUsername"]
        except:
            twitterHandle = None

        if "use_smashgg_prefixes" in import_options:
            prefix = participant_data["prefix"]
        else:
            prefix = ""

        player = smashgg.Player(
                id = standing["entrant"]["id"],
                prefix = prefix,
                gamerTag = participant_data["gamerTag"],
                placement = standing["placement"],
                seeding = seeding,
                twitterHandle = twitterHandle,
                )

        top_players[player.id] = player

    # -------------------------------------------------------------------------
    # Now, we need to find which characters those top players chose
    data = None

    data = smashgg.run_query(
            query_name = "getCharsByTournamentIdAndEntrantIds",
            variables = {
                "tournamentId" : int(tournament.id),
                "entrantIds": [ id for id in top_players.keys() ],
                },
            query_dir = ROOTDIR / "queries",
            token = token,
            proxy = proxy,
            log = log,
            )

    try:
        tournament_data = data["tournament"]
    except:
        log.error("Failed to load Tournament")
        return None,None

    if tournament_data is None:
        log.error("Failed to load Tournament")
        return None,None

    event = None
    if event_slug is None:
        event = selectBiggestEvent(tournament_data, log)
    else:
        event = selectEventBySlug(tournament_data, event_slug, log)

    if event is None :
        return None,None

    # TODO check that sets number is < to hardcoded 100 max value (cf query)
    sets = event["sets"]["nodes"]

    for s in sets:
        try:
            for g in s["games"]:

                winnerId = g["winnerId"]

                for slct in g["selections"]:

                    if slct["selectionType"] == "CHARACTER":
                        eid = slct["entrant"]["id"]
                        try:
                            top_players[eid].add_character_selection(
                                    game = tournament.game,
                                    character = slct["selectionValue"],
                                    win = (winnerId == eid),
                                    )
                        except KeyError:
                            pass
        except TypeError:
            # If some games or selections are null, this can happen
            continue

    # Sort top_players by rank instead of id:
    top_players_sorted = sorted(
                top_players.values(),
                key = lambda p: p.placement,
                )

    # Return the data
    return tournament, top_players_sorted

# =============================================================================
if __name__ == '__main__':
    rv = main()
    sys.exit(rv)