rustat-python-api 0.9.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

rustat_python_api/matching/__init__.py

@@ -1,9 +1,29 @@
 from .dataloader import MatchInferLoader
 from .pc_adder import PitchControlAdder
 from .tr_adder import TrackingFeaturesAdder
+from .shot_loader import ShotInferLoader
+from .shot_features import (
+    build_shot_features,
+    identify_goalkeepers,
+    filter_shots,
+    compute_event_features,
+    compute_tracking_features,
+    compute_pitch_control,
+    SHOT_NUMERIC_COLS,
+    SHOT_CATEGORICAL_COLS,
+)
 
 __all__ = [
     "PitchControlAdder",
     "TrackingFeaturesAdder",
-    "MatchInferLoader"
+    "MatchInferLoader",
+    "ShotInferLoader",
+    "build_shot_features",
+    "identify_goalkeepers",
+    "filter_shots",
+    "compute_event_features",
+    "compute_tracking_features",
+    "compute_pitch_control",
+    "SHOT_NUMERIC_COLS",
+    "SHOT_CATEGORICAL_COLS",
 ]

rustat_python_api/matching/shot_features.py

@@ -0,0 +1,324 @@
+"""Shot-level feature engineering for xG.
+
+Pure functions that take events + tracking + ball and return a DataFrame of
+shot rows with event, goalkeeper, opponent, shooter and pitch-control features.
+
+Shared between:
+  - training pipelines (models repo)
+  - xG inference server (models repo, src/api)
+  - clients that call DynamoLab (e.g. pdf-report-creator/plots/plot_config.py)
+
+The contract: shot ordering and column names are stable, so a model trained
+on cache built by `build_shot_features` can be served against features built
+by the same function on inference data.
+"""
+
+import numpy as np
+import pandas as pd
+from ast import literal_eval
+
+
+GOAL_CENTER = np.array([105.0, 34.0])
+POST_LEFT = np.array([105.0, 34.0 - 3.66])
+POST_RIGHT = np.array([105.0, 34.0 + 3.66])
+
+
+SHOT_NUMERIC_COLS = [
+    'pos_x', 'pos_y', 'distance_to_goal', 'goal_angle',
+    'gk_projection', 'gk_shift',
+    'opp_in_cone', 'opp_between',
+    'opp_radius_3m', 'opp_radius_5m', 'opp_radius_10m',
+    'nearest_opp_dist', 'shooter_speed',
+    'pc_r3', 'pc_r5', 'pc_r10',
+]
+
+SHOT_CATEGORICAL_COLS = ['body_name', 'shot_type', 'attack_type_name', 'standart_name']
+
+
+def filter_shots(events: pd.DataFrame) -> pd.DataFrame:
+    events = events.copy()
+    events['tags'] = events['tags'].astype(str).apply(literal_eval)
+    events['sub_tags'] = events['sub_tags'].astype(str).apply(literal_eval)
+
+    mask = events['tags'].apply(lambda t: 'shot' in t or 'goal' in t)
+    shots = events[mask].copy()
+
+    shots['is_goal'] = shots['tags'].apply(lambda t: 'goal' in t).astype(int)
+
+    return shots.reset_index(drop=True)
+
+
+def compute_event_features(shots: pd.DataFrame) -> pd.DataFrame:
+    shots = shots.copy()
+
+    dx = GOAL_CENTER[0] - shots['pos_x'].values
+    dy = GOAL_CENTER[1] - shots['pos_y'].values
+    shots['distance_to_goal'] = np.sqrt(dx ** 2 + dy ** 2)
+
+    shot_pos = shots[['pos_x', 'pos_y']].values
+    vec_left = POST_LEFT - shot_pos
+    vec_right = POST_RIGHT - shot_pos
+
+    dot = np.sum(vec_left * vec_right, axis=1)
+    mag_left = np.linalg.norm(vec_left, axis=1)
+    mag_right = np.linalg.norm(vec_right, axis=1)
+
+    cos_angle = np.clip(dot / (mag_left * mag_right + 1e-9), -1, 1)
+    shots['goal_angle'] = np.arccos(cos_angle)
+
+    return shots
+
+
+def identify_goalkeepers(events: pd.DataFrame) -> dict[int, int]:
+    """Map team_id -> goalkeeper player_id from `position_name`."""
+    gk_rows = events[
+        events['position_name'].astype(str).str.contains('Goalkeeper', case=False, na=False)
+    ][['team_id', 'player_id']].drop_duplicates()
+
+    gk_ids = {}
+    for _, row in gk_rows.iterrows():
+        tid = int(row['team_id'])
+        pid = int(row['player_id'])
+        gk_ids[tid] = pid
+    return gk_ids
+
+
+def _find_goalkeeper(tracking_at_shot: pd.DataFrame, team_id: int,
+                     gk_ids: dict[int, int]) -> pd.Series | None:
+    opp_team = tracking_at_shot[tracking_at_shot['team_id'] != team_id]
+    opp_team_id = opp_team['team_id'].iloc[0] if len(opp_team) > 0 else None
+
+    if opp_team_id is not None and opp_team_id in gk_ids:
+        gk_row = opp_team[opp_team['player_id'] == gk_ids[opp_team_id]]
+        if len(gk_row) > 0:
+            return gk_row.iloc[0]
+
+    if len(opp_team) > 0:
+        return opp_team.loc[opp_team['pos_x'].idxmax()]
+
+    return None
+
+
+def _get_tracking_at_time(tracking: pd.DataFrame, half: int, second: float) -> pd.DataFrame:
+    half_tracking = tracking[tracking['half'] == half]
+    if half_tracking.empty:
+        return half_tracking
+
+    closest_second = half_tracking.iloc[
+        (half_tracking['second'].values - second).astype(float).__abs__().argmin()
+    ]['second']
+
+    return half_tracking[half_tracking['second'] == closest_second]
+
+
+def _build_side_by_half(tracking: pd.DataFrame) -> dict[int, dict[int, str]]:
+    side_1h = {}
+    for tid in tracking['team_id'].unique():
+        side_1h[tid] = tracking[tracking['team_id'] == tid]['side_1h'].iloc[0]
+
+    side_by_half = {1: {}, 2: {}}
+    for tid, side in side_1h.items():
+        side_by_half[1][tid] = side
+        side_by_half[2][tid] = 'right' if side == 'left' else 'left'
+
+    return side_by_half
+
+
+def _normalize_snapshot(snapshot: pd.DataFrame, shooting_team_id: int,
+                        side_by_half: dict, half: int) -> pd.DataFrame:
+    team_side = side_by_half[half].get(shooting_team_id)
+
+    if team_side == 'right':
+        snapshot = snapshot.copy()
+        snapshot['pos_x'] = 105.0 - snapshot['pos_x']
+        snapshot['pos_y'] = 68.0 - snapshot['pos_y']
+
+    return snapshot
+
+
+def compute_tracking_features(
+        shots: pd.DataFrame,
+        tracking: pd.DataFrame,
+        gk_ids: dict[int, int],
+) -> pd.DataFrame:
+    shots = shots.copy()
+    side_by_half = _build_side_by_half(tracking)
+
+    gk_projection_vals = []
+    gk_shift_vals = []
+    opp_in_cone_vals = []
+    opp_between_vals = []
+    opp_radius_3_vals = []
+    opp_radius_5_vals = []
+    opp_radius_10_vals = []
+    nearest_opp_dist_vals = []
+    shooter_speed_vals = []
+
+    for _, shot in shots.iterrows():
+        half = shot['half']
+        second = shot['second']
+        team_id = shot['team_id']
+        pos = np.array([shot['pos_x'], shot['pos_y']])
+
+        snapshot = _get_tracking_at_time(tracking, half, second)
+
+        if snapshot.empty:
+            gk_projection_vals.append(np.nan)
+            gk_shift_vals.append(np.nan)
+            opp_in_cone_vals.append(np.nan)
+            opp_between_vals.append(np.nan)
+            opp_radius_3_vals.append(np.nan)
+            opp_radius_5_vals.append(np.nan)
+            opp_radius_10_vals.append(np.nan)
+            nearest_opp_dist_vals.append(np.nan)
+            shooter_speed_vals.append(np.nan)
+            continue
+
+        snapshot = _normalize_snapshot(snapshot, int(team_id), side_by_half, half)
+
+        opponents = snapshot[snapshot['team_id'] != team_id]
+        opp_pos = opponents[['pos_x', 'pos_y']].values.astype(float)
+
+        gk = _find_goalkeeper(snapshot, team_id, gk_ids)
+
+        if gk is not None:
+            gk_pos = np.array([float(gk['pos_x']), float(gk['pos_y'])])
+
+            vec_gb = pos - GOAL_CENTER
+            vec_gk = gk_pos - GOAL_CENTER
+            dot_proj = np.dot(vec_gk, vec_gb)
+            dot_gb = np.dot(vec_gb, vec_gb)
+            projection = dot_proj / (dot_gb + 1e-9)
+            projection = np.clip(projection, 0, 1)
+            gk_projection_vals.append(projection)
+
+            ball_side = np.sign(pos[1] - GOAL_CENTER[1])
+            if ball_side == 0:
+                ball_side = 1.0
+            gk_shift = (gk_pos[1] - GOAL_CENTER[1]) * ball_side
+            gk_shift_vals.append(gk_shift)
+        else:
+            gk_projection_vals.append(np.nan)
+            gk_shift_vals.append(np.nan)
+
+        if len(opp_pos) > 0:
+            opp_between = int(np.sum(opp_pos[:, 0] > pos[0]))
+            opp_between_vals.append(opp_between)
+
+            dists = np.sqrt(np.sum((opp_pos - pos) ** 2, axis=1))
+
+            opp_radius_3_vals.append(int(np.sum(dists < 3)))
+            opp_radius_5_vals.append(int(np.sum(dists < 5)))
+            opp_radius_10_vals.append(int(np.sum(dists < 10)))
+            nearest_opp_dist_vals.append(float(np.min(dists)))
+
+            vec_to_left = POST_LEFT - pos
+            vec_to_right = POST_RIGHT - pos
+
+            def _cross_2d(a, b):
+                return a[0] * b[1] - a[1] * b[0]
+
+            in_cone = 0
+            for op in opp_pos:
+                if op[0] <= pos[0]:
+                    continue
+                vec_to_opp = op - pos
+                cross_left = _cross_2d(vec_to_left, vec_to_opp)
+                cross_right = _cross_2d(vec_to_right, vec_to_opp)
+                if cross_left * cross_right <= 0:
+                    in_cone += 1
+            opp_in_cone_vals.append(in_cone)
+        else:
+            opp_between_vals.append(0)
+            opp_radius_3_vals.append(0)
+            opp_radius_5_vals.append(0)
+            opp_radius_10_vals.append(0)
+            nearest_opp_dist_vals.append(np.nan)
+            opp_in_cone_vals.append(0)
+
+        shooter_id = shot.get('player_id')
+        if pd.notna(shooter_id):
+            shooter_track = snapshot[snapshot['player_id'] == int(shooter_id)]
+            if len(shooter_track) > 0 and 'speed' in shooter_track.columns:
+                shooter_speed_vals.append(float(shooter_track.iloc[0]['speed']))
+            else:
+                shooter_speed_vals.append(np.nan)
+        else:
+            shooter_speed_vals.append(np.nan)
+
+    shots['gk_projection'] = gk_projection_vals
+    shots['gk_shift'] = gk_shift_vals
+    shots['opp_in_cone'] = opp_in_cone_vals
+    shots['opp_between'] = opp_between_vals
+    shots['opp_radius_3m'] = opp_radius_3_vals
+    shots['opp_radius_5m'] = opp_radius_5_vals
+    shots['opp_radius_10m'] = opp_radius_10_vals
+    shots['nearest_opp_dist'] = nearest_opp_dist_vals
+    shots['shooter_speed'] = shooter_speed_vals
+
+    return shots
+
+
+def compute_pitch_control(
+        shots: pd.DataFrame,
+        tracking: pd.DataFrame,
+        ball: pd.DataFrame,
+        device: str = "cpu",
+        backend: str = "pt",
+) -> pd.DataFrame:
+    from .pc_adder import PitchControlAdder
+
+    shots = shots.copy()
+
+    try:
+        tracking = tracking.copy()
+        tracking['team_id'] = tracking['team_id'].astype(str)
+        shots['team_id'] = shots['team_id'].astype(int)
+
+        pc_adder = PitchControlAdder(shots, tracking, ball, device=device, backend=backend)
+        pc_adder.run(modes=['mean'] * 3, rads=[3, 5, 10])
+        shots = pc_adder.events
+
+        rename_map = {}
+        for col in shots.columns:
+            if col.startswith('pc_mean_src_r'):
+                r = col.replace('pc_mean_src_r', '')
+                rename_map[col] = f'pc_r{r}'
+        shots = shots.rename(columns=rename_map)
+
+        dest_cols = [c for c in shots.columns if 'pc_mean_dest' in c]
+        shots = shots.drop(columns=dest_cols, errors='ignore')
+    except Exception as e:
+        print(f"  [WARNING] Pitch control failed: {e}")
+        shots['pc_r3'] = np.nan
+        shots['pc_r5'] = np.nan
+        shots['pc_r10'] = np.nan
+
+    return shots
+
+
+def build_shot_features(
+        events: pd.DataFrame,
+        tracking: pd.DataFrame,
+        ball: pd.DataFrame,
+        gk_ids: dict[int, int] | None = None,
+        device: str = "cpu",
+        backend: str = "pt",
+) -> pd.DataFrame:
+    """Full pipeline: filter shots -> event features -> tracking features -> pitch control.
+
+    If `gk_ids` is None, goalkeepers are identified from `events['position_name']`.
+    """
+    if gk_ids is None:
+        gk_ids = identify_goalkeepers(events)
+
+    shots = filter_shots(events)
+
+    if shots.empty:
+        return shots
+
+    shots = compute_event_features(shots)
+    shots = compute_tracking_features(shots, tracking, gk_ids)
+    shots = compute_pitch_control(shots, tracking, ball, device=device, backend=backend)
+
+    return shots

