python-ballchasing 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

ballchasing/typed/deep_replay.py

@@ -0,0 +1,286 @@
+from dataclasses import dataclass, field
+from typing import Optional, List
+
+from ballchasing.typed.shared import _DictToTypeMixin, BasePlayer, BaseReplay, BaseTeam
+
+
+@dataclass
+class CameraSettings:
+    fov: int = 0
+    height: int = 0
+    pitch: int = 0
+    distance: int = 0
+    stiffness: float = 0.0
+    swivel_speed: float = 0.0
+    transition_speed: int = 0
+
+
+@dataclass
+class TeamBallStatsDR:
+    possession_time: float = 0.0
+    time_in_side: float = 0.0
+
+
+@dataclass
+class TeamCoreStatsDR:
+    shots: int = 0
+    shots_against: int = 0
+    goals: int = 0
+    goals_against: int = 0
+    saves: int = 0
+    assists: int = 0
+    score: int = 0
+    shooting_percentage: int = 0
+
+
+@dataclass
+class PlayerCoreStatsDR:
+    shots: int = 0
+    shots_against: int = 0
+    goals: int = 0
+    goals_against: int = 0
+    saves: int = 0
+    assists: int = 0
+    score: int = 0
+    mvp: bool = False
+    shooting_percentage: int = 0
+
+
+@dataclass
+class TeamBoostStatsDR:
+    bpm: int = 0
+    bcpm: float = 0.0
+    avg_amount: float = 0.0
+    amount_collected: int = 0
+    amount_stolen: int = 0
+    amount_collected_big: int = 0
+    amount_stolen_big: int = 0
+    amount_collected_small: int = 0
+    amount_stolen_small: int = 0
+    count_collected_big: int = 0
+    count_stolen_big: int = 0
+    count_collected_small: int = 0
+    count_stolen_small: int = 0
+    amount_overfill: int = 0
+    amount_overfill_stolen: int = 0
+    amount_used_while_supersonic: int = 0
+    time_zero_boost: float = 0.0
+    time_full_boost: float = 0.0
+    time_boost_0_25: float = 0.0
+    time_boost_25_50: float = 0.0
+    time_boost_50_75: float = 0.0
+    time_boost_75_100: float = 0.0
+
+
+@dataclass
+class PlayerBoostStatsDR:
+    bpm: int = 0
+    bcpm: float = 0.0
+    avg_amount: float = 0.0
+    amount_collected: int = 0
+    amount_stolen: int = 0
+    amount_collected_big: int = 0
+    amount_stolen_big: int = 0
+    amount_collected_small: int = 0
+    amount_stolen_small: int = 0
+    count_collected_big: int = 0
+    count_stolen_big: int = 0
+    count_collected_small: int = 0
+    count_stolen_small: int = 0
+    amount_overfill: int = 0
+    amount_overfill_stolen: int = 0
+    amount_used_while_supersonic: int = 0
+    time_zero_boost: float = 0.0
+    percent_zero_boost: float = 0.0
+    time_full_boost: float = 0.0
+    percent_full_boost: float = 0.0
+    time_boost_0_25: float = 0.0
+    time_boost_25_50: float = 0.0
+    time_boost_50_75: float = 0.0
+    time_boost_75_100: float = 0.0
+    percent_boost_0_25: float = 0.0
+    percent_boost_25_50: float = 0.0
+    percent_boost_50_75: float = 0.0
+    percent_boost_75_100: float = 0.0
+
+
+@dataclass
+class TeamMovementStatsDR:
+    total_distance: int = 0
+    time_supersonic_speed: float = 0.0
+    time_boost_speed: float = 0.0
+    time_slow_speed: float = 0.0
+    time_ground: float = 0.0
+    time_low_air: float = 0.0
+    time_high_air: float = 0.0
+    time_powerslide: float = 0.0
+    count_powerslide: int = 0
+
+
+@dataclass
+class PlayerMovementStatsDR:
+    avg_speed: int = 0
+    total_distance: int = 0
+    time_supersonic_speed: float = 0.0
+    time_boost_speed: float = 0.0
+    time_slow_speed: float = 0.0
+    time_ground: float = 0.0
+    time_low_air: float = 0.0
+    time_high_air: float = 0.0
+    time_powerslide: float = 0.0
+    count_powerslide: int = 0
+    avg_powerslide_duration: float = 0.0
+    avg_speed_percentage: float = 0.0
+    percent_slow_speed: float = 0.0
+    percent_boost_speed: float = 0.0
+    percent_supersonic_speed: float = 0.0
+    percent_ground: float = 0.0
+    percent_low_air: float = 0.0
+    percent_high_air: float = 0.0
+
+
+@dataclass
+class TeamPositioningStatsDR:
+    time_defensive_third: float = 0.0
+    time_neutral_third: float = 0.0
+    time_offensive_third: float = 0.0
+    time_defensive_half: float = 0.0
+    time_offensive_half: float = 0.0
+    time_behind_ball: float = 0.0
+    time_infront_ball: float = 0.0
+
+
+@dataclass
+class PlayerPositioningStatsDR:
+    avg_distance_to_ball: int = 0
+    avg_distance_to_ball_possession: int = 0
+    avg_distance_to_ball_no_possession: int = 0
+    avg_distance_to_mates: int = 0
+    time_defensive_third: float = 0.0
+    time_neutral_third: float = 0.0
+    time_offensive_third: float = 0.0
+    time_defensive_half: float = 0.0
+    time_offensive_half: float = 0.0
+    time_behind_ball: float = 0.0
+    time_infront_ball: float = 0.0
+    time_most_back: float = 0.0
+    time_most_forward: float = 0.0
+    time_closest_to_ball: float = 0.0
+    time_farthest_from_ball: float = 0.0
+    percent_defensive_third: float = 0.0
+    percent_offensive_third: float = 0.0
+    percent_neutral_third: float = 0.0
+    percent_defensive_half: float = 0.0
+    percent_offensive_half: float = 0.0
+    percent_behind_ball: float = 0.0
+    percent_infront_ball: float = 0.0
+    percent_most_back: float = 0.0
+    percent_most_forward: float = 0.0
+    percent_closest_to_ball: float = 0.0
+    percent_farthest_from_ball: float = 0.0
+    goals_against_while_last_defender: int = 0
+
+
+@dataclass
+class TeamDemoStatsDR:
+    inflicted: int = 0
+    taken: int = 0
+
+
+@dataclass
+class PlayerDemoStatsDR:
+    inflicted: int = 0
+    taken: int = 0
+
+
+@dataclass
+class TeamStatsDR(_DictToTypeMixin):
+    ball: Optional[TeamBallStatsDR] = None
+    core: Optional[TeamCoreStatsDR] = None
+    boost: Optional[TeamBoostStatsDR] = None
+    movement: Optional[TeamMovementStatsDR] = None
+    positioning: Optional[TeamPositioningStatsDR] = None
+    demo: Optional[TeamDemoStatsDR] = None
+
+
+@dataclass
+class PlayerStatsDR(_DictToTypeMixin):
+    core: Optional[PlayerCoreStatsDR] = None
+    boost: Optional[PlayerBoostStatsDR] = None
+    movement: Optional[PlayerMovementStatsDR] = None
+    positioning: Optional[PlayerPositioningStatsDR] = None
+    demo: Optional[PlayerDemoStatsDR] = None
+
+
+@dataclass
+class PlayerDR(BasePlayer):
+    # start_time: float = 0.0
+    # end_time: float = 0.0
+    # name: str = ""
+    # id: Optional[PlayerID] = None
+    # pro: bool = False
+    # mvp: bool = False
+    # rank: Optional[Rank] = None
+    car_id: int = 0
+    car_name: str = ""
+    camera: Optional[CameraSettings] = None
+    steering_sensitivity: float = 0
+    stats: Optional[PlayerStatsDR] = None
+
+
+@dataclass
+class TeamDR(BaseTeam):
+    # name: str = ""
+    color: str = ""
+    players: List[PlayerDR] = field(default_factory=list)
+    stats: Optional[TeamStatsDR] = None
+
+
+@dataclass
+class Server:
+    name: str = ""
+    region: str = ""
+
+
+@dataclass
+class DeepReplay(BaseReplay):
+    # id: str = ""
+    # link: str = ""
+    # rocket_league_id: str = ""
+    # recorder: str = ""
+    # map_code: str = ""
+    # map_name: str = ""
+    # playlist_id: str = ""
+    # playlist_name: str = ""
+    # duration: int = 0
+    # overtime: bool = False
+    # overtime_seconds: int = 0
+    # season: int = 0
+    # season_type: str = ""
+    # date: Optional[datetime] = None
+    # visibility: str = ""
+    # created: Optional[datetime] = None
+    # uploader: Optional[User] = None
+    # min_rank: Optional[Rank] = None
+    # max_rank: Optional[Rank] = None
+    # groups: List[BaseGroup] = field(default_factory=list)
+    title: str = ""  # replay_title in shallow replay
+    date_has_timezone: bool = False  # date_has_tz in shallow replay
+    status: str = ""
+    match_guid: str = ""
+    match_type: str = ""
+    team_size: int = 0
+    blue: Optional[TeamDR] = None
+    orange: Optional[TeamDR] = None
+    server: Optional[Server] = None
+
+    def scoreline(self):
+        try:
+            bg = self.blue.stats.core.goals
+        except AttributeError:
+            bg = 0
+        try:
+            og = self.orange.stats.core.goals
+        except AttributeError:
+            og = 0
+        return bg, og

