mark todo sections

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

flake.nix

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

main.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(args):
@@ -427,7 +562,7 @@ def main(args):
                 ),
             )
 
-            parse_log(replay.id, replay.log, into=db)
+            LogParser(replay.id, db).parse(replay.log)
             db.commit()
 
     finally: