ATG-lib 1.5.0__tar.gz

atg_lib-1.5.0/ATG/__init__.py

@@ -0,0 +1,8 @@
+from . import api
+from . import database
+from . import match_lib
+from . import models
+from . import rate_limiter
+from . import utils
+
+__all__ = ["api", "database", "match_lib", "models", "rate_limiter", "utils"]

atg_lib-1.5.0/ATG/api/__init__.py

@@ -0,0 +1,46 @@
+from .account_v1 import get_account_by_puuid, get_account_by_riot_id
+from .ddragon import get_ddragon_versions
+from .league_v4 import (
+    get_masters,
+    get_grandmasters,
+    get_challengers,
+    get_league_entries_by_puuid,
+    get_league_entries_by_summoner_id,
+    get_all_league_entries,
+    get_league_entries_by_league_id,
+)
+from .match_v5 import get_available_matches, get_match_by_id, get_match_history
+from .spectator_v5 import get_active_games, get_featured_games
+from .summoner_v4 import (
+    get_summoner_by_account_id,
+    get_summoner_by_puuid,
+    get_summoner_by_summoner_id,
+)
+from .utils import parse_match_id, REGIONS, QUEUES, DIVISIONS, TIERS
+
+
+__all__ = [
+    "get_account_by_puuid",
+    "get_account_by_riot_id",
+    "get_ddragon_versions",
+    "get_masters",
+    "get_grandmasters",
+    "get_challengers",
+    "get_league_entries_by_puuid",
+    "get_league_entries_by_summoner_id",
+    "get_all_league_entries",
+    "get_league_entries_by_league_id",
+    "get_available_matches",
+    "get_match_by_id",
+    "get_match_history",
+    "get_active_games",
+    "get_featured_games",
+    "get_summoner_by_account_id",
+    "get_summoner_by_puuid",
+    "get_summoner_by_summoner_id",
+    "parse_match_id",
+    "REGIONS",
+    "QUEUES",
+    "DIVISIONS",
+    "TIERS",
+]

atg_lib-1.5.0/ATG/api/account_v1.py

@@ -0,0 +1,29 @@
+import requests as r
+from requests import Response
+from .utils import headers, RoutingLiteral
+from ..rate_limiter import riot_api_limiter
+
+
+@riot_api_limiter(endpoint_key="account_v1_by_riot_id")
+def get_account_by_riot_id(
+    game_name: str, tag_line: str, api_key: str, routing: RoutingLiteral = "americas"
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    # There are three routing values for account-v1; americas, asia, and europe. You can query for any account in any region. We recommend using the nearest cluster.
+    response = r.get(
+        f"https://{routing}.api.riotgames.com/riot/account/v1/accounts/by-riot-id/{game_name}/{tag_line}",
+        headers=_headers,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="account_v1_by_puuid")
+def get_account_by_puuid(
+    puuid: str, api_key: str, routing: RoutingLiteral = "americas"
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{routing}.api.riotgames.com/riot/account/v1/accounts/by-puuid/{puuid}",
+        headers=_headers,
+    )
+    return response

atg_lib-1.5.0/ATG/api/ddragon.py

@@ -0,0 +1,6 @@
+import requests as r
+from requests import Response
+
+
+def get_ddragon_versions() -> Response:
+    return r.get("https://ddragon.leagueoflegends.com/api/versions.json")

atg_lib-1.5.0/ATG/api/league_v4.py

@@ -0,0 +1,91 @@
+import requests as r
+from requests import Response
+from .utils import headers, RegionLiteral, QueueLiteral, DivisionLiteral, TierLiteral
+from ..rate_limiter import riot_api_limiter
+
+
+@riot_api_limiter(endpoint_key="league_v4_get_challengers")
+def get_challengers(
+    region: RegionLiteral, queue: QueueLiteral, api_key: str
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/league/v4/challengerleagues/by-queue/{queue}",
+        headers=_headers,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="league_v4_get_grandmasters")
+def get_grandmasters(
+    region: RegionLiteral, queue: QueueLiteral, api_key: str
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/league/v4/grandmasterleagues/by-queue/{queue}",
+        headers=_headers,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="league_v4_get_masters")
+def get_masters(region: RegionLiteral, queue: QueueLiteral, api_key: str) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/league/v4/masterleagues/by-queue/{queue}",
+        headers=_headers,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="league_v4_entries_puuid")
+def get_league_entries_by_puuid(
+    region: RegionLiteral, puuid: str, api_key: str
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/league/v4/entries/by-puuid/{puuid}",
+        headers=_headers,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="league_v4_entries_summoner_id")
+def get_league_entries_by_summoner_id(
+    region: RegionLiteral, summoner_id: str, api_key: str
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/league/v4/entries/by-summoner/{summoner_id}",
+        headers=_headers,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="league_v4_all_entries")
+def get_all_league_entries(
+    region: RegionLiteral,
+    queue: QueueLiteral,
+    tier: TierLiteral,
+    division: DivisionLiteral,
+    api_key: str,
+    page: int = 1,
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, "page": str(page), **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/league/v4/entries/{queue}/{tier}/{division}",
+        headers=_headers,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="league_v4_entries_league_id")
+def get_league_entries_by_league_id(
+    region: RegionLiteral, league_id: str, api_key: str
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/league/v4/leagues/{league_id}",
+        headers=_headers,
+    )
+    return response