ballchasing/typed/shallow_group.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+from typing import Optional
+
+from ballchasing.typed.shared import User, BaseGroup
+
+
+@dataclass
+class ShallowGroup(BaseGroup):
+    # id: str = ""
+    # link: str = ""
+    # name: str = ""
+    # created: Optional[datetime] = None
+    # player_identification: str = ""
+    # team_identification: str = ""
+    # shared: bool = False
+    direct_replays: int = 0
+    indirect_replays: int = 0
+    user: Optional[User] = None

ballchasing/typed/shallow_replay.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass, field
+from typing import Optional, List
+
+from ballchasing.typed.shared import _DictToTypeMixin, BasePlayer, BaseTeam, BaseReplay
+
+
+@dataclass
+class PlayerSR(BasePlayer):
+    # start_time: float = 0.0
+    # end_time: float = 0.0
+    # name: str = ""
+    # id: Optional[PlayerID] = None
+    # pro: bool = False
+    # mvp: bool = False
+    # rank: Optional[Rank] = None
+    score: int = 0
+
+
+@dataclass
+class TeamSR(BaseTeam):
+    # name: str = ""
+    goals: int = 0
+    players: List[PlayerSR] = field(default_factory=list)
+
+    def __eq__(self, other):
+        if isinstance(other, TeamSR):
+            for p1 in self.players:
+                for p2 in other.players:
+                    if p1 == p2:
+                        break
+                else:
+                    return False
+            return True
+        return NotImplemented
+
+
+@dataclass
+class ShallowReplay(BaseReplay):
+    # id: str = ""
+    # link: str = ""
+    # rocket_league_id: str = ""
+    # recorder: str = ""
+    # map_code: str = ""
+    # map_name: str = ""
+    # playlist_id: str = ""
+    # playlist_name: str = ""
+    # duration: int = 0
+    # overtime: bool = False
+    # overtime_seconds: int = 0
+    # season: int = 0
+    # season_type: str = ""
+    # date: Optional[datetime] = None
+    # visibility: str = ""
+    # created: Optional[datetime] = None
+    # uploader: Optional[User] = None
+    # min_rank: Optional[Rank] = None
+    # max_rank: Optional[Rank] = None
+    # groups: List[BaseGroup] = field(default_factory=list)
+    replay_title: str = ""  # title in deep replay
+    date_has_tz: bool = False  # date_has_timezone in deep replay
+    blue: Optional[TeamSR] = None
+    orange: Optional[TeamSR] = None
+
+    def scoreline(self):
+        bg = self.blue.goals if self.blue else 0
+        og = self.orange.goals if self.orange else 0
+        return bg, og

