spforge 0.8.29__tar.gz → 0.8.31__tar.gz

{spforge-0.8.29/spforge.egg-info → spforge-0.8.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.29
+Version: 0.8.31
 Summary: A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data.
 Author-email: Mathias Holmstrøm <mathiasholmstom@gmail.com>
 License: See LICENSE file

{spforge-0.8.29 → spforge-0.8.31}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.29"
+version = "0.8.31"
 description = "A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data."
 readme = "README.md"
 requires-python = ">=3.11"

{spforge-0.8.29 → spforge-0.8.31}/spforge/data_structures.py

@@ -12,6 +12,8 @@ class ColumnNames:
     position: str | None = None
     participation_weight: str | None = None
     projected_participation_weight: str | None = None
+    defense_participation_weight: str | None = None
+    projected_defense_participation_weight: str | None = None
     update_match_id: str | None = None
     parent_team_id: str | None = None
     team_players_playing_time: str | None = None
@@ -81,6 +83,8 @@ class MatchPerformance:
     performance_value: float | None
     participation_weight: float | None
     projected_participation_weight: float
+    defense_participation_weight: float | None = None
+    projected_defense_participation_weight: float | None = None
     team_players_playing_time: dict[str, float] | None = None
     opponent_players_playing_time: dict[str, float] | None = None
 

{spforge-0.8.29 → spforge-0.8.31}/spforge/ratings/_player_rating.py

@@ -39,6 +39,8 @@ from spforge.feature_generator._utils import to_polars
 PLAYER_STATS = "__PLAYER_STATS"
 _SCALED_PW = "__scaled_participation_weight__"
 _SCALED_PPW = "__scaled_projected_participation_weight__"
+_SCALED_DPW = "__scaled_defense_participation_weight__"
+_SCALED_PDPW = "__scaled_projected_defense_participation_weight__"
 
 
 class PlayerRatingGenerator(RatingGenerator):
@@ -186,6 +188,8 @@ class PlayerRatingGenerator(RatingGenerator):
         self.auto_scale_participation_weights = bool(auto_scale_participation_weights)
         self._participation_weight_max: float | None = None
         self._projected_participation_weight_max: float | None = None
+        self._defense_participation_weight_max: float | None = None
+        self._projected_defense_participation_weight_max: float | None = None
 
         self._player_off_ratings: dict[str, PlayerRating] = {}
         self._player_def_ratings: dict[str, PlayerRating] = {}
@@ -233,8 +237,11 @@ class PlayerRatingGenerator(RatingGenerator):
             eps = 1e-6
             return min_val < -eps or max_val > (1.0 + eps)
 
-        if _out_of_bounds(cn.participation_weight) or _out_of_bounds(
-            cn.projected_participation_weight
+        if (
+            _out_of_bounds(cn.participation_weight)
+            or _out_of_bounds(cn.projected_participation_weight)
+            or _out_of_bounds(cn.defense_participation_weight)
+            or _out_of_bounds(cn.projected_defense_participation_weight)
         ):
             self.scale_participation_weights = True
             logging.warning(
@@ -289,6 +296,25 @@ class PlayerRatingGenerator(RatingGenerator):
         elif self._participation_weight_max is not None:
             self._projected_participation_weight_max = self._participation_weight_max
 
+        if cn.defense_participation_weight and cn.defense_participation_weight in df.columns:
+            q_val = pl_df[cn.defense_participation_weight].quantile(0.99, "linear")
+            if q_val is not None:
+                self._defense_participation_weight_max = float(q_val)
+        elif self._participation_weight_max is not None:
+            self._defense_participation_weight_max = self._participation_weight_max
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+        ):
+            q_val = pl_df[cn.projected_defense_participation_weight].quantile(0.99, "linear")
+            if q_val is not None:
+                self._projected_defense_participation_weight_max = float(q_val)
+        elif self._defense_participation_weight_max is not None:
+            self._projected_defense_participation_weight_max = self._defense_participation_weight_max
+        elif self._projected_participation_weight_max is not None:
+            self._projected_defense_participation_weight_max = self._projected_participation_weight_max
+
     def _scale_participation_weight_columns(self, df: pl.DataFrame) -> pl.DataFrame:
         """Create internal scaled participation weight columns without mutating originals."""
         if not self.scale_participation_weights:
@@ -321,6 +347,32 @@ class PlayerRatingGenerator(RatingGenerator):
                 .alias(_SCALED_PPW)
             )
 
+        if (
+            cn.defense_participation_weight
+            and cn.defense_participation_weight in df.columns
+            and self._defense_participation_weight_max is not None
+            and self._defense_participation_weight_max > 0
+        ):
+            denom = float(self._defense_participation_weight_max)
+            df = df.with_columns(
+                (pl.col(cn.defense_participation_weight) / denom)
+                .clip(0.0, 1.0)
+                .alias(_SCALED_DPW)
+            )
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+            and self._projected_defense_participation_weight_max is not None
+            and self._projected_defense_participation_weight_max > 0
+        ):
+            denom = float(self._projected_defense_participation_weight_max)
+            df = df.with_columns(
+                (pl.col(cn.projected_defense_participation_weight) / denom)
+                .clip(0.0, 1.0)
+                .alias(_SCALED_PDPW)
+            )
+
         return df
 
     def _get_participation_weight_col(self) -> str:
@@ -339,7 +391,9 @@ class PlayerRatingGenerator(RatingGenerator):
 
     def _remove_internal_scaled_columns(self, df: pl.DataFrame) -> pl.DataFrame:
         """Remove internal scaled columns before returning."""
-        cols_to_drop = [c for c in [_SCALED_PW, _SCALED_PPW] if c in df.columns]
+        cols_to_drop = [
+            c for c in [_SCALED_PW, _SCALED_PPW, _SCALED_DPW, _SCALED_PDPW] if c in df.columns
+        ]
         if cols_to_drop:
             df = df.drop(cols_to_drop)
         return df
@@ -541,7 +595,7 @@ class PlayerRatingGenerator(RatingGenerator):
                         * float(pre_player.match_performance.participation_weight)
                     )
 
-                if perf_value is None or team1_def_perf is None:
+                if team1_def_perf is None:
                     def_change = 0.0
                 else:
                     def_perf = float(team1_def_perf)
@@ -554,7 +608,7 @@ class PlayerRatingGenerator(RatingGenerator):
                     def_change = (
                         (def_perf - float(pred_def))
                         * mult_def
-                        * float(pre_player.match_performance.participation_weight)
+                        * float(pre_player.match_performance.defense_participation_weight)
                     )
 
                 if math.isnan(off_change) or math.isnan(def_change):
@@ -635,7 +689,7 @@ class PlayerRatingGenerator(RatingGenerator):
                         * float(pre_player.match_performance.participation_weight)
                     )
 
-                if perf_value is None or team2_def_perf is None:
+                if team2_def_perf is None:
                     def_change = 0.0
                 else:
                     def_perf = float(team2_def_perf)
@@ -648,7 +702,7 @@ class PlayerRatingGenerator(RatingGenerator):
                     def_change = (
                         (def_perf - float(pred_def))
                         * mult_def
-                        * float(pre_player.match_performance.participation_weight)
+                        * float(pre_player.match_performance.defense_participation_weight)
                     )
 
                 if math.isnan(off_change) or math.isnan(def_change):
@@ -922,6 +976,19 @@ class PlayerRatingGenerator(RatingGenerator):
         if _SCALED_PPW in df.columns:
             player_stat_cols.append(_SCALED_PPW)
 
+        if cn.defense_participation_weight and cn.defense_participation_weight in df.columns:
+            player_stat_cols.append(cn.defense_participation_weight)
+        if _SCALED_DPW in df.columns:
+            player_stat_cols.append(_SCALED_DPW)
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+        ):
+            player_stat_cols.append(cn.projected_defense_participation_weight)
+        if _SCALED_PDPW in df.columns:
+            player_stat_cols.append(_SCALED_PDPW)
+
         if cn.position and cn.position in df.columns:
             player_stat_cols.append(cn.position)
 
@@ -1041,6 +1108,28 @@ class PlayerRatingGenerator(RatingGenerator):
                 projected_participation_weight = participation_weight
             projected_participation_weights.append(projected_participation_weight)
 
+            # Use scaled defense participation weight if available, otherwise default to participation_weight
+            if _SCALED_DPW in team_player:
+                defense_participation_weight = team_player.get(_SCALED_DPW, participation_weight)
+            elif cn.defense_participation_weight:
+                defense_participation_weight = team_player.get(
+                    cn.defense_participation_weight, participation_weight
+                )
+            else:
+                defense_participation_weight = participation_weight
+
+            # Use scaled projected defense participation weight if available
+            if _SCALED_PDPW in team_player:
+                projected_defense_participation_weight = team_player.get(
+                    _SCALED_PDPW, defense_participation_weight
+                )
+            elif cn.projected_defense_participation_weight:
+                projected_defense_participation_weight = team_player.get(
+                    cn.projected_defense_participation_weight, defense_participation_weight
+                )
+            else:
+                projected_defense_participation_weight = defense_participation_weight
+
             perf_val = (
                 float(team_player[self.performance_column])
                 if (
@@ -1061,6 +1150,8 @@ class PlayerRatingGenerator(RatingGenerator):
                 performance_value=perf_val,
                 projected_participation_weight=projected_participation_weight,
                 participation_weight=participation_weight,
+                defense_participation_weight=defense_participation_weight,
+                projected_defense_participation_weight=projected_defense_participation_weight,
                 team_players_playing_time=team_playing_time,
                 opponent_players_playing_time=opponent_playing_time,
             )
@@ -1296,6 +1387,22 @@ class PlayerRatingGenerator(RatingGenerator):
                         ppw = pw
                     proj_w.append(float(ppw))
 
+                    # Use scaled defense participation weight if available
+                    if _SCALED_DPW in tp:
+                        dpw = tp.get(_SCALED_DPW, pw)
+                    elif cn.defense_participation_weight:
+                        dpw = tp.get(cn.defense_participation_weight, pw)
+                    else:
+                        dpw = pw
+
+                    # Use scaled projected defense participation weight if available
+                    if _SCALED_PDPW in tp:
+                        pdpw = tp.get(_SCALED_PDPW, dpw)
+                    elif cn.projected_defense_participation_weight:
+                        pdpw = tp.get(cn.projected_defense_participation_weight, dpw)
+                    else:
+                        pdpw = dpw
+
                     team_playing_time = self._get_players_playing_time(
                         tp, cn.team_players_playing_time
                     )
@@ -1307,6 +1414,8 @@ class PlayerRatingGenerator(RatingGenerator):
                         performance_value=get_perf_value(tp),
                         projected_participation_weight=ppw,
                         participation_weight=pw,
+                        defense_participation_weight=dpw,
+                        projected_defense_participation_weight=pdpw,
                         team_players_playing_time=team_playing_time,
                         opponent_players_playing_time=opponent_playing_time,
                     )

{spforge-0.8.29 → spforge-0.8.31/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.29
+Version: 0.8.31
 Summary: A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data.
 Author-email: Mathias Holmstrøm <mathiasholmstom@gmail.com>
 License: See LICENSE file

{spforge-0.8.29 → spforge-0.8.31}/tests/ratings/test_player_rating_generator.py

@@ -2133,6 +2133,59 @@ def test_fit_transform_when_all_players_have_null_performance_then_no_rating_cha
     )
 
 
+def test_null_individual_perf_still_updates_def_rating(base_cn):
+    """
+    Regression test: Players with null individual performance should still get DEF updates.
+
+    Bug: Line 598 had `if perf_value is None or team1_def_perf is None: def_change = 0.0`
+         This incorrectly skipped DEF updates when player had null individual performance.
+
+    Fix: Changed to `if team1_def_perf is None: def_change = 0.0`
+         Defense is team-level, so null individual perf should NOT block DEF updates.
+
+    Test creates scenario where P1 has null perf but team defense is known (poor).
+    Verifies P1's DEF rating decreases (proving defensive update logic ran).
+    """
+    # Match 1: Balanced to establish baseline ratings
+    # Match 2: P1 null perf, but T2 dominates offense (0.9) so T1 defense is poor (0.1)
+    df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4", "P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2", "T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1", "M2", "M2", "M2", "M2"],
+            "dt": ["2024-01-01"] * 4 + ["2024-01-02"] * 4,
+            "perf": [0.5, 0.5, 0.5, 0.5, None, 0.1, 0.9, 0.9],
+            "pw": [1.0] * 8,
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        use_off_def_split=True,
+        rating_change_multiplier_offense=50.0,  # High multipliers to ensure visible changes
+        rating_change_multiplier_defense=50.0,
+        start_rating_value=1000.0,
+    )
+    gen.fit_transform(df)
+
+    # P1 had null perf in M2, so OFF rating should be unchanged from baseline
+    p1_off = gen._player_off_ratings["P1"].rating_value
+    assert p1_off == 1000.0, f"P1 OFF should be 1000 (null perf), got {p1_off}"
+
+    # P1's DEF rating MUST decrease because T1's defense was poor (0.1) in M2
+    # Team defense = 1.0 - opponent offense = 1.0 - 0.9 = 0.1 (much worse than expected 0.5)
+    p1_def = gen._player_def_ratings["P1"].rating_value
+    assert p1_def < 1000.0, (
+        f"P1 DEF should decrease (team defended poorly), but got {p1_def}. "
+        f"Bug: defensive update was incorrectly skipped for null individual performance."
+    )
+
+    # Sanity check: P2 had valid perf (0.1) so OFF should change too
+    p2_off = gen._player_off_ratings["P2"].rating_value
+    assert p2_off != 1000.0, f"P2 OFF should change (valid perf 0.1), got {p2_off}"
+
+
 # --- team_players_playing_time Tests ---
 
 
@@ -2710,3 +2763,114 @@ def test_ignore_opponent_predictor_reference_rating_set_correctly(base_cn):
     assert gen5._performance_predictor._reference_rating == 1200.0, (
         f"Expected hardcoded start rating 1200.0 to take precedence, got {gen5._performance_predictor._reference_rating}"
     )
+
+
+def test_separate_offense_defense_participation_weights(base_cn):
+    """Test that offense and defense use separate participation weights.
+
+    When participation_weight represents offensive activity (e.g., shots attempted),
+    using it for both offense and defense updates creates bias. This test verifies
+    that defense_participation_weight is used for defensive rating updates.
+    """
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        participation_weight="shots_attempted",
+        defense_participation_weight="minutes",
+    )
+
+    # Create a scenario where a high-volume shooter (many shots) faces a low-volume shooter
+    # The high-volume shooter should have larger offensive updates but equal defensive updates
+    df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.6, 0.4, 0.5, 0.5],  # Varying performance values
+            "shots_attempted": [10.0, 10.0, 10.0, 10.0],  # Same offensive activity
+            "minutes": [30.0, 30.0, 30.0, 30.0],  # Same defensive activity
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        rating_change_multiplier_offense=50,
+        rating_change_multiplier_defense=50,
+    )
+
+    result = gen.fit_transform(df)
+
+    # Verify that the defense_participation_weight column is present in the data
+    assert "minutes" in df.columns
+
+    # All players performed equally (0.5) with equal participation weights,
+    # so ratings should be symmetric
+    assert "P1" in gen._player_off_ratings
+    assert "P1" in gen._player_def_ratings
+
+    # Now test with different participation weights for offense vs defense
+    df2 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M2", "M2", "M2", "M2"],
+            "dt": ["2024-01-02"] * 4,
+            "perf": [0.6, 0.4, 0.5, 0.5],
+            "shots_attempted": [20.0, 5.0, 10.0, 10.0],  # P1 shoots much more
+            "minutes": [30.0, 30.0, 30.0, 30.0],  # But all play same minutes
+        }
+    )
+
+    result2 = gen.fit_transform(df2)
+
+    # P1 should have larger offensive rating changes due to high shots_attempted
+    # but equal defensive rating changes due to equal minutes played
+    p1_off = gen._player_off_ratings["P1"]
+    p2_off = gen._player_off_ratings["P2"]
+    p1_def = gen._player_def_ratings["P1"]
+    p2_def = gen._player_def_ratings["P2"]
+
+    # Both players have same games_played count for defense
+    assert p1_def.games_played == p2_def.games_played
+
+    # Verify that ratings were updated
+    assert p1_off.games_played > 0
+    assert p2_off.games_played > 0
+
+
+@pytest.mark.parametrize("library", ["polars", "pandas"])
+def test_defense_participation_weight_backwards_compatibility(base_cn, library):
+    """Test that when defense_participation_weight is not set, it defaults to participation_weight."""
+    import pandas as pd
+
+    df_data = {
+        "pid": ["P1", "P2", "P3", "P4"],
+        "tid": ["T1", "T1", "T2", "T2"],
+        "mid": ["M1", "M1", "M1", "M1"],
+        "dt": ["2024-01-01"] * 4,
+        "perf": [0.6, 0.4, 0.5, 0.5],
+        "pw": [1.0, 0.5, 0.8, 0.8],
+    }
+
+    if library == "polars":
+        df = pl.DataFrame(df_data)
+    else:
+        df = pd.DataFrame(df_data)
+
+    # When defense_participation_weight is None, it should default to participation_weight
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        auto_scale_performance=True,
+    )
+
+    result = gen.fit_transform(df)
+
+    # Should work without errors
+    assert result is not None
+    assert len(gen._player_off_ratings) > 0
+    assert len(gen._player_def_ratings) > 0