atg_lib-1.5.0/ATG/api/match_v5.py

@@ -0,0 +1,59 @@
+import requests as r
+from requests import Response
+from .utils import headers, PLATFORM_ROUTING, parse_match_id, RegionLiteral
+from ..rate_limiter import riot_api_limiter
+
+
+@riot_api_limiter(endpoint_key="match_v5_by_id")
+def get_match_by_id(match_id: str, api_key: str, timeline: bool = False) -> Response:
+    region, _ = parse_match_id(match_id)
+    is_timeline = "/timeline" if timeline else ""
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{PLATFORM_ROUTING[region]}.api.riotgames.com/lol/match/v5/matches/{match_id}{is_timeline}",
+        headers=_headers,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="match_v5_available_matches")
+def get_available_matches(
+    puuid: str, region: RegionLiteral, api_key: str, **kwargs
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{PLATFORM_ROUTING[region]}.api.riotgames.com/lol/match/v5/matches/by-puuid/{puuid}/ids",
+        headers=_headers,
+        params=kwargs,
+    )
+    return response
+
+
+def get_match_history(
+    puuid: str, region: RegionLiteral, api_key: str, **kwargs
+) -> list[str]:
+    start = 0
+    count = 100
+    match_history = []
+    while True:
+        match_list = get_available_matches(
+            puuid=puuid,
+            region=region,
+            api_key=api_key,
+            start=start,
+            count=count,
+            **kwargs,
+        )
+        if match_list:
+            try:
+                match_list.raise_for_status()
+                match_list = match_list.json()
+                if len(match_list) == 0:
+                    break
+                match_history.extend(match_list)
+                start += count
+            except:
+                # If an error occurs, we will fail.
+                print(f"{match_list.status_code} - Failed to retrieve match history")
+                return match_history
+    return match_history

atg_lib-1.5.0/ATG/api/spectator_v5.py

@@ -0,0 +1,28 @@
+import requests as r
+from requests import Response
+from .utils import headers, RegionLiteral
+from ..rate_limiter import riot_api_limiter
+
+
+@riot_api_limiter(endpoint_key="spectator_v5_active_games")
+def get_active_games(
+    puuid: str, region: RegionLiteral, api_key: str, **kwargs
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/spectator/v5/active-games/by-summoner/{puuid}",
+        headers=_headers,
+        params=kwargs,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="spectator_v5_featured_games")
+def get_featured_games(region: RegionLiteral, api_key: str, **kwargs) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/spectator/v5/featured-games",
+        headers=_headers,
+        params=kwargs,
+    )
+    return response

atg_lib-1.5.0/ATG/api/summoner_v4.py

@@ -0,0 +1,43 @@
+import requests as r
+from requests import Response
+from .utils import headers, RegionLiteral
+from ..rate_limiter import riot_api_limiter
+
+
+@riot_api_limiter(endpoint_key="summoner_v4_by_account_id")
+def get_summoner_by_account_id(
+    account_id: str, region: RegionLiteral, api_key: str, **kwargs
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/summoner/v4/summoners/by-account/{account_id}",
+        headers=_headers,
+        params=kwargs,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="summoner_v4_by_puuid")
+def get_summoner_by_puuid(
+    puuid: str, region: RegionLiteral, api_key: str, **kwargs
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/summoner/v4/summoners/by-puuid/{puuid}",
+        headers=_headers,
+        params=kwargs,
+    )
+    return response
+
+
+@riot_api_limiter(endpoint_key="summoner_v4_by_summoner_id")
+def get_summoner_by_summoner_id(
+    summoner_id: str, region: RegionLiteral, api_key: str, **kwargs
+) -> Response:
+    _headers = {"X-Riot-Token": api_key, **headers}
+    response = r.get(
+        f"https://{region.lower()}.api.riotgames.com/lol/summoner/v4/summoners/{summoner_id}",
+        headers=_headers,
+        params=kwargs,
+    )
+    return response

