log complete update

- resolve nicknames as we go
- update column names
- better variables

bot.py

@@ -1,22 +1,18 @@
 #!/usr/bin/env python3
 
-from collections import deque
 from discord.utils import setup_logging
-from typing import Optional
 import argparse
 import discord
 import logging
-import os.path
-import random
 import re
 import shutil
 import subprocess as sp
 
 discord.utils.setup_logging()
-_log = logging.getLogger(__name__)
+_log = logging.getLogger("statbot")
 
 _GAMES = "games.txt"
-_DB = "holy-heck.db"
+_DB = "holy-heck2.db"
 _DB_DEST = f"/var/lib/grafana/{_DB}"
 
 
@@ -43,61 +39,16 @@ def _update_db():
 
 
 class BotClient(discord.Client):
-    def __init__(
-        self,
-        intents: discord.Intents,
-        leaguefacts: Optional[list[str]] = None,
-    ):
-        super().__init__(intents=intents)
-        self._recentfacts = deque(maxlen=min(len(leaguefacts) - 1, 5))
-        self._leaguefacts = leaguefacts or []
-        self._leaguefacts.append(
-            f"I know {len(self._leaguefacts)} leaguefacts but you'll never see most of them."
-        )
-        random.seed()
-
     async def on_ready(self):
         _log.info(f"ready as {self.user}")
 
     async def on_message(self, message: discord.Message):
         content = message.content
-        if self.is_replay(message):
+        if re.match("https://replay.pokemonshowdown.com/dl-.*", content):
-            await self.on_replay(message)
+            _log.info(f"Recognised {content} as a League game")
-        elif self.is_leaguefact(message):
+            _write_game(content)
-            await self.on_leaguefact(message)
-
-    def is_replay(self, message: discord.Message) -> bool:
-        if re.match("https://replay.pokemonshowdown.com/dl-.*", message.content):
-            return True
-        return False
-
-    async def on_replay(self, message: discord.Message):
-        _log.info(f"Recognised {message.content} as a League game")
-        _write_game(message.content)
             _update_db()
 
-    def is_leaguefact(self, message: discord.Message) -> bool:
-        return message.content.lower() in ["leaguefact", "leaguefacts"]
-
-    async def on_leaguefact(self, message: discord.Message):
-        _log.info("leaguefact requested")
-        fact = self._select_leaguefact()
-        if fact:
-            await message.channel.send(f"Did you know? {fact}")
-        else:
-            await message.channel.send("There are no league facts.")
-
-    def _select_leaguefact(self) -> Optional[str]:
-        if not self._leaguefacts:
-            return None
-        choice = None
-        while True:
-            choice = random.choice(self._leaguefacts)
-            if choice not in self._recentfacts:
-                break
-        self._recentfacts.append(choice)
-        return choice
-
 
 def main():
     parser = argparse.ArgumentParser()
@@ -108,26 +59,12 @@ def main():
         default="token",
         help="file containing Discord API token",
     )
-    parser.add_argument(
-        "-f",
-        "--facts",
-        metavar="FILE",
-        default="facts.txt",
-        help="file containing leagefacts",
-    )
 
     args = parser.parse_args()
 
-    facts = []
-    if os.path.exists(args.facts):
-        with open(args.facts) as f:
-            for line in f:
-                facts.append(line)
-
     intents = discord.Intents.default()
     intents.message_content = True
-    client = BotClient(leaguefacts=facts, intents=intents)
+    client = BotClient(intents=intents)
-
     with open(args.token_file) as f:
         token = f.read().strip()
         client.run(token, log_handler=None)

facts.txt