ballchasing/typed/shared.py

@@ -0,0 +1,218 @@
+from dataclasses import dataclass, fields, field
+from datetime import datetime
+from functools import total_ordering
+from typing import get_args, Optional, List
+
+from ballchasing.util import from_rfc3339
+
+
+class _DictToTypeMixin:
+    """
+    Mixin class to convert dicts to their respective types in dataclasses.
+    """
+
+    def __post_init__(self):
+        for field in fields(self):
+            value = getattr(self, field.name)
+            actual_type = field.type
+            if args := get_args(field.type):
+                actual_type = args[0]
+            if isinstance(value, dict):
+                new_value = actual_type(**value)
+                setattr(self, field.name, new_value)
+            elif isinstance(value, list):
+                new_value = [actual_type(**item) if isinstance(item, dict) else item for item in value]
+                setattr(self, field.name, new_value)
+            elif isinstance(value, str) and actual_type is datetime:
+                # Load rfc3339 formatted strings as datetime objects
+                new_value = from_rfc3339(value)
+                setattr(self, field.name, new_value)
+            # else:  # For testing
+            #     # Check that the value has the type specified in the dataclass field
+            #     if value is not None and not isinstance(value, actual_type):
+            #         if isinstance(value, int) and actual_type is float:
+            #             pass  # ints can be converted losslessly to floats
+            #         else:
+            #             raise TypeError(f"Expected {field.name} to be of type {actual_type}, got {type(value)}")
+
+
+@dataclass
+class User:
+    steam_id: str = ""
+    name: str = ""
+    profile_url: str = ""
+    avatar: str = ""
+
+    def __eq__(self, other):
+        if isinstance(other, User):
+            return self.steam_id == other.steam_id
+        return False
+
+
+@dataclass
+class PlayerID:
+    platform: str = ""
+    id: str = ""
+    player_number: int = 0
+
+    def __repr__(self):
+        if self.player_number == 0:
+            return f"{self.platform}:{self.id}"
+        return f"{self.platform}:{self.id}#{self.player_number}"
+
+
+@total_ordering
+@dataclass
+class Rank:
+    tier: int = 0
+    division: int = 0
+    name: str = ""
+    id: str = ""
+
+    def __eq__(self, other):
+        return self.tier == other.tier and self.division == other.division
+
+    def __lt__(self, other):
+        return (self.tier, self.division) < (other.tier, other.division)
+
+    @classmethod
+    def from_id(cls, rank_id: str):
+        """
+        Create a Rank object from a rank ID string, e.g. "grand-champion-1"
+        """
+        from ballchasing.constants import Rank as RankConstants
+        ranks = [r for r in RankConstants.ALL if r != "grand-champion"]
+        if rank_id == RankConstants.GRAND_CHAMPION_LEGACY:
+            rank_id = RankConstants.GRAND_CHAMPION_1
+        try:
+            tier = ranks.index(rank_id)
+            division = 0  # Division 0 is not really a thing but ID doesn't include it
+            name = rank_id.replace("-", " ").title().strip()
+            name = name.replace("1", "I").replace("2", "II").replace("3", "III")
+            name = name + " Division 0"
+            return cls(tier=tier, division=division, name=name, id=rank_id)
+        except ValueError:
+            raise ValueError(f"Invalid rank ID: {rank_id}. Must be one of {ranks}.")
+
+    @classmethod
+    def from_name(cls, rank_name: str):
+        rank_id = rank_name.lower().replace(" ", "-")
+        rank_id = rank_id.replace("i", "1").replace("ii", "2").replace("iii", "3")
+        if "-division-" in rank_id:
+            rank_id, division = rank_id.split("-division-")
+            division = int(division)
+        else:
+            division = 0
+
+        res = cls.from_id(rank_id)
+        res.division = division
+        res.name = rank_name
+        return res
+
+
+@dataclass
+class BasePlayer(_DictToTypeMixin):
+    start_time: float = 0.0
+    end_time: float = 0.0
+    name: str = ""
+    id: Optional[PlayerID] = None
+    pro: bool = False
+    mvp: bool = False
+    rank: Optional[Rank] = None
+
+    def __eq__(self, other):
+        if isinstance(other, BasePlayer):
+            return self.id == other.id
+        return NotImplemented
+
+    def is_bot(self):
+        return self.id.id == "" and self.id.platform == ""
+
+
+@dataclass
+class BaseTeam(_DictToTypeMixin):
+    name: str = ""
+    # Further specified in subclasses, needed for methods:
+    players: List[BasePlayer] = field(default_factory=list)
+
+    def __eq__(self, other):
+        # Teams are equal if all players are the same
+        if isinstance(other, BaseTeam):
+            for p1 in self.players:
+                for p2 in other.players:
+                    if p1 == p2:
+                        break
+                else:
+                    return False
+            return True
+        return NotImplemented
+
+
+@dataclass
+class BasicGroup:  # Shared between replays and shallow/deep groups
+    id: str = ""
+    name: str = ""
+    link: str = ""
+
+    def __eq__(self, other):
+        if isinstance(other, BasicGroup):
+            return self.id == other.id
+        return NotImplemented
+
+
+@dataclass
+class BaseGroup(BasicGroup, _DictToTypeMixin):  # Shared between shallow and deep groups
+    created: Optional[datetime] = ""
+    player_identification: str = ""
+    team_identification: str = ""
+    shared: bool = False
+
+
+@dataclass
+class BaseReplay(_DictToTypeMixin):  # Shared between shallow and deep replays
+    id: str = ""
+    link: str = ""
+    rocket_league_id: str = ""
+    recorder: str = ""
+    map_code: str = ""
+    map_name: str = ""
+    playlist_id: str = ""
+    playlist_name: str = ""
+    duration: int = 0
+    overtime: bool = False
+    overtime_seconds: int = 0
+    season: int = 0
+    season_type: str = ""
+    date: Optional[datetime] = None
+    visibility: str = ""
+    created: Optional[datetime] = None
+    uploader: Optional[User] = None
+    min_rank: Optional[Rank] = None
+    max_rank: Optional[Rank] = None
+    groups: List[BasicGroup] = field(default_factory=list)
+    # Further specified in subclasses, needed for methods:
+    blue: Optional[BaseTeam] = None
+    orange: Optional[BaseTeam] = None
+
+    def players(self):
+        blue = self.blue.players if self.blue else []
+        orange = self.orange.players if self.orange else []
+        return blue + orange
+
+    def teams(self):
+        teams = []
+        if self.blue:
+            teams.append(self.blue)
+        if self.orange:
+            teams.append(self.orange)
+        return teams
+
+    def team_sizes(self):
+        bs = len(self.blue.players) if self.blue else 0
+        os = len(self.orange.players) if self.orange else 0
+        return bs, os
+
+    def __eq__(self, other):
+        if isinstance(other, BaseReplay):
+            return self.id == other.id or self.rocket_league_id == other.rocket_league_id
+        return NotImplemented