atg_lib-1.5.0/ATG/api/utils.py

@@ -0,0 +1,73 @@
+from typing import Dict, Literal
+from enum import StrEnum
+
+headers = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+    "Accept-Language": "en-US,en-CA;q=0.9,en;q=0.8,ru-RU;q=0.7,ru;q=0.6,ko-KR;q=0.5,ko;q=0.4",
+    "Accept-Charset": "application/x-www-form-urlencoded; charset=UTF-8",
+}
+
+# The AMERICAS routing value serves NA, BR, LAN and LAS. The ASIA routing value serves KR and JP. The EUROPE routing value serves EUNE, EUW, ME1, TR and RU. The SEA routing value serves OCE, SG2, TW2 and VN2.
+PLATFORM_ROUTING: Dict[str, str] = {
+    "NA1": "americas",
+    "BR1": "americas",
+    "LA1": "americas",
+    "LA2": "americas",
+    "KR": "asia",
+    "JP": "asia",
+    "ME1": "europe",
+    "EUN1": "europe",
+    "EUW1": "europe",
+    "TR1": "europe",
+    "RU": "europe",
+    "OC1": "sea",
+    "SG2": "sea",
+    "TW2": "sea",
+    "VN2": "sea",
+}
+
+RoutingLiteral = Literal["americas", "asia", "europe", "sea"]
+RegionLiteral = Literal[
+    "NA1",
+    "BR1",
+    "LA1",
+    "LA2",
+    "KR",
+    "JP",
+    "ME1",
+    "EUN1",
+    "EUW1",
+    "TR1",
+    "RU",
+    "OC1",
+    "SG2",
+    "TW2",
+    "VN2",
+]
+QueueLiteral = Literal["RANKED_SOLO_5x5", "RANKED_FLEX_SR", "RANKED_FLEX_TT"]
+DivisionLiteral = Literal["I", "II", "III", "IV"]
+TierLiteral = Literal[
+    "DIAMOND", "EMERALD", "PLATINUM", "GOLD", "SILVER", "BRONZE", "IRON"
+]
+
+REGIONS = StrEnum("Regions", [(_, _) for _ in PLATFORM_ROUTING.keys()])
+QUEUES = StrEnum(
+    "Queues", [(_, _) for _ in ["RANKED_SOLO_5x5", "RANKED_FLEX_SR", "RANKED_FLEX_TT"]]
+)
+DIVISIONS = StrEnum("Divisions", [(_, _) for _ in ["I", "II", "III", "IV"]])
+TIERS = StrEnum(
+    "Tiers",
+    [
+        (_, _)
+        for _ in ["DIAMOND", "EMERALD", "PLATINUM", "GOLD", "SILVER", "BRONZE", "IRON"]
+    ],
+)
+
+
+def parse_match_id(match_id: str) -> tuple[str, str]:
+    split = match_id.split("_")
+    if len(split) != 2:
+        raise ValueError(f"Unable to parse {match_id}")
+    if split[0] not in REGIONS:
+        raise ValueError(f"Unknown region {split[0]} received")
+    return split[0], split[1]

atg_lib-1.5.0/ATG/database/__init__.py

@@ -0,0 +1,3 @@
+from .database import get_session_factory
+
+__all__ = ["get_session_factory"]

atg_lib-1.5.0/ATG/database/database.py

@@ -0,0 +1,10 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from ..models import Base
+
+
+def get_session_factory(database_url: str, read_only: bool = False):
+    engine = create_engine(database_url, pool_recycle=3600)
+    if not read_only:
+        Base.metadata.create_all(bind=engine)
+    return sessionmaker(autocommit=False, autoflush=True, bind=engine)

atg_lib-1.5.0/ATG/match_lib/__init__.py