@@ -1,45 +0,0 @@
-The Canberra Mamoswines have fielded the most unique Pokémon, with 16. The Cheyenne Chimchars have fielded the least, with 6.
-The Raleigh County Revavrooms have drafted the most unique Pokémon, with 18. The Cheyenne Chimchars have drafted the least, with 10.
-Barrow's Biggest Birds have made the most free agency exchanges so far, with 2 exchanges totalling 6 members.
-Despite their name, Barrow's Biggest Birds do not currently possess any of largest birds in season 3, and have only had at most three birds on their roster. They briefly had the tallest drafted bird, Quaquaval, but exchanged them in week 3.
-The Raleigh County Revavrooms conducted the single largest free agency exchange of season 3 in week 3, replacing eight members of their roster.
-The Canberra Mamoswines are the slowest team, with an average of 65 Speed across their roster. The Buenos Aires Aggrons are the fastest, with an average of 84.6 Speed.
-The Nimbasa City Ninjasks have the greatest Speed differential between their fastest and slowest members, of 112 points. Emily's Eevees and the Raleigh County Revavrooms are tied for the lowest differential, of 72 points.
-The Raleigh County Revavrooms have the largest roster, with up to 13 bodies across their 10 members. Prior to week 6, the Buenos Aires Aggrons had the most heads, with 14.
-As of week 4, Emily's Eevees have the fewest limbs in season 3, with only 24. Only two of their members are in the Amporphous egg group.
-The Nimbasa City Ninjasks and the Scheveningen Slow Brows are tied for the most Toxic roster, with 2 Pokémon each capable of learning the move.
-Prior to week 6, Cerluedge had more kills than all other Fire-type Pokémon combined that aren't some kind of Volcarona, as befitting of its ability, Flash Fire.
-Landorus is the only Force of Nature that has not been drafted in season 3.
-No Therian-Forme Forces of Nature have been drafted in season 3.
-Emily's Eevees is the only roster to not have a Pokémon with more than 100 Speed.
-Most teams have an average member cost of 12 points. The San Francisco 549ers are most unevenly weighted team, with a standard distribution of 6.99 points. The Canberra Mamoswines are the most evenly weighted, with a standard distribution of 5.06 points.
-Only one team does not have a regional or alternate variant of a Pokémon on their roster: the Nimbasa City Ninjasks.
-The East Midland Milotics have the fattest roster, claiming both Dondozo and Bellibolt.
-Two teams have more than one 2-cost Pokémon in their rosters: Barrow's Biggest Birds and the Nimbasa City Ninjasks, each with 2 members. Four teams have no 2-cost Pokémon at all.
-Moltres is the only legendary bird that has not been drafted in season 3.
-Tyranitar and Haxorus are the only available pseudo-legendary Pokémon to not be drafted (either directly or as a variant) in season 3.
-Frosmoth is the biggest underdog in season 3 so far, having 4 knockouts to its name while only being a 2-point Pokémon.
-The Buenos Aires Aggrons and Canberra Mamoswines are tied for having the largest type overlap on their rosters: the Aggrons have 4 Water-types, and the Mamoswines have 4 Electric-types.
-6 Pokémon have been drafted more than once in season 3: Altaria, Amoongus, Gastrodon, Goodra-Hisui, Oricorio, and Quaquaval.
-help
-I have exactly 3 facts, and they're all about how fast teams are.
-6-0s happen more often than you'd think. It may even happen to you!
-Pivot moves make up approximately 12% of all moves used in season 3. This is because U-turn is the only pivoting move to be widely available outside Pokémon of the same type as the move. This will probably be fixed in generation 10.
-Brute Bonnet is the only ancient Paradox Pokémon to not be drafted in season 3 (among those available). However, Amoongus has been. They are very upset by this.
-Only two future Paradox Pokémon have not been drafted in season 3: Iron Jugulus and Iron Thorns. Iron Jugulus is resentful that Hydreigon has seen lots of play, but it hasn't.
-As usual, Flareon is the only original Eeveelution to not be drafted in season 3.
-After 5 generations of competitive relevance, Heatran is still weak to Earthquake.
-#holy-heck-pokemon-league contains the letters "OKHO" in order, so Discord suggests it when searching for OKHO.
-Donphan and Volcarona are the most-drafted Pokémon in season 3.
-252+ Atk Choice Band Quark Drive Iron Hands Wild Charge vs. 252 HP / 252+ Def Dondozo in Electric Terrain: 564-666 (111.9 - 132.1%) -- guaranteed OHKO
-Prior to week 6, Zapdos-G had a K/D ratio of 9:2, and both of its deaths were due to recoil.
-Wave Crash causes significant recoil because Floatzel travels at approximately 78392 miles per hour when it uses it. Something about slippery otters.
-Cyclizar
-Ice-types are topping the KO leaderboard. How did this happen?
-Froslass has not landed a damaging move in season 3, and has only inflicted damage through Spikes and Destiny Bond.
-People can be busy. Please allow 4-6 weeks for updated facts.
-The San Francisco 549ers and Scheveningen Slow Bros are tied for winning the most 6-0s of season 3, with two matches each.
-Barrow's Biggest Birds and Mew York are tied for winning the most games by surrender, with two matches each.
-No Pokémon has fainted due to Confusion in season 3.
-No Pokémon has led a single team in every match. However, 11 Pokémon have led in every match they have been fielded, and The Cheyenne Chimchars' Ting-Lu has the highest rate of leading, being fielded first in 66.7% of all of their games.
-Aside from the Cheyenne Chimchars, two teams are tied for the most staples (Pokémon fielded every single match): Mew York's Torkoal and Slither Wing, and the Scheveningen Slow Bros' Slowking-G and Corviknight.

