analyzerl-parser 0.1.2__cp39-abi3-win_amd64.whl

analyzerl_parser/__init__.py

@@ -0,0 +1,2 @@
+from .parse import parse_replay
+from .stats import calculate_stats

analyzerl_parser/parse.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+from ._boxcars import parse_frames as _parse_frames
+
+_DATA_DIR = Path.cwd()
+
+
+def set_data_dir(path):
+    global _DATA_DIR
+    _DATA_DIR = Path(path).expanduser().resolve()
+    return _DATA_DIR
+
+
+def get_data_dir():
+    return _DATA_DIR
+
+
+def _path(value):
+    value = Path(value).expanduser()
+    return value if value.is_absolute() else (_DATA_DIR / value).resolve()
+
+
+def _replay_paths(replay_path):
+    replay_path = _path(replay_path)
+
+    if replay_path.is_file():
+        if replay_path.suffix.lower() != ".replay":
+            raise ValueError(f"Not a .replay file: {replay_path}")
+        return [replay_path]
+
+    if replay_path.is_dir():
+        paths = sorted(replay_path.rglob("*.replay"))
+        if not paths:
+            raise FileNotFoundError(f"No .replay files found in: {replay_path}")
+        return paths
+
+    raise FileNotFoundError(f"Replay path does not exist: {replay_path}")
+
+
+def parse_replay(replay_path="data/replays", workers=4, return_type="list", export=None):
+    replay_paths = _replay_paths(replay_path)
+
+    output = []
+
+    for replay_file in replay_paths:
+        parsed_replays = _parse_frames(
+            replay_path=str(replay_file),
+            workers=max(int(workers or 1), 1),
+        )
+
+        for parsed in parsed_replays:
+            game_id = parsed["game_id"]
+            rows = parsed["rows"]
+
+            if return_type == "list":
+                item = rows
+            elif return_type == "pandas":
+                import pandas as pd
+                item = pd.DataFrame(rows)
+            elif return_type == "polars":
+                import polars as pl
+                item = pl.DataFrame(rows)
+            else:
+                raise ValueError("return_type must be one of: 'list', 'pandas', 'polars'")
+
+            if export is not None:
+                export_path = _path(export)
+                export_path.mkdir(parents=True, exist_ok=True)
+                
+                out_file = export_path / f"{game_id}_frames.parquet"
+
+                if return_type == "polars":
+                    item.write_parquet(out_file)
+                else:
+                    import pandas as pd
+                    if return_type == "list":
+                        pd.DataFrame(item).to_parquet(out_file, index=False)
+                    else:
+                        item.to_parquet(out_file, index=False)
+
+            output.append(item)
+
+    return output

analyzerl_parser/stats.py

