Feature consistent equality

pyproject.toml

@@ -1,19 +1,21 @@
 [project]
-name = "vlr-scraper"
+name = "vlrscraper"
 version = '0.0.1'
 authors = [
     { name = "Joe Paton", email = "joantpat@gmail.com" },
 ]
 description = "vlrscraper - Scrape data from vlr seamlessly"
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.6"
 dependencies = [
     "lxml",
     "requests",
 ]
 
 [project.optional-dependencies]
-dev = ["pytest", "pytest-cov"]
+test = ["pytest", "pytest-cov"]
+lint = ["ruff", "pyright"]
+docs = ["sphinx"]
 
 [build-system]
 requires = ["setuptools >= 61.0"]

src/vlrscraper/logger.py

@@ -2,11 +2,13 @@
 import sys
 import logging
 
+from typing import Optional
+
 
 class LogConfig:
-    formatter: logging.Formatter | None = None
+    formatter: Optional[logging.Formatter] = None
     stdoutHandler: logging.StreamHandler = logging.StreamHandler(sys.stdout)
-    fileHandler: logging.FileHandler | None = None
+    fileHandler: Optional[logging.FileHandler] = None
     setup: bool = False
     logger: logging.Logger
 

src/vlrscraper/match.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Optional, List, Tuple
 
 from lxml import html
 
@@ -18,19 +18,19 @@
 
 
 @dataclass
-class MatchStats:
-    rating: float | None
-    ACS: int
-    kills: int
-    deaths: int
-    assists: int
-    KD: int
-    KAST: int | None
-    ADR: int
-    HS: int
-    FK: int
-    FD: int
-    FKFD: int
+class PlayerStats:
+    rating: Optional[float]
+    ACS: Optional[int]
+    kills: Optional[int]
+    deaths: Optional[int]
+    assists: Optional[int]
+    KD: Optional[int]
+    KAST: Optional[int]
+    ADR: Optional[int]
+    HS: Optional[int]
+    FK: Optional[int]
+    FD: Optional[int]
+    FKFD: Optional[int]
 
 
 class Match:
@@ -42,22 +42,32 @@ def __init__(
         match_name: str,
         event_name: str,
         epoch: float,
-        teams: tuple[Team, Team] | tuple[()] = (),
+        teams: Tuple[Team, Team] | Tuple[()] = (),
     ) -> None:
         self.__id = _id
         self.__name = match_name
         self.__event = event_name
         self.__epoch = epoch
         self.__teams = teams
-        self.__stats: dict[int, MatchStats] = {}
+        self.__stats: dict[int, PlayerStats] = {}
 
     def __eq__(self, other: object) -> bool:
+        _logger.warning(
+            "Avoid using inbuilt equality for Players. See Match.is_same_match()"
+        )
+        return object.__eq__(self, other)
+
+    def is_same_match(self, other: object) -> bool:
         return (
             isinstance(other, Match)
             and self.get_id() == other.get_id()
             and self.get_full_name() == other.get_full_name()
             and self.get_date() == other.get_date()
-            and self.get_teams() == other.get_teams()
+            and all(
+                team.is_same_team(other.get_teams()[i])
+                and team.has_same_roster(other.get_teams()[i])
+                for i, team in enumerate(self.get_teams())
+            )
         )
 
     def get_id(self) -> int:
@@ -72,56 +82,48 @@ def get_event_name(self) -> str:
     def get_full_name(self) -> str:
         return f"{self.__event} - {self.__name}"
 
-    def get_teams(self) -> tuple[Team, Team] | tuple[()]:
+    def get_teams(self) -> Tuple[Team, Team] | Tuple[()]:
         return self.__teams
 
-    def get_stats(self) -> dict[int, MatchStats]:
+    def get_stats(self) -> dict[int, PlayerStats]:
         return self.__stats
 
-    def get_player_stats(self, player: int) -> Optional[MatchStats]:
+    def get_player_stats(self, player: int) -> Optional[PlayerStats]:
         return self.__stats.get(player, None)
 
     def get_date(self) -> float:
         return self.__epoch
 
-    def set_stats(self, stats: dict[int, MatchStats]):
+    def set_stats(self, stats: dict[int, PlayerStats]):
         self.__stats = stats
 
-    def add_match_stat(self, player: int, stats: MatchStats) -> None:
+    def add_match_stat(self, player: int, stats: PlayerStats) -> None:
         self.__stats.update({player: stats})
 
     @staticmethod
     def __parse_match_stats(
-        players: list[int], stats: list[html.HtmlElement]
-    ) -> dict[int, MatchStats]:
+        players: List[int], stats: List[html.HtmlElement]
+    ) -> dict[int, PlayerStats]:
         if len(stats) % 12 != 0:
             _logger.warning(f"Wrong amount of stats passed ({len(stats)})")
             return {}
         player_stats = {}
-        TO_LOAD = [
-            float,
-            int,
-            int,
-            int,
-            int,
-            int,
-            int,
-            int,
-            int,
-            int,
-            int,
-            int,
-        ]
         for i, player in enumerate(players):
-            indexes = range(i * 12, (i + 1) * 12)
-
             player_stats.update(
                 {
-                    player: MatchStats(
-                        *[
-                            parse_stat(stats[stat].text, rtype=TO_LOAD[stat % 12])
-                            for stat in indexes
-                        ]
+                    player: PlayerStats(
+                        parse_stat(stats[i * 12 + 0].text, rtype=float),
+                        parse_stat(stats[i * 12 + 1].text, rtype=int),
+                        parse_stat(stats[i * 12 + 2].text, rtype=int),
+                        parse_stat(stats[i * 12 + 3].text, rtype=int),
+                        parse_stat(stats[i * 12 + 4].text, rtype=int),
+                        parse_stat(stats[i * 12 + 5].text, rtype=int),
+                        parse_stat(stats[i * 12 + 6].text, rtype=int),
+                        parse_stat(stats[i * 12 + 7].text, rtype=int),
+                        parse_stat(stats[i * 12 + 8].text, rtype=int),
+                        parse_stat(stats[i * 12 + 9].text, rtype=int),
+                        parse_stat(stats[i * 12 + 10].text, rtype=int),
+                        parse_stat(stats[i * 12 + 11].text, rtype=int),
                     )
                 }
             )
@@ -152,18 +154,27 @@ def get_match(_id: int) -> Optional[Match]:
         from vlrscraper.team import Team
         from vlrscraper.player import Player
 
-        teams = tuple(
+        teams = (
             Team.from_match_page(
-                get_url_segment(team, 2, int),
-                team_names[i],
+                get_url_segment(team_links[0], 2, int),
+                team_names[0],
                 "",
-                f"https:{team_logos[i]}",
+                f"https:{team_logos[0]}",
                 [
                     Player.from_match_page(match_player_ids[pl], match_player_names[pl])
-                    for pl in range(i * 5, (i + 1) * 5)
+                    for pl in range(0, 5)
                 ],
-            )
-            for i, team in enumerate(team_links)
+            ),
+            Team.from_match_page(
+                get_url_segment(team_links[1], 2, int),
+                team_names[1],
+                "",
+                f"https:{team_logos[1]}",
+                [
+                    Player.from_match_page(match_player_ids[pl], match_player_names[pl])
+                    for pl in range(1, 5)
+                ],
+            ),
         )
 
         match = Match(