@@ -0,0 +1,23 @@
+from .esports_ingest import (
+    create_account,
+    create_player,
+    create_missing_accounts,
+    parse_game_participants,
+    get_common_prefix_length
+)
+from .ingest_match import (
+    insert_match_history,
+    update_account_names,
+    process_match,
+)
+
+__all__ = [
+    "create_account",
+    "create_player",
+    "create_missing_accounts",
+    "parse_game_participants",
+    "get_common_prefix_length",
+    "insert_match_history",
+    "update_account_names",
+    "process_match",
+]

atg_lib-1.5.0/ATG/match_lib/esports_ingest.py

@@ -0,0 +1,112 @@
+from ..models import Player, Account, Participant
+from sqlalchemy.orm import Session
+from sqlalchemy import select
+
+def create_player(name: str) -> Player:
+    """Creates a player object
+
+    Args:
+        name (str): Player name
+
+    Returns:
+        Player: Created player object
+    """
+    return Player(name=name)
+
+def create_account(puuid: str, name: str, tagline: str, player_id: int, region: str = "TOURNAMENT", skip_update: bool = True) -> Account:
+    """Creates an account object
+
+    Args:
+        puuid (str): Account identifier (PUUID / Account ID)
+        name (str): Account name
+        tagline (str): Account tagline
+        player_id (int): Player ID (foreign key)
+        region (str, optional): Account region. Defaults to "TOURNAMENT".
+        skip_update (bool, optional): Should be updated automatically?. Defaults to True.
+
+    Returns:
+        Account: Created account object
+    """
+    return Account(
+        puuid=puuid,
+        name=name,
+        tagline=tagline,
+        region=region,
+        player_id=player_id,
+        skip_update=skip_update)
+
+def get_puuid(participant) -> str:
+    return str(participant.get("puuid", participant["accountID"]))
+def get_game_name(participant) -> str:
+    return participant.get("riotId", {"displayName": participant.get("summonerName")})["displayName"]
+def get_tagline(participant) -> str:
+    return participant.get("riotId", {}).get("tagLine", "")
+def get_team_id(participant) -> int:
+    return participant.get("teamID", participant.get("teamId"))
+
+def parse_game_participants(participants: list[dict], game_id: str, winning_team_id: int, NAME_ID_MAP: dict[str, int]) -> list[Participant]:
+    """Parses the participants into a list of Participant objects
+
+    Args:
+        participants (list[dict]): List of game participants
+        winning_team_id (int): 100 or 200 (blue/red winners)
+        NAME_ID_MAP (dict[str, int]): champion name -> champion id map
+
+    Returns:
+        list[Participant]: Parsed participant objects
+    """
+    game_participants = []
+    for participant in participants:
+        game_participants.append(Participant(
+            game_id = game_id,
+            puuid = get_puuid(participant),
+            participant_id = participant["participantID"],
+            riot_id_game_name = get_game_name(participant),
+            riot_id_tagline = get_tagline(participant),
+            summoner_id = participant["accountID"],
+            team_id = get_team_id(participant),
+            champion_id = NAME_ID_MAP[participant["championName"].lower()],
+            win = get_team_id(participant) == winning_team_id,
+        ))
+    return game_participants
+
+def get_common_prefix_length(player_names: list[str]) -> int:
+    """Gets the number of charaters shared in the prefix of all items of a list
+
+    Args:
+        player_names (list[str]): A list of player names
+
+    Returns:
+        int: The length of the shared prefix
+    """
+    common_prefix_length = 0
+    for chars in zip(*player_names):
+        if len(set(chars)) == 1:
+            common_prefix_length += 1
+        else:
+            break
+    return common_prefix_length
+
+def create_missing_accounts(session: Session, participants: dict):
+    """Helper function to parse a list of participants and add to the session any missing players/accounts.
+
+    Args:
+        session (Session): Active SQLAlchemy session object
+        participants (dict): A match-v5 like participant list
+    """
+    stored_puuids = session.scalars(select(Account.puuid)).all()
+    for participant in participants:
+        puuid = get_puuid(participant)
+        if puuid not in stored_puuids:
+            game_name = get_game_name(participant)
+            player_names = [get_game_name(p) for p in participants if get_team_id(p) == get_team_id(participant)]
+            player_name = game_name[get_common_prefix_length(player_names):]
+            
+            db_player = session.scalar(select(Player).where(Player.name == player_name))
+            
+            if db_player is None:
+                db_player = create_player(player_name)
+                session.add(db_player)
+                session.flush()
+
+            session.add(create_account(puuid, game_name, get_tagline(participant), db_player.id))