flake.nix

@@ -14,10 +14,17 @@
               let
                 python = pkgs.python3.withPackages (ps: [
                   ps.discordpy
+                  ps.mypy
                   ps.requests
+                  ps.types-requests
                 ]);
               in
-              [ python pkgs.sqlite ];
+              [
+                python
+                pkgs.sqlite
+                python.pkgs.python-lsp-server
+                python.pkgs.pylsp-mypy
+              ];
           };
         });
 }

games.txt

@@ -18,6 +18,3 @@ https://replay.pokemonshowdown.com/dl-gen9paldeadexposthomedraft-33751
 https://replay.pokemonshowdown.com/dl-gen9paldeadexposthomedraft-33998
 https://replay.pokemonshowdown.com/dl-gen9paldeadexposthomedraft-34087
 https://replay.pokemonshowdown.com/dl-gen9paldeadexposthomedraft-34672
-https://replay.pokemonshowdown.com/dl-gen9paldeadexposthomedraft-36025
-https://replay.pokemonshowdown.com/dl-gen9paldeadexposthomedraft-36096
-https://replay.pokemonshowdown.com/dl-gen9paldeadexposthomedraft-37058

index.py

@@ -14,22 +14,22 @@ import sys
 import typing as t
 
 
-logging.TRACE = 5
+logging.TRACE = 5  # type: ignore
-logging.addLevelName(logging.TRACE, "TRACE")
+logging.addLevelName(logging.TRACE, "TRACE")  # type: ignore
-logging.Logger.trace = partialmethod(logging.Logger.log, logging.TRACE)
+logging.Logger.trace = partialmethod(logging.Logger.log, logging.TRACE)  # type: ignore
-logging.trace = partial(logging.log, logging.TRACE)
+logging.trace = partial(logging.log, logging.TRACE)  # type: ignore
 
 
 class LogFormatter(logging.Formatter):
 
-    format = "%(name)s [%(levelname)s] %(message)s"
+    _format = "%(name)s [%(levelname)s] %(message)s"
     FORMATS = {
-        logging.TRACE: f"\x1b[30;20m{format}\x1b[0m",
+        logging.TRACE: f"\x1b[30;20m{_format}\x1b[0m",  # type: ignore
-        logging.DEBUG: f"\x1b[38;20m{format}\x1b[0m",
+        logging.DEBUG: f"\x1b[38;20m{_format}\x1b[0m",
-        logging.INFO: f"\x1b[34;20m{format}\x1b[0m",
+        logging.INFO: f"\x1b[34;20m{_format}\x1b[0m",
-        logging.WARNING: f"\x1b[33;20m{format}\x1b[0m",
+        logging.WARNING: f"\x1b[33;20m{_format}\x1b[0m",
-        logging.ERROR: f"\x1b[31;20m{format}\x1b[0m",
+        logging.ERROR: f"\x1b[31;20m{_format}\x1b[0m",
-        logging.CRITICAL: f"\x1b[31;1m{format}\x1b[0m",
+        logging.CRITICAL: f"\x1b[31;1m{_format}\x1b[0m",
     }
 
     def format(self, record):
@@ -45,29 +45,6 @@ _ch.setFormatter(LogFormatter())
 LOG.addHandler(_ch)
 
 
-TEAMS = {}
-_logged_teams = []
-
-
-def team(player: str) -> str:
-    """Maps a username to a defined team."""
-    if player in TEAMS:
-        return TEAMS[player]
-    else:
-        if not player in _logged_teams and player:
-            LOG.warning(f"missing team mapping for {player}")
-        _logged_teams.append(player)
-        return player
-
-
-class safelist(list):
-    def get(self, index, default=None):
-        try:
-            return self.__getitem__(index)
-        except IndexError:
-            return default
-
-
 def _init_db(conn: sqlite3.Connection):
     def namedtuple_factory(cursor, row):
         fields = [column[0] for column in cursor.description]
@@ -79,23 +56,24 @@ def _init_db(conn: sqlite3.Connection):
     conn.executescript(
         """
         CREATE TABLE IF NOT EXISTS moves(
-            game, turn, player, name, user, target,
+            game, turn, player, pokemon, move, target,
-            UNIQUE(game, turn, player, user)
+            UNIQUE(game, turn, player, pokemon)
         );
         CREATE TABLE IF NOT EXISTS switches(
-            game, turn, player, name,
+            game, turn, player, pokemon,
-            UNIQUE(game, turn, player, name)
+            UNIQUE(game, turn, player, pokemon)
         );
         CREATE TABLE IF NOT EXISTS nicknames(
-            game, player, name, specie,
+            game, player, pokemon, specie,
             UNIQUE(game, player, specie)
         );
         CREATE TABLE IF NOT EXISTS knockouts(
-            game, turn, player, name,
+            game, turn, player, pokemon,
             UNIQUE(game, turn, player)
         );
         CREATE TABLE IF NOT EXISTS indirect_knockouts(
-            game, turn, player, name, source, source_user, source_player,
+            game, turn, player, pokemon,
+            reason, source, source_player,
             UNIQUE(game, turn, player)
         );
         CREATE TABLE IF NOT EXISTS games(
@@ -104,216 +82,373 @@ def _init_db(conn: sqlite3.Connection):
         );
         -- No good way to ensure idempotence for damage; just re-build it.
         DROP TABLE IF EXISTS damage;
-        CREATE TABLE damage(game, player, name, value);
+        CREATE TABLE damage(game, player, pokemon, value);
         DROP TABLE IF EXISTS indirect_damage;
-        CREATE TABLE indirect_damage(game, player, name, value);
+        CREATE TABLE indirect_damage(game, player, pokemon, value);
         """
     )
 
 
-def parse_log(game: str, log: str, into: sqlite3.Connection):
+# Either the value "p1" or "p2"
-    conn = into
+PlayerTag = t.NewType("PlayerTag", str)
+
+# A player's name
+Player = t.NewType("Player", str)
+
+# A player prefixed with a PlayerTag
+TaggedPlayer = t.NewType("TaggedPlayer", str)
+
+# A Pokemon identified by its nickname, if any
+Pokemon = t.NewType("Pokemon", str)
+
+# A Pokemon specie
+PokemonSpecie = t.NewType("PokemonSpecie", str)
+
+# A Pokemon prefixed with a PlayerTag
+TaggedPokemon = t.NewType("TaggedPokemon", str)
+
+
+def tag(tagged: TaggedPlayer | TaggedPokemon) -> PlayerTag:
+    return PlayerTag(tagged[0:1])
+
+
+TEAMS: dict[Player, Player] = {}
+_logged_teams: set[Player] = set()
+
+
+def team(player: Player) -> Player:
+    """Maps a username to a defined team."""
+    if player in TEAMS:
+        return TEAMS[player]
+    else:
+        if not player in _logged_teams and player:
+            LOG.warning(f"missing team mapping for {player}")
+        _logged_teams.add(player)
+        return player
+
+
+class LogParser:
 
     turn = 0
-    players = {}
+    players: dict[PlayerTag, Player] = {}
-    hp = {}
+    hp: dict[TaggedPokemon, int] = {}
 