rustat_python_api/matching/shot_loader.py

@@ -0,0 +1,49 @@
+"""Client-side shot loader for xG inference.
+
+Mirrors `MatchInferLoader` but produces a shot-level DataFrame (`shots_tr`)
+ready to be sent to `DynamoLab.run_model('xG (tracking)', ...)`. Preserves
+the original event index in `orig_index`, so the caller can scatter the
+returned xG column back onto the full events DataFrame:
+
+    events.loc[shots_tr['orig_index'], 'xG'] = shots_tr['xG']
+"""
+
+import pandas as pd
+
+from .shot_features import build_shot_features, identify_goalkeepers
+
+
+class ShotInferLoader:
+    def __init__(
+            self,
+            events: pd.DataFrame, tracking: pd.DataFrame, ball: pd.DataFrame,
+            gk_ids: dict[int, int] | None = None,
+            device: str = "cpu", backend: str = "pt",
+    ):
+        self.events = events
+        self.tracking = tracking
+        self.ball = ball
+        self.gk_ids = gk_ids
+        self.device = device
+        self.backend = backend
+
+        self.shots: pd.DataFrame | None = None
+
+    def _save_index(self) -> None:
+        self.events = self.events.copy()
+        self.events['orig_index'] = self.events.index
+
+    def _build_shots(self) -> None:
+        gk_ids = self.gk_ids if self.gk_ids is not None else identify_goalkeepers(self.events)
+        self.shots = build_shot_features(
+            self.events, self.tracking, self.ball, gk_ids,
+            device=self.device, backend=self.backend,
+        )
+
+    def fit(self, inplace: bool = False) -> pd.DataFrame | None:
+        self._save_index()
+        self._build_shots()
+
+        if not inplace:
+            return self.shots
+        return None

