cs2df 3.0.2__tar.gz → 3.0.3__tar.gz

{cs2df-3.0.2 → cs2df-3.0.3}/.gitignore

@@ -4,6 +4,7 @@ dist/
 *.d.ts
 .DS_Store
 .omc/
+.codegraph/
 __pycache__/
 *.py[cod]
 .pytest_cache/

{cs2df-3.0.2 → cs2df-3.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cs2df
-Version: 3.0.2
+Version: 3.0.3
 Summary: Reference exporter & validator CLI for cs2-demo-format v3 (CS2 demo → ZIP data package)
 Project-URL: Homepage, https://github.com/Starfie1d1272/cs2-demo-format
 Project-URL: Repository, https://github.com/Starfie1d1272/cs2-demo-format

{cs2df-3.0.2 → cs2df-3.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cs2df"
-version = "3.0.2"
+version = "3.0.3"
 description = "Reference exporter & validator CLI for cs2-demo-format v3 (CS2 demo → ZIP data package)"
 readme = "README.md"
 requires-python = ">=3.11"

{cs2df-3.0.2 → cs2df-3.0.3}/src/cs2df/__init__.py

@@ -5,7 +5,7 @@ demoparser2 / pandas stack installed. Heavy imports are deferred into the
 submodules that need them.
 """
 
-__version__ = "3.0.0"
+__version__ = "3.0.3"
 
 SCHEMA_VERSION = "cs2-demo-format/3.0"
 EXPORTER_NAME = "cs2df"

{cs2df-3.0.2 → cs2df-3.0.3}/src/cs2df/events.py

@@ -121,7 +121,8 @@ def _active_event_round_number(round_model: _RoundModel, row: dict) -> int | Non
         return None
     tick = int(row.get("tick") or 0)
     window = round_model.window_for_round(n)
-    if window is None or tick < window.freeze_end_tick or tick > window.end_tick:
+    event_end = round_model.event_end_tick(n)
+    if window is None or event_end is None or tick < window.freeze_end_tick or tick > event_end:
         return None
     return n
 
@@ -372,7 +373,8 @@ def build_bombs(raw: dict, players: PlayerDirectory, round_model: _RoundModel) -
                 continue
             tick = int(r.get("tick") or 0)
             window = round_model.window_for_round(n)
-            if window is None or tick < window.freeze_end_tick or tick > window.end_tick:
+            event_end = round_model.event_end_tick(n)
+            if window is None or event_end is None or tick < window.freeze_end_tick or tick > event_end:
                 continue
             actor_sid = _sid(r.get("user_steamid") or r.get("steamid") or r.get("userid"))
             site = bomb_site_from_place(r.get("user_last_place_name"))
@@ -431,7 +433,8 @@ def build_grenades(raw: dict, players: PlayerDirectory, round_model: _RoundModel
             continue
         tick = int(r.get("tick") or 0)
         window = round_model.window_for_round(n)
-        if window is None or tick < window.freeze_end_tick or tick > window.end_tick:
+        event_end = round_model.event_end_tick(n)
+        if window is None or event_end is None or tick < window.freeze_end_tick or tick > event_end:
             continue
         gtype = str(r.get("_grenade_type") or "")
         if gtype not in _GRENADE_TYPE_ENUM:
@@ -460,7 +463,7 @@ def build_grenades(raw: dict, players: PlayerDirectory, round_model: _RoundModel
         if not _is_valid_side(round_model.side_map.get((n, players.team(thrower_sid)), "unknown")):
             continue
         if destroy_tick is not None and (
-            destroy_tick < tick or window is None or destroy_tick > window.end_tick
+            destroy_tick < tick or event_end is None or destroy_tick > event_end
         ):
             destroy_tick = None
 
@@ -489,13 +492,13 @@ def build_grenades(raw: dict, players: PlayerDirectory, round_model: _RoundModel
     for g in out:
         if g["grenade"] != "molotov" or g["destroyTick"] is not None:
             continue
-        window = round_model.window_for_round(g["roundNumber"])
+        event_end = round_model.event_end_tick(g["roundNumber"])
         best = None
         best_d2 = None
         for e in expires:
             if e["used"] or e["rn"] != g["roundNumber"] or e["tick"] < g["effectTick"]:
                 continue
-            if window is not None and e["tick"] > window.end_tick:
+            if event_end is not None and e["tick"] > event_end:
                 continue
             ep, gp = e["pos"], g["effectPosition"]
             d2 = (ep["x"] - gp["x"]) ** 2 + (ep["y"] - gp["y"]) ** 2
@@ -521,11 +524,11 @@ def build_grenades(raw: dict, players: PlayerDirectory, round_model: _RoundModel
         eid = g.pop("_entityId", None)
         if g["grenade"] != "smoke" or eid is None:
             continue
-        window = round_model.window_for_round(g["roundNumber"])
+        event_end = round_model.event_end_tick(g["roundNumber"])
         for e in smoke_index.get((g["roundNumber"], eid), []):
             if e["tick"] < g["effectTick"]:
                 continue
-            if window is not None and e["tick"] > window.end_tick:
+            if event_end is not None and e["tick"] > event_end:
                 continue
             g["destroyTick"] = e["tick"]
             break

{cs2df-3.0.2 → cs2df-3.0.3}/src/cs2df/parse.py

@@ -351,7 +351,7 @@ def parse_demo(dem_path: str, *, sample_rate: int = 8, research: bool = False,
     stage_started = time.perf_counter()
     round_ends = g_round["round_end"]
     step = max(1, tickrate // max(1, sample_rate))
-    replay_ticks = _build_sample_ticks(round_ends, round_freeze_ends, step)
+    replay_ticks = _build_sample_ticks(round_ends, round_freeze_ends, g_round["round_start"], step)
     replay_df = _safe_ticks_df(p, _REPLAY_PROPS, replay_ticks) if replay_ticks else None
     _record("parse.replayGrid", stage_started)
 
@@ -368,7 +368,8 @@ def parse_demo(dem_path: str, *, sample_rate: int = 8, research: bool = False,
         _p("duel windows (full tick)", 0.78)
         anchor_ticks = [int(r.get("tick") or 0) for r in deaths + hurts]
         duel_windows = _merge_windows(anchor_ticks, round_ends, round_freeze_ends,
-                                      tickrate, window_before_ms, window_after_ms)
+                                      g_round["round_start"], tickrate,
+                                      window_before_ms, window_after_ms)
         duel_ticks: list[int] = []
         for start, end in duel_windows:
             duel_ticks.extend(range(start, end + 1))
@@ -444,34 +445,50 @@ def _freeze_by_round(round_freeze_ends: list[dict]) -> dict[int, int]:
     return out
 
 
+def _round_starts_by_round(round_starts: list[dict]) -> dict[int, int]:
+    out: dict[int, int] = {}
+    for r in round_starts:
+        rn = int(r.get("total_rounds_played") or 0) + 1
+        t = int(r.get("tick") or 0)
+        if rn > 0 and t > 0 and rn not in out:
+            out[rn] = t
+    return out
+
+
 def _round_spans(round_ends: list[dict],
-                 round_freeze_ends: list[dict]) -> list[tuple[int, int]]:
-    """[(freeze_end_tick, end_tick)] for rounds with a valid window."""
+                 round_freeze_ends: list[dict],
+                 round_starts: list[dict] | None = None) -> list[tuple[int, int]]:
+    """[(freeze_end_tick, event_end_tick)] for rounds with a valid window."""
     freeze = _freeze_by_round(round_freeze_ends)
+    starts = _round_starts_by_round(round_starts or [])
     spans: list[tuple[int, int]] = []
     for r in round_ends:
         rn = int(r.get("total_rounds_played") or 0)
         end_t = int(r.get("tick") or 0)
+        next_start_t = starts.get(rn + 1)
+        event_end_t = next_start_t - 1 if next_start_t is not None else end_t
         start_t = freeze.get(rn, 0)
-        if start_t > 0 and end_t > start_t:
-            spans.append((start_t, end_t))
+        if start_t > 0 and event_end_t > start_t:
+            spans.append((start_t, event_end_t))
     return spans
 
 
 def _build_sample_ticks(round_ends: list[dict], round_freeze_ends: list[dict],
+                        round_starts: list[dict],
                         step: int) -> list[int]:
-    """Sorted unique sample ticks at interval `step` within active play."""
+    """Sorted unique sample ticks through the post-round tail."""
     ticks: list[int] = []
-    for start_t, end_t in _round_spans(round_ends, round_freeze_ends):
-        ticks.extend(range(start_t, end_t, step))
+    for start_t, end_t in _round_spans(round_ends, round_freeze_ends, round_starts):
+        ticks.extend(range(start_t, end_t + 1, step))
     return sorted(set(ticks))
 
 
 def _merge_windows(anchor_ticks: list[int], round_ends: list[dict],
-                   round_freeze_ends: list[dict], tickrate: int,
+                   round_freeze_ends: list[dict], round_starts: list[dict],
+                   tickrate: int,
                    before_ms: int, after_ms: int) -> list[tuple[int, int]]:
     """Merged [start, end] full-tick combat windows, clamped to round spans."""
-    spans = _round_spans(round_ends, round_freeze_ends)
+    spans = _round_spans(round_ends, round_freeze_ends, round_starts)
     if not spans or not anchor_ticks:
         return []
     before = (before_ms * tickrate) // 1000

{cs2df-3.0.2 → cs2df-3.0.3}/src/cs2df/rounds.py

@@ -57,6 +57,7 @@ class _RoundModel:
     # Indexes built in __post_init__; events are resolved per-row across every
     # builder, so these turn O(rounds) scans into O(1)/O(log rounds) lookups.
     _by_round: dict[int, _RoundWindow] = field(init=False, repr=False, default_factory=dict)
+    _event_end_by_round: dict[int, int] = field(init=False, repr=False, default_factory=dict)
     _sorted_starts: list[int] = field(init=False, repr=False, default_factory=list)
     _sorted_windows: list[_RoundWindow] = field(init=False, repr=False, default_factory=list)
 
@@ -65,6 +66,12 @@ class _RoundModel:
         ordered = sorted(self.windows, key=lambda w: w.start_tick)
         self._sorted_windows = ordered
         self._sorted_starts = [w.start_tick for w in ordered]
+        self._event_end_by_round = {}
+        for i, window in enumerate(ordered):
+            next_start = ordered[i + 1].start_tick if i + 1 < len(ordered) else None
+            self._event_end_by_round[window.round_number] = (
+                next_start - 1 if next_start is not None else window.end_tick
+            )
 
     def window_for_round(self, round_number: int) -> _RoundWindow | None:
         return self._by_round.get(round_number)
@@ -72,15 +79,19 @@ class _RoundModel:
     def has_round(self, round_number: int) -> bool:
         return round_number in self._by_round
 
+    def event_end_tick(self, round_number: int) -> int | None:
+        return self._event_end_by_round.get(round_number)
+
     def round_for_tick(self, tick: int) -> int | None:
         # Windows are sorted by start_tick and non-overlapping: the candidate is
-        # the last window whose start_tick <= tick; confirm tick is within it
-        # (ticks falling in inter-round gaps resolve to None, as before).
+        # the last window whose start_tick <= tick; confirm tick is before the
+        # next round start (or <= end_tick for the final round).
         i = bisect.bisect_right(self._sorted_starts, tick) - 1
         if i < 0:
             return None
         window = self._sorted_windows[i]
-        return window.round_number if window.start_tick <= tick <= window.end_tick else None
+        event_end = self.event_end_tick(window.round_number)
+        return window.round_number if event_end is not None and window.start_tick <= tick <= event_end else None
 
     def round_for_event(self, row: dict) -> int | None:
         tick = int(row.get("tick") or 0)

{cs2df-3.0.2 → cs2df-3.0.3}/src/cs2df/streams.py

@@ -178,8 +178,11 @@ def build_replay(raw: dict, players: PlayerDirectory, round_model: _RoundModel,
         })
 
     rounds_out: list[dict] = []
-    for w in sorted(round_model.windows, key=lambda w: w.round_number):
-        grid = np.arange(w.freeze_end_tick, w.end_tick, step, dtype="int64")
+    windows = sorted(round_model.windows, key=lambda w: w.round_number)
+    for i, w in enumerate(windows):
+        next_start_tick = windows[i + 1].start_tick if i + 1 < len(windows) else None
+        stop_tick = next_start_tick if next_start_tick is not None else w.end_tick + 1
+        grid = np.arange(w.freeze_end_tick, stop_tick, step, dtype="int64")
         if len(grid) == 0:
             continue
         sl = _slice_by_tick(df, tick_values, int(grid[0]), int(grid[-1]))

{cs2df-3.0.2 → cs2df-3.0.3}/src/cs2df/validate.py

@@ -339,7 +339,8 @@ def _check_shots_stream(shots: dict, n_players: int, round_set: set,
                 break
         ticks = decode_delta(t.get("tick", []))
         rd = rounds_by_number.get(t.get("roundNumber"))
-        if rd and ticks and not all(rd.get("freezeEndTick", 0) <= tk <= rd.get("endTick", 0) for tk in ticks):
+        event_end = _round_event_end(rounds_by_number, t.get("roundNumber"))
+        if rd and ticks and event_end is not None and not all(rd.get("freezeEndTick", 0) <= tk <= event_end for tk in ticks):
             err(f"{label}: decoded ticks fall outside the round window")
 
 
@@ -370,7 +371,8 @@ def _check_replay_stream(replay: dict, n_players: int, round_set: set,
         step = rd_obj.get("tickStep", 1)
         if fc and rd:
             last_tick = start + (fc - 1) * step
-            if start < rd.get("freezeEndTick", 0) or last_tick > rd.get("endTick", 0):
+            event_end = _round_event_end(rounds_by_number, rn)
+            if event_end is not None and (start < rd.get("freezeEndTick", 0) or last_tick > event_end):
                 err(f"{label}: frame grid [{start}, {last_tick}] outside round window")
         for pi, track in enumerate(rd_obj.get("players", [])):
             tlabel = f"{label} players[{pi}]"
@@ -414,7 +416,8 @@ def _check_duels_stream(duels: dict, n_players: int, round_set: set,
         step = w.get("tickStep", 1)
         if fc and rd:
             last_tick = start + (fc - 1) * step
-            if start < rd.get("freezeEndTick", 0) or last_tick > rd.get("endTick", 0):
+            event_end = _round_event_end(rounds_by_number, rn)
+            if event_end is not None and (start < rd.get("freezeEndTick", 0) or last_tick > event_end):
                 err(f"{label}: frame grid [{start}, {last_tick}] outside round window")
         anchors = w.get("anchors", [])
         if not anchors:
@@ -499,7 +502,7 @@ def _check_tick_windows(name: str, rows: list, rounds_by_number: dict, err,
             if not isinstance(tick, int):
                 continue
             start = round_row.get("freezeEndTick")
-            end = round_row.get("endTick")
+            end = _round_event_end(rounds_by_number, row.get("roundNumber"))
             if not isinstance(start, int) or not isinstance(end, int):
                 continue
             if tick < start or tick > end:
@@ -510,6 +513,17 @@ def _check_tick_windows(name: str, rows: list, rounds_by_number: dict, err,
         err(f"{name}.json: {len(bad)} row(s) have ticks outside their round window; sample: {sample}")
 
 
+def _round_event_end(rounds_by_number: dict, round_number) -> int | None:
+    round_row = rounds_by_number.get(round_number)
+    if not isinstance(round_row, dict):
+        return None
+    next_round = rounds_by_number.get(round_number + 1) if isinstance(round_number, int) else None
+    if isinstance(next_round, dict) and isinstance(next_round.get("startTick"), int):
+        return next_round["startTick"] - 1
+    end_tick = round_row.get("endTick")
+    return end_tick if isinstance(end_tick, int) else None
+
+
 def _check_bomb_lifecycle(bombs: list, err):
     by_round: dict[object, list[dict]] = {}
     for b in bombs:

cs2df-3.0.3/tests/test_replay_boundaries.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import pandas as pd
+
+from cs2df.events import PlayerDirectory
+from cs2df.parse import _build_sample_ticks
+from cs2df.rounds import _RoundModel, _RoundWindow
+from cs2df.streams import build_replay
+
+
+def _replay_row(tick: int) -> dict:
+    return {
+        "steamid": "76561198000000001",
+        "tick": tick,
+        "active_weapon_name": "ak47",
+        "last_place_name": "Middle",
+        "inventory": [],
+        "X": tick,
+        "Y": tick + 1,
+        "Z": tick + 2,
+        "yaw": 90,
+        "pitch": 0,
+        "balance": 800,
+        "current_equip_value": 2700,
+        "health": 100,
+        "armor": 100,
+        "flash_duration": 0,
+        "has_defuser": False,
+    }
+
+
+def test_replay_round_extends_to_sample_before_next_round_start():
+    players = PlayerDirectory([
+        {"steamId64": "76561198000000001", "name": "p1", "teamKey": "teamA"},
+    ])
+    round_model = _RoundModel(
+        windows=[
+            _RoundWindow(round_number=1, start_tick=50, freeze_end_tick=100, end_tick=200),
+            _RoundWindow(round_number=2, start_tick=300, freeze_end_tick=360, end_tick=460),
+        ],
+        side_map={},
+    )
+    raw = {
+        "replay_df": pd.DataFrame([_replay_row(tick) for tick in range(100, 360, 16)]),
+        "grenade_trajectories": [],
+    }
+
+    replay = build_replay(raw, players, round_model, tickrate=128, sample_rate=8)
+
+    assert replay is not None
+    first_round = replay["rounds"][0]
+    last_tick = first_round["startTick"] + (first_round["frameCount"] - 1) * first_round["tickStep"]
+    assert last_tick == 292
+    assert last_tick < 300
+
+
+def test_parse_replay_ticks_include_post_round_tail_before_next_start():
+    round_ends = [
+        {"total_rounds_played": 1, "tick": 200},
+        {"total_rounds_played": 2, "tick": 460},
+    ]
+    round_freeze_ends = [
+        {"total_rounds_played": 0, "tick": 100},
+        {"total_rounds_played": 1, "tick": 360},
+    ]
+    round_starts = [
+        {"total_rounds_played": 0, "tick": 50},
+        {"total_rounds_played": 1, "tick": 300},
+    ]
+
+    ticks = _build_sample_ticks(round_ends, round_freeze_ends, round_starts, step=16)
+
+    assert 292 in ticks
+    assert 300 not in ticks

cs2df-3.0.3/tests/test_round_windows.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from cs2df.events import PlayerDirectory, build_kills
+from cs2df.rounds import _RoundModel, _RoundWindow
+
+
+def test_round_for_tick_assigns_post_round_tail_to_previous_round():
+    round_model = _RoundModel(
+        windows=[
+            _RoundWindow(round_number=1, start_tick=50, freeze_end_tick=100, end_tick=200),
+            _RoundWindow(round_number=2, start_tick=300, freeze_end_tick=360, end_tick=460),
+        ],
+        side_map={},
+    )
+
+    assert round_model.round_for_tick(200) == 1
+    assert round_model.round_for_tick(250) == 1
+    assert round_model.round_for_tick(299) == 1
+    assert round_model.round_for_tick(300) == 2
+
+
+def test_kills_after_round_end_before_next_start_are_kept_in_previous_round():
+    players = PlayerDirectory([
+        {"steamId64": "76561198000000001", "name": "attacker", "teamKey": "teamA"},
+        {"steamId64": "76561198000000002", "name": "victim", "teamKey": "teamB"},
+    ])
+    round_model = _RoundModel(
+        windows=[
+            _RoundWindow(round_number=1, start_tick=50, freeze_end_tick=100, end_tick=200),
+            _RoundWindow(round_number=2, start_tick=300, freeze_end_tick=360, end_tick=460),
+        ],
+        side_map={(1, "teamA"): "t", (1, "teamB"): "ct"},
+    )
+    raw = {
+        "deaths": [{
+            "tick": 250,
+            "user_steamid": "76561198000000002",
+            "attacker_steamid": "76561198000000001",
+            "weapon": "ak47",
+            "user_X": 1,
+            "user_Y": 2,
+            "user_Z": 3,
+        }],
+    }
+
+    kills = build_kills(raw, players, round_model)
+
+    assert len(kills) == 1
+    assert kills[0]["roundNumber"] == 1
+    assert kills[0]["tick"] == 250

cs2df-3.0.3/tests/test_version_consistency.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def test_check_versions_script_accepts_current_release_versions():
+    script = ROOT / "tools" / "check_versions.py"
+
+    result = subprocess.run(
+        [sys.executable, str(script)],
+        cwd=ROOT,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stdout + result.stderr

{cs2df-3.0.2 → cs2df-3.0.3}/uv.lock

@@ -30,7 +30,7 @@ wheels = [
 
 [[package]]
 name = "cs2df"
-version = "3.0.2"
+version = "3.0.3"
 source = { editable = "." }
 dependencies = [
     { name = "demoparser2" },