@@ -0,0 +1,494 @@
+import polars as pl
+
+from pathlib import Path
+
+PLAYER_SLOTS = [
+    "blue_player_1",
+    "blue_player_2",
+    "blue_player_3",
+    "orange_player_1",
+    "orange_player_2",
+    "orange_player_3",
+]
+
+def requested_columns(has_xg):
+    columns = [
+        "game_id",
+        "replay_id",
+        "event_type",
+        "event_team",
+        "event_player_1_id",
+        "event_player_1_name",
+        "event_player_1_team",
+        "event_player_2_id",
+        "event_player_2_name",
+        "event_player_2_team",
+        "seconds_elapsed",
+        "official_assist",
+        "boost_pickup_amount",
+        "boost_pickup_type",
+        "off_demo",
+        "off_kickoff",
+        "off_challenge_win",
+        "off_bump",
+        "off_air_dribble",
+        "off_ground_dribble",
+        "off_flick",
+        "pass_in_play",
+        "aerialing",
+        "air_dribble",
+        "ground_dribble",
+        "flick_shot",
+        "rebound",
+        "off_flip_reset",
+        "off_wall",
+        "off_ceiling",
+        "blue_team_name",
+        "orange_team_name",
+    ]
+
+    if has_xg:
+        columns.append("xG")
+
+    for slot in PLAYER_SLOTS:
+        for field in [
+            "id",
+            "network_id",
+            "name",
+            "platform",
+            "rank",
+            "rank_tier",
+            "pro_player",
+            "mmr",
+            "car_id",
+            "car_name",
+            "is_bot",
+            "time_in_game",
+        ]:
+            columns.append(f"{slot}_{field}")
+
+    return list(dict.fromkeys(columns))
+
+
+def _to_lazy_frames(frames):
+    if isinstance(frames, pl.LazyFrame):
+        return frames
+
+    if isinstance(frames, pl.DataFrame):
+        return frames.lazy()
+
+    try:
+        import pandas as pd
+
+        if isinstance(frames, pd.DataFrame):
+            return pl.from_pandas(frames).lazy()
+    except ImportError:
+        pass
+
+    if not isinstance(frames, list) or not frames:
+        raise TypeError(
+            "frames must be a Polars DataFrame, pandas DataFrame, "
+            "list[dict], list[list[dict]], or list of DataFrames"
+        )
+
+    first = frames[0]
+
+    if isinstance(first, dict):
+        return pl.DataFrame(frames).lazy()
+
+    if isinstance(first, list):
+        return pl.concat(
+            [pl.DataFrame(replay_rows) for replay_rows in frames],
+            how="vertical_relaxed",
+        ).lazy()
+
+    if isinstance(first, pl.DataFrame):
+        return pl.concat(frames, how="vertical_relaxed").lazy()
+
+    try:
+        import pandas as pd
+
+        if isinstance(first, pd.DataFrame):
+            return pl.concat(
+                [pl.from_pandas(frame) for frame in frames],
+                how="vertical_relaxed",
+            ).lazy()
+    except ImportError:
+        pass
+
+    raise TypeError(
+        "frames must be a Polars DataFrame, pandas DataFrame, "
+        "list[dict], list[list[dict]], or list of DataFrames"
+    )
+
+
+def _ensure_columns(rows, columns):
+    existing = rows.collect_schema().names()
+
+    return rows.with_columns(
+        [
+            pl.lit(None).alias(column)
+            for column in columns
+            if column not in existing
+        ]
+    ).select(columns)
+
+
+def string_col(column):
+    return pl.col(column).cast(pl.Utf8, strict=False).fill_null("")
+
+
+def number_col(column):
+    return pl.col(column).cast(pl.Float64, strict=False).fill_null(0.0)
+
+
+def flag_col(column):
+    return string_col(column).str.to_lowercase().is_in(["true", "1", "yes"])
+
+
+def count_if(condition, name):
+    return condition.cast(pl.Int64).sum().alias(name)
+
+
+def sum_if(condition, value, name):
+    return pl.when(condition).then(value).otherwise(0.0).sum().alias(name)
+
+
+def player_slot_frame(events, slot):
+    team = "orange" if slot.startswith("orange") else "blue"
+    team_name_col = "orange_team_name" if team == "orange" else "blue_team_name"
+
+    return events.select(
+        [
+            pl.col("replay_id"),
+            string_col(f"{slot}_id").alias("player_id"),
+            string_col(f"{slot}_network_id").alias("network_id"),
+            string_col(f"{slot}_name").alias("player_name"),
+            pl.lit(team).alias("team"),
+            string_col(team_name_col).alias("team_name"),
+            string_col(f"{slot}_platform").alias("platform"),
+            string_col(f"{slot}_rank").alias("rank"),
+            string_col(f"{slot}_rank_tier").alias("rank_tier"),
+            flag_col(f"{slot}_pro_player").alias("pro_player"),
+            number_col(f"{slot}_mmr").alias("mmr"),
+            string_col(f"{slot}_car_id").alias("car_id"),
+            string_col(f"{slot}_car_name").alias("car_name"),
+            flag_col(f"{slot}_is_bot").alias("is_bot"),
+            number_col(f"{slot}_time_in_game").alias("time_in_game"),
+            number_col("seconds_elapsed").alias("seconds_elapsed"),
+        ]
+    ).filter(pl.col("player_id") != "")
+
+
+def player_frame(rows):
+    players = pl.concat(
+        [player_slot_frame(rows, slot) for slot in PLAYER_SLOTS],
+        how="vertical_relaxed",
+    )
+
+    players = players.group_by(["replay_id", "player_id"]).agg(
+        [
+            pl.col("network_id").drop_nulls().first(),
+            pl.col("player_name").drop_nulls().first(),
+            pl.col("team").drop_nulls().first(),
+            pl.col("team_name").drop_nulls().first(),
+            pl.col("platform").drop_nulls().first(),
+            pl.col("rank").drop_nulls().first(),
+            pl.col("rank_tier").drop_nulls().first(),
+            pl.col("pro_player").max(),
+            pl.col("mmr").max(),
+            pl.col("car_id").drop_nulls().first(),
+            pl.col("car_name").drop_nulls().first(),
+            pl.col("is_bot").max(),
+            pl.col("time_in_game").max(),
+            pl.col("seconds_elapsed").max().alias("_max_seconds_elapsed"),
+        ]
+    )
+
+    return (
+        players.with_columns(
+            [
+                pl.when(pl.col("time_in_game") > 0)
+                .then(pl.col("time_in_game"))
+                .otherwise(pl.col("_max_seconds_elapsed"))
+                .alias("time_in_game")
+            ]
+        )
+        .with_columns([(pl.col("time_in_game") / 60.0).alias("time_on_field")])
+        .drop("_max_seconds_elapsed")
+    )
+
+
+def primary_event_stats(events, has_xg):
+    shot = pl.col("event_type").is_in(["shot", "goal"])
+    goal = pl.col("event_type") == "goal"
+
+    expressions = [
+        pl.len().alias("event_count"),
+        count_if(shot, "shots"),
+        count_if(goal, "goals"),
+        count_if(pl.col("event_type") == "save", "saves"),
+        count_if(pl.col("event_type") == "touch", "touches"),
+        count_if(pl.col("event_type") == "pass", "passes"),
+        count_if(pl.col("event_type") == "turnover", "turnovers"),
+        count_if(pl.col("event_type") == "challenge", "challenge_wins"),
+        count_if(pl.col("event_type") == "kickoff", "kickoff_wins"),
+        count_if(pl.col("event_type") == "demo", "demos"),
+        count_if(pl.col("event_type") == "bump", "bumps"),
+        count_if(pl.col("event_type") == "entry", "entries"),
+        count_if(pl.col("event_type") == "exit", "exits"),
+        count_if(pl.col("event_type") == "retrieval", "retrievals"),
+        count_if(pl.col("event_type") == "air_dribble", "air_dribbles"),
+        count_if(pl.col("event_type") == "ground_dribble", "ground_dribbles"),
+        count_if(pl.col("event_type") == "flick", "flicks"),
+        count_if(pl.col("event_type") == "flip_reset", "flip_resets"),
+        count_if(pl.col("event_type") == "boost-pickup", "boost_pickups"),
+        count_if(
+            (pl.col("event_type") == "boost-pickup")
+            & (string_col("boost_pickup_type") == "small"),
+            "small_boost_pickups",
+        ),
+        count_if(
+            (pl.col("event_type") == "boost-pickup")
+            & (string_col("boost_pickup_type") == "big"),
+            "big_boost_pickups",
+        ),
+        count_if(
+            (pl.col("event_type") == "boost-pickup")
+            & (string_col("boost_pickup_type") == "reset"),
+            "boost_resets",
+        ),
+        sum_if(
+            pl.col("event_type") == "boost-pickup",
+            number_col("boost_pickup_amount"),
+            "boost_collected",
+        ),
+        count_if(shot & flag_col("off_demo"), "off_demo_shots"),
+        count_if(shot & flag_col("off_kickoff"), "off_kickoff_shots"),
+        count_if(shot & flag_col("off_challenge_win"), "off_challenge_win_shots"),
+        count_if(shot & flag_col("off_bump"), "off_bump_shots"),
+        count_if(shot & flag_col("off_air_dribble"), "off_air_dribble_shots"),
+        count_if(shot & flag_col("off_ground_dribble"), "off_ground_dribble_shots"),
+        count_if(shot & flag_col("off_flick"), "off_flick_shots"),
+        count_if(shot & flag_col("pass_in_play"), "pass_in_play_shots"),
+        count_if(shot & flag_col("aerialing"), "aerial_shots"),
+        count_if(shot & flag_col("air_dribble"), "air_dribble_shots"),
+        count_if(shot & flag_col("ground_dribble"), "ground_dribble_shots"),
+        count_if(shot & flag_col("flick_shot"), "flick_shots"),
+        count_if(shot & flag_col("rebound"), "rebound_shots"),
+        count_if(shot & flag_col("off_flip_reset"), "off_flip_reset_shots"),
+        count_if(shot & flag_col("off_wall"), "off_wall_shots"),
+        count_if(shot & flag_col("off_ceiling"), "off_ceiling_shots"),
+    ]
+
+    if has_xg:
+        xg = number_col("xG")
+        expressions.extend(
+            [
+                sum_if(shot, xg, "expected_goals"),
+                sum_if(goal, xg, "expected_goals_on_goals"),
+                sum_if(shot & ~goal, xg, "expected_goals_on_misses"),
+            ]
+        )
+
+    return (
+        events.filter(string_col("event_player_1_id") != "")
+        .group_by(
+            [
+                "replay_id",
+                string_col("event_player_1_id").alias("player_id"),
+            ]
+        )
+        .agg(expressions)
+    )
+
+
+def secondary_event_stats(events):
+    assist = (pl.col("event_type") == "goal") & (
+        flag_col("official_assist") | (string_col("event_player_2_id") != "")
+    )
+
+    return (
+        events.filter(string_col("event_player_2_id") != "")
+        .group_by(
+            [
+                "replay_id",
+                string_col("event_player_2_id").alias("player_id"),
+            ]
+        )
+        .agg(
+            [
+                count_if(assist, "assists"),
+                count_if(pl.col("event_type") == "pass", "passes_received"),
+                count_if(pl.col("event_type") == "demo", "demos_taken"),
+                count_if(pl.col("event_type") == "bump", "bumps_taken"),
+                count_if(pl.col("event_type") == "challenge", "challenge_losses"),
+                count_if(pl.col("event_type") == "kickoff", "kickoff_losses"),
+            ]
+        )
+    )
+
+
+def team_event_stats(events, has_xg):
+    shot = pl.col("event_type").is_in(["shot", "goal"])
+    goal = pl.col("event_type") == "goal"
+
+    expressions = [
+        count_if(shot, "shots_for"),
+        count_if(goal, "goals_for"),
+        count_if(pl.col("event_type") == "save", "saves_for"),
+        count_if(pl.col("event_type") == "demo", "demos_for"),
+        count_if(pl.col("event_type") == "challenge", "challenges_won_for"),
+        count_if(pl.col("event_type") == "entry", "entries_for"),
+        count_if(pl.col("event_type") == "exit", "exits_for"),
+        count_if(pl.col("event_type") == "retrieval", "retrievals_for"),
+        count_if(pl.col("event_type") == "air_dribble", "air_dribbles_for"),
+        count_if(pl.col("event_type") == "ground_dribble", "ground_dribbles_for"),
+        count_if(pl.col("event_type") == "flick", "flicks_for"),
+        count_if(pl.col("event_type") == "flip_reset", "flip_resets_for"),
+        count_if(pl.col("event_type") == "boost-pickup", "boost_pickups_for"),
+        sum_if(
+            pl.col("event_type") == "boost-pickup",
+            number_col("boost_pickup_amount"),
+            "boost_collected_for",
+        ),
+    ]
+
+    if has_xg:
+        expressions.append(sum_if(shot, number_col("xG"), "expected_goals_for"))
+
+    return (
+        events.filter(string_col("event_team").is_in(["blue", "orange"]))
+        .group_by(
+            [
+                "replay_id",
+                pl.col("event_team").alias("team"),
+            ]
+        )
+        .agg(expressions)
+    )
+
+
+def calculate_player_replay_stats(frames):
+    rows = _to_lazy_frames(frames)
+    schema = rows.collect_schema().names()
+
+    has_xg = "xG" in schema
+    columns = requested_columns(has_xg)
+    rows = _ensure_columns(rows, columns)
+
+    rows = rows.with_columns(
+        [
+            pl.when(string_col("replay_id") != "")
+            .then(string_col("replay_id"))
+            .otherwise(string_col("game_id"))
+            .alias("replay_id"),
+            string_col("event_type").alias("event_type"),
+            string_col("event_team").alias("event_team"),
+        ]
+    )
+
+    events = rows.filter(string_col("event_type") != "")
+
+    players = player_frame(rows)
+    primary = primary_event_stats(events, has_xg)
+    secondary = secondary_event_stats(events)
+    team_for = team_event_stats(events, has_xg)
+
+    team_against = team_for.rename(
+        {
+            "team": "opponent_team",
+            **{
+                column: column.replace("_for", "_against")
+                for column in team_for.collect_schema().names()
+                if column.endswith("_for")
+            },
+        }
+    )
+
+    stats = players.with_columns(
+        [
+            pl.when(pl.col("team") == "blue")
+            .then(pl.lit("orange"))
+            .otherwise(pl.lit("blue"))
+            .alias("opponent_team")
+        ]
+    ).join(primary, on=["replay_id", "player_id"], how="left")
+
+    stats = stats.join(secondary, on=["replay_id", "player_id"], how="left")
+    stats = stats.join(team_for, on=["replay_id", "team"], how="left")
+    stats = stats.join(team_against, on=["replay_id", "opponent_team"], how="left").drop(
+        "opponent_team"
+    )
+
+    identity_columns = [
+        "replay_id",
+        "player_id",
+        "network_id",
+        "player_name",
+        "team",
+        "team_name",
+        "platform",
+        "rank",
+        "rank_tier",
+        "pro_player",
+        "mmr",
+        "car_id",
+        "car_name",
+        "is_bot",
+        "time_in_game",
+        "time_on_field",
+    ]
+
+    count_columns = [
+        column
+        for column in stats.collect_schema().names()
+        if column not in identity_columns
+    ]
+
+    stats = stats.with_columns([pl.col(column).fill_null(0) for column in count_columns])
+
+    if has_xg:
+        stats = stats.with_columns(
+            [
+                pl.when(pl.col("shots") > 0)
+                .then(pl.col("expected_goals") / pl.col("shots"))
+                .otherwise(0.0)
+                .alias("expected_goals_per_shot"),
+                (pl.col("goals") - pl.col("expected_goals")).alias(
+                    "goals_minus_expected_goals"
+                ),
+                (pl.col("goals_for") - pl.col("expected_goals_for")).alias(
+                    "goals_for_minus_expected_goals_for"
+                ),
+                (pl.col("goals_against") - pl.col("expected_goals_against")).alias(
+                    "goals_against_minus_expected_goals_against"
+                ),
+            ]
+        )
+
+    return stats.sort(["replay_id", "team", "player_name", "player_id"]).collect()
+
+
+def calculate_stats(frames, return_type="polars", export=None):
+    stats = calculate_player_replay_stats(frames)
+
+    if export is not None:
+        export = Path(export)
+        export.parent.mkdir(parents=True, exist_ok=True)
+
+        if export.suffix == ".parquet":
+            stats.write_parquet(export)
+        else:
+            stats.write_csv(export)
+
+    if return_type == "polars":
+        return stats
+
+    if return_type == "pandas":
+        return stats.to_pandas()
+
+    if return_type == "list":
+        return stats.to_dicts()
+
+    raise ValueError("return_type must be one of: 'polars', 'pandas', 'list'")