ballchasing/util.py

@@ -1,9 +1,9 @@
 from datetime import datetime
-from distutils.util import strtobool
 from pathlib import Path
+from typing import Optional
 
 
-def rfc3339(dt):
+def to_rfc3339(dt: Optional[datetime]):
     if dt is None:
         return dt
     elif isinstance(dt, str):
@@ -14,6 +14,18 @@ def rfc3339(dt):
         raise ValueError("Date must be either string or datetime")
 
 
+def from_rfc3339(s: str):
+    """
+    Convert an RFC3339 formatted string to a datetime object.
+    """
+    s = s.replace("Z", "+00:00")
+    try:
+        dt = datetime.fromisoformat(s)
+    except ValueError:
+        dt = datetime.strptime(s, "%Y-%m-%dT%H:%M:%S.%f%z")
+    return dt
+
+
 def _get_stats_info():
     cur_path = Path(__file__).parent
     with open(cur_path / "stats_info.tsv") as stats_info:
@@ -25,7 +37,7 @@ def _get_stats_info():
         stat_info = {}
         for k, v in zip(header, row):
             if k.startswith("is_"):
-                v = bool(strtobool(v))
+                v = v.lower() in ("true", "1")
             elif k == "dtype":
                 v = {
                     "str": str,
@@ -56,7 +68,7 @@ def get_value(replay, path, dtype, *path_args):
         return "MISSING"
 
     if dtype == datetime:
-        return rfc3339(tree)
+        return to_rfc3339(tree)
 
     return dtype(tree)