-    # ("p2a: Edward", "p1a: Meteo")
+    # Memorises the user of the move that causes environment setting or status,
-    # memorises the user of the move that causes environment setting or status,
+    # its target, and the move name (for debugging).
-    # and its target
+    last_move: t.Optional[tuple[TaggedPokemon, TaggedPokemon, str]] = None
-    last_move: t.Optional[tuple[str, str]]
 
-    # ("p1", "Spikes") => "p2a: Frosslas"
+    # Memorises the last hazard set against a player and the causing user.
-    last_env_set: dict[tuple[str, str], str] = {}
+    last_env_set: dict[tuple[PlayerTag, str], TaggedPokemon] = {}
 
-    # ("p1a: Meteo", "brn") => "p2a: Edward"
+    # Memorises statuses set on a pokemon and the causing user.
-    last_status_set: dict[tuple[str, str], str] = {}
+    last_status_set: dict[tuple[TaggedPokemon, str], TaggedPokemon] = {}
 
-    def resolve_mon(user: str) -> tuple[str, str]:
+    def __init__(self, game: str, into: sqlite3.Connection):
-        [player, name] = user.split(": ")
+        self.game = game
-        return players[player.strip("ab")], name
+        self.conn: sqlite3.Connection = into
+
+    def split_pokemon(self, user: TaggedPokemon) -> tuple[Player, Pokemon]:
+        """Splits a TaggedPokemon into the owning player and the Pokemon."""
+        [player, pokemon] = user.split(": ")
+        return self.players[PlayerTag(player.strip("ab"))], Pokemon(pokemon)
+
+    @t.overload
+    def specie(self, pokemon: Pokemon, player: Player) -> PokemonSpecie:
+        """Resolves the species of a nicknamed Pokemon."""
+        ...
+
+    @t.overload
+    def specie(self, pokemon: TaggedPokemon) -> PokemonSpecie:
+        """Resolves the species of a Pokemon given its Showdown identifier (used
+        in split_pokemon)."""
+        ...
+
+    def specie(
+        self, pokemon: Pokemon | TaggedPokemon, player: t.Optional[Player] = None
+    ) -> PokemonSpecie:
+        if not player:
+            [player, pokemon] = self.split_pokemon(TaggedPokemon(pokemon))
+        return (
+            self.conn.execute(
+                """
+                SELECT specie
+                FROM nicknames
+                WHERE (game, player, pokemon) = (?, ?, ?)
+                LIMIT 1
+                """,
+                (self.game, team(player), pokemon),
+            )
+            .fetchall()[0]
+            .specie
+        )
+
+    def _reset(self):
+        self.turn = 0
+        self.players.clear()
+        self.hp.clear()
+        self.last_move = None
+        self.last_env_set.clear()
+        self.last_status_set.clear()
+
+    def _log_appearance(self, name: TaggedPokemon, specie: str):
+
+        # Also includes gender and formes.
+        trimmed_specie = PokemonSpecie(specie.split(", ")[0])
+        player, nickname = self.split_pokemon(name)
+
+        self.conn.execute(
+            """
+            INSERT INTO nicknames(game, player, pokemon, specie)
+            VALUES(?, ?, ?, ?)
+            ON CONFLICT DO NOTHING
+            """,
+            (self.game, team(player), nickname, trimmed_specie),
+        )
+
+    def parse(self, log: str):
+        self._reset()
 
         for line in log.split("\n"):
             chunks = line.split("|")[1:]
             if not chunks:
                 continue
 
-        LOG.trace(line)
+            LOG.trace(line)  # type: ignore
 
             match chunks:
-            case ["player", id, username, *rest]:
-                players[id] = username
 
-            case ["turn", turn]:
+                # t.Literal, TaggedPokemon, str, str
-                turn = int(turn)
+                case ["drag", name_, specie, status, *rest]:
+                    name = TaggedPokemon(name_)
 