analyzerl_parser-0.1.2.dist-info/METADATA

@@ -0,0 +1,3 @@
+Metadata-Version: 2.4
+Name: analyzerl_parser
+Version: 0.1.2

analyzerl_parser-0.1.2.dist-info/RECORD

@@ -0,0 +1,8 @@
+analyzerl_parser/__init__.py,sha256=B0LYJ62s2F8lAfTE1zqtWzBVgqQBmRoIPfW1EzHLBzI,69
+analyzerl_parser/_boxcars.pyd,sha256=kClVGucZRCh0i1CTISBwZL1xfdXzOOVf5B6eWaYPJbg,1551360
+analyzerl_parser/parse.py,sha256=EbdpbCWBRKoLwYqh4gdsM9CS11NrVqsqVmK8LOD2jj8,2519
+analyzerl_parser/stats.py,sha256=5jmMLZeYE-PYZngNWkzSLANBApevB2vsCBuwdHVyGS8,16512
+analyzerl_parser-0.1.2.dist-info/METADATA,sha256=t7l6oxV5mzTgO_K33aLJW3GIHJTzJblp420TAPQEw1s,60
+analyzerl_parser-0.1.2.dist-info/WHEEL,sha256=ZiBmjEMKX1iTyJmqXZl_jTcrFdOtPkEbr7SVi1lbRvI,95
+analyzerl_parser-0.1.2.dist-info/sboms/analyzerl_boxcars.cyclonedx.json,sha256=4FlZMlzEPVRYofRbkDlpHpV0pOxB98mAsFAehoH_4J8,179469
+analyzerl_parser-0.1.2.dist-info/RECORD,,

analyzerl_parser-0.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.14.0)
+Root-Is-Purelib: false
+Tag: cp39-abi3-win_amd64