{rustat_python_api-0.9.1.dist-info → rustat_python_api-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: rustat-python-api
-Version: 0.9.1
+Version: 0.10.0
 Summary: A Python wrapper for RuStat API
 Home-page: https://github.com/dailydaniel/rustat-python-api
 Author: Daniel Zholkovsky

{rustat_python_api-0.9.1.dist-info → rustat_python_api-0.10.0.dist-info}/RECORD

@@ -7,12 +7,14 @@ rustat_python_api/processing.py,sha256=sjZdjSs2BKyM_f7T_Utu1CJSF1l-V8UsWrAj7dhqy
 rustat_python_api/urls.py,sha256=iJTD31T6OyXPAhmhViwFXVehrzwsOjBDONA1SIVc_40,1068
 rustat_python_api/kernels/__init__.py,sha256=eFJ-BMY8VcNZSjf3XjOnZf_nfOQ5t-7Lp57DPCHYOo0,124
 rustat_python_api/kernels/maha.py,sha256=k2PqY6VghgER2j9QH8xGYq61JLfPaHjirLXb4aLnjQw,2591
-rustat_python_api/matching/__init__.py,sha256=QIqkft_NVban8p0rxJsim3x4defZN3eQBqZfWcm0Acs,217
+rustat_python_api/matching/__init__.py,sha256=K6MYaVQuPXD9ybgJBap_PFsLVmJa0-yTBdDEAO8_vBo,739
 rustat_python_api/matching/dataloader.py,sha256=FZ95ZC5Z-6FrZEVy-d5S1rXt5nIBwYMqTT0hvFlc4mI,2753
 rustat_python_api/matching/pc_adder.py,sha256=oP84iplIqmqF1jFDN9ernkjKw7wgsmWbuOVPEsoTNWM,7582
+rustat_python_api/matching/shot_features.py,sha256=sSMm1fM1Ob2kuWD1Ltc679TuSCAtyHwtqRpMNF4okk4,10890
+rustat_python_api/matching/shot_loader.py,sha256=2cvJ1Q63QMdYWsYA9-PVYY9DZx6tbbRpW_LXB_WDBt0,1581
 rustat_python_api/matching/tr_adder.py,sha256=0sAjYfoLitScDhg2yjh2PIKWTseoaSeUa5chPnVau-Q,16025
-rustat_python_api-0.9.1.dist-info/LICENSE,sha256=4Cohqg5p6Mq1xyrzdEX8AvFSA62GSVvapEOr2xK_tgY,57
-rustat_python_api-0.9.1.dist-info/METADATA,sha256=LYy7zRsQOHNNVbPGmsZZ12iMj9Pn1UZ1gE3-NhUG2FM,1920
-rustat_python_api-0.9.1.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-rustat_python_api-0.9.1.dist-info/top_level.txt,sha256=VK0hmkKZE9YThxolUcoE6JtGI67NFeKJMBLuet8kI4w,18
-rustat_python_api-0.9.1.dist-info/RECORD,,
+rustat_python_api-0.10.0.dist-info/LICENSE,sha256=4Cohqg5p6Mq1xyrzdEX8AvFSA62GSVvapEOr2xK_tgY,57
+rustat_python_api-0.10.0.dist-info/METADATA,sha256=y5uyWPoC1Rq6OK0dWA7jt-yWJQAzZx5XBhoaxZNGtQc,1921
+rustat_python_api-0.10.0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+rustat_python_api-0.10.0.dist-info/top_level.txt,sha256=VK0hmkKZE9YThxolUcoE6JtGI67NFeKJMBLuet8kI4w,18
+rustat_python_api-0.10.0.dist-info/RECORD,,