-            case ["move", user, move, target]:
+                    self.hp[name] = int(status.split("/")[0])
-                last_move = (user, target)
+                    self._log_appearance(name, specie)
-                player, user = resolve_mon(user)
+
-                _, target = resolve_mon(target)
+                # t.Literal, TaggedPokemon
-                conn.execute(
+                case ["faint", pokemon_]:
+                    pokemon = TaggedPokemon(pokemon_)
+
+                    player, _ = self.split_pokemon(pokemon)
+                    self.conn.execute(
                         """
-                    INSERT INTO moves(game, turn, player, name, user, target)
+                        INSERT INTO knockouts(game, turn, player, pokemon)
+                        VALUES(?, ?, ?, ?)
+                        ON CONFLICT DO NOTHING
+                        """,
+                        (self.game, self.turn, team(player), self.specie(pokemon)),
+                    )
+
+                # t.Literal, TaggedPokemon, str, TaggedPokemon
+                case ["move", user_, move, target_]:
+                    user = TaggedPokemon(user_)
+                    target = TaggedPokemon(target_)
+
+                    last_move = (user, target, move)
+                    player, _ = self.split_pokemon(user)
+                    self.conn.execute(
+                        """
+                        INSERT INTO moves(game, turn, player, pokemon, move, target)
                         VALUES (?, ?, ?, ?, ?, ?)
                         ON CONFLICT DO NOTHING
                         """,
-                    (game, turn, team(player), move, user, target),
+                        (
+                            self.game,
+                            self.turn,
+                            team(player),
+                            self.specie(user),
+                            move,
+                            self.specie(target),
+                        ),
                     )
 
-            case ["drag", name, specie, status, *rest]:
+                # t.Literal, PlayerTag, Player
-                hp[name] = int(status.split("/")[0])
+                case ["player", id, username, *rest]:
+                    self.players[PlayerTag(id)] = Player(username)
 
+                # t.Literal, TaggedPokemon, str
+                case ["replace", name, specie]:
+                    self._log_appearance(name, specie)
+
+                # t.Literal, TaggedPokemon, str, str, t.Optional[str]
                 case ["switch", name, specie, status, *rest]:
-                hp[name] = int(status.split("/")[0])
+                    self.hp[name] = int(status.split("/")[0])
 
-                player, name = resolve_mon(name)
+                    # Also includes gender and formes.
-                conn.execute(
+                    trimmed_specie = specie.split(", ")[0]
+                    player, nickname = self.split_pokemon(name)
+
+                    self._log_appearance(name, specie)
+                    self.conn.execute(
                         """
-                    INSERT INTO switches(game, turn, player, name)
+                        INSERT INTO switches(game, turn, player, pokemon)
                         VALUES (?, ?, ?, ?)
                         ON CONFLICT DO NOTHING
                         """,
-                    (game, turn, team(player), name),
+                        (self.game, self.turn, team(player), trimmed_specie),
-                )
-                conn.execute(
-                    """
-                    INSERT INTO nicknames(game, player, name, specie)
-                    VALUES(?, ?, ?, ?)
-                    ON CONFLICT DO NOTHING
-                    """,
-                    (game, team(player), name, specie.split(", ")[0]),
                     )
 
-            case ["faint", mon]:
+                # t.Literal, str
-                player, mon = resolve_mon(mon)
+                case ["turn", turn]:
-                conn.execute(
+                    self.turn = int(turn)
-                    """
-                    INSERT INTO knockouts(game, turn, player, name)
-                    VALUES(?, ?, ?, ?)
-                    ON CONFLICT DO NOTHING
-                    """,
-                    (game, turn, team(player), mon),
-                )
 
+                # t.Literal, Player
                 case ["win", player]:
-                conn.execute(
+                    self.conn.execute(
                         """
                         UPDATE games
                         SET winner = ?
                         WHERE id = ?
                         """,
-                    (team(player), game),
+                        (team(player), self.game),
                     )
 
-            case ["-sidestart", side, env]:
+                case ["-heal", pokemon, status, *rest]:
-                if not last_move:
+                    self.hp[pokemon] = int(status.split("/")[0])
-                    LOG.warning(f"missing previous move for {line}")
-                    continue
-                LOG.debug(f"{line} <- {last_move}")
-                last_env_set[(side[0:1], env.replace("move: ", ""))] = last_move[0]
 
-            case ["-status", mon, cond]:
+                    # TODO: track healing done
-                if not last_move or last_move[1] != mon:
-                    LOG.warning(f"missing previous move for {line}")
-                    continue
-                LOG.debug(f"{line} <- {last_move}")
-                last_status_set[(mon, cond)] = last_move[0]
 
-            case ["-damage", mon, status]:
+                # t.Literal, TaggedPokemon, str
-                # mon takes direct (non-hazard/condition) damage
+                case ["-damage", pokemon, status]:
-                # status can be a percentage 70/100 with or without condition,
+                    # Pokemon takes direct (non-hazard/condition) damage; status
-                # or "0 fnt"
+                    # can be a percentage "70/100" with or without condition, or
+                    # "0 fnt"
                     new_hp = int(re.split("[/ ]", status)[0])
-                LOG.debug(f"{mon} dropped to {new_hp} from {hp[mon]}")
+                    LOG.debug(f"{pokemon} dropped to {new_hp} from {self.hp[pokemon]}")
                     LOG.debug(f"source: {last_move}")
 
                     # resolve to damage source
-                if last_move[1] != mon:
+                    if last_move[1] != pokemon:
-                    LOG.warn(
+                        LOG.warning(
-                        f"{mon} took direct damage but last move was not targeted at them"
+                            f"{pokemon} took direct damage but last move"
+                            f" {last_move[2]} was not targeted at them"
                         )
                         continue
-                user = last_move[0]
+                    damage_source = last_move[0]
-                source_player, source_mon = resolve_mon(user)
+                    source_player, source_nickname = self.split_pokemon(damage_source)
 
-                conn.execute(
+                    self.conn.execute(
                         """
-                    INSERT INTO damage(game, player, name, value)
+                        INSERT INTO damage(game, player, pokemon, value)
                         VALUES(?, ?, ?, ?)
                         ON CONFLICT DO NOTHING
                         """,
-                    (game, team(source_player), source_mon, hp[mon] - new_hp),
+                        (
+                            self.game,
+                            team(source_player),
+                            self.specie(damage_source),
+                            self.hp[pokemon] - new_hp,
+                        ),
                     )
 
-                hp[mon] = new_hp
+                    self.hp[pokemon] = new_hp
 
-            case ["-damage", mon, status, from_]:
+                # t.Literal, TaggedPokemon, str, str
-                # mon takes indirect damage
+                case ["-damage", pokemon_, status, from_]:
-                # status can be a percentage 70/100 with or without condition,
+                    pokemon = TaggedPokemon(pokemon_)
-                # or "0 fnt"
+
-                # mon has fainted from an indirect damage source
+                    # Pokemon takes indirect damage; status can be a percentage
-                #
+                    # "70/100" with or without condition, or "0 fnt"
                     new_hp = int(re.split("[/ ]", status)[0])
-                LOG.debug(f"{mon} dropped to {new_hp} from {from_}")
+                    LOG.debug(f"{pokemon} dropped to {new_hp} from {from_}")
 
-                LOG.debug(f"tracing source for {line}")
+                    LOG.debug(f"tracing reason for {line}")
-                source = from_.replace("[from] ", "")
+                    reason = from_.replace("[from] ", "")
-                source_user = None
 
-                test_hazard = last_env_set.get((mon[0:1], source))
+                    source: TaggedPokemon | str | None = None
+                    source_is_pokemon = True
+
+                    test_hazard = self.last_env_set.get((tag(pokemon), reason))
                     if test_hazard:
-                    source_user = test_hazard
+                        source = test_hazard
-                    LOG.debug(f"identified hazard source {source_user}")
+                        LOG.debug(f"identified hazard source {source}")
 
-                test_status = last_status_set.get((mon, source))
+                    test_status = self.last_status_set.get((pokemon, reason))
                     if test_status:
-                    source_user = test_status
+                        source = test_status
-                    LOG.debug(f"identified move source {source_user}")
+                        LOG.debug(f"identified move source {source}")
 
-                if source == "Recoil" or source.startswith("item: "):
+                    if reason == "Recoil" or reason.startswith("item: "):
-                    LOG.debug(f"identified special source {source}")
+                        LOG.debug(f"identified special source {reason}")
-                    source = source.replace("item: ", "")
+                        reason = reason.replace("item: ", "")
-                    source_user = "self"
+                        source = "self"
+                        source_is_pokemon = False
 
-                if not source_user:
+                    if not source:
-                    LOG.error(f"missing source for {line}")
+                        LOG.error(f"missing reason for {line}")
                         continue
 
-                player, pkmn = resolve_mon(mon)
+                    player, nickname = self.split_pokemon(pokemon)
-                if source_user.startswith("p1") or source_user.startswith("p2"):
+                    if source.startswith("p1") or source.startswith("p2"):
-                    source_player, source_mon = resolve_mon(source_user)
+                        source_player, _ = self.split_pokemon(TaggedPokemon(source))
                     else:
-                    source_player = None
+                        source_player = None  # type: ignore
+                        source_is_pokemon = False
 
                     if source_player:
-                    conn.execute(
+                        self.conn.execute(
                             """
-                        INSERT INTO indirect_damage(game, player, name, value)
+                            INSERT INTO indirect_damage(game, player, pokemon, value)
                             VALUES(?, ?, ?, ?)
                             """,
-                        (game, team(source_player), source_mon, hp[mon] - new_hp),
+                            (
+                                self.game,
+                                team(source_player),
+                                self.specie(TaggedPokemon(source)),
+                                self.hp[pokemon] - new_hp,
+                            ),
                         )
 
                     if status == "0 fnt":
-                    conn.execute(
+                        self.conn.execute(
                             """
-                        INSERT INTO indirect_knockouts(game, turn, player, name, source, source_user, source_player)
+                            INSERT INTO indirect_knockouts(
+                                game, turn, player, pokemon,
+                                reason, source, source_player)
                             VALUES(?, ?, ?, ?, ?, ?, ?)
                             ON CONFLICT DO NOTHING
                             """,
                             (
-                            game,
+                                self.game,
-                            turn,
+                                self.turn,
                                 team(player),
-                            pkmn,
+                                self.specie(pokemon),
-                            source,
+                                reason,
-                            source_mon,
+                                self.specie(TaggedPokemon(source))
+                                if source_is_pokemon
+                                else source,
                                 team(source_player),
                             ),
                         )
 
-            case ["-heal", mon, status, *rest]:
+                # t.Literal, TaggedPlayer, str
-                hp[mon] = int(status.split("/")[0])
+                case ["-sidestart", side_, env]:
+                    side = TaggedPlayer(side_)
+
+                    if not last_move:
+                        LOG.warning(f"missing previous move for {line}")
+                        continue
+
+                    LOG.debug(f"{line} <- {last_move}")
+                    self.last_env_set[
+                        (tag(side), env.replace("move: ", ""))
+                    ] = last_move[0]
+
+                # t.Literal, TaggedPokemon, str
+                case ["-status", pokemon_, cond]:
+                    pokemon = TaggedPokemon(pokemon_)
+
+                    if not last_move or last_move[1] != pokemon:
+                        LOG.warning(f"missing previous move for {line}")
+                        continue
+
+                    LOG.debug(f"{line} <- {last_move}")
+                    self.last_status_set[(pokemon, cond)] = last_move[0]
+
+                # t.Literal, TaggedPokemon, str
+                case ["-terastallize", pokemon_, type]:
+                    pokemon = TaggedPokemon(pokemon_)
+                    # TODO
+                    pass
 
                 case _:
                     # LOG.debug(f"unhandled message {chunks[0]}")
@@ -355,7 +490,7 @@ def fetch(replay: str, cache: bool = True) -> Replay:
         with replay_file.open(mode="w") as f:
             json.dump(data, f)
 
-    return Replay(**data)
+    return Replay(**data)  # type: ignore
 
 
 def main():
@@ -427,7 +562,7 @@ def main():
                 ),
             )
 
-            parse_log(replay.id, replay.log, into=db)
+            LogParser(replay.id, db).parse(replay.log)
             db.commit()
 
     finally: