spforge 0.8.19__tar.gz → 0.8.20__tar.gz

{spforge-0.8.19/spforge.egg-info → spforge-0.8.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.19
+Version: 0.8.20
 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.19 → spforge-0.8.20}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.19"
+version = "0.8.20"
 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.19 → spforge-0.8.20}/spforge/ratings/_player_rating.py

@@ -484,26 +484,31 @@ class PlayerRatingGenerator(RatingGenerator):
                     ),
                 )
 
-                off_perf = float(pre_player.match_performance.performance_value)
-                def_perf = float(team1_def_perf)  # same for all players on team1 (derived)
-
-                if not self.use_off_def_split:
-                    pred_def = pred_off
-                    def_perf = off_perf
-
-                mult_off = self._applied_multiplier_off(off_state)
-                mult_def = self._applied_multiplier_def(def_state)
-
-                off_change = (
-                    (off_perf - float(pred_off))
-                    * mult_off
-                    * float(pre_player.match_performance.participation_weight)
-                )
-                def_change = (
-                    (def_perf - float(pred_def))
-                    * mult_def
-                    * float(pre_player.match_performance.participation_weight)
-                )
+                perf_value = pre_player.match_performance.performance_value
+                if perf_value is None:
+                    off_change = 0.0
+                    def_change = 0.0
+                else:
+                    off_perf = float(perf_value)
+                    def_perf = float(team1_def_perf)
+
+                    if not self.use_off_def_split:
+                        pred_def = pred_off
+                        def_perf = off_perf
+
+                    mult_off = self._applied_multiplier_off(off_state)
+                    mult_def = self._applied_multiplier_def(def_state)
+
+                    off_change = (
+                        (off_perf - float(pred_off))
+                        * mult_off
+                        * float(pre_player.match_performance.participation_weight)
+                    )
+                    def_change = (
+                        (def_perf - float(pred_def))
+                        * mult_def
+                        * float(pre_player.match_performance.participation_weight)
+                    )
 
                 if math.isnan(off_change) or math.isnan(def_change):
                     raise ValueError(
@@ -562,32 +567,37 @@ class PlayerRatingGenerator(RatingGenerator):
                     ),
                 )
 
-                off_perf = float(pre_player.match_performance.performance_value)
-                def_perf = float(team2_def_perf)
-
-                if not self.use_off_def_split:
-                    pred_def = pred_off
-                    def_perf = off_perf
-
-                mult_off = self._applied_multiplier_off(off_state)
-                mult_def = self._applied_multiplier_def(def_state)
-
-                off_change = (
-                    (off_perf - float(pred_off))
-                    * mult_off
-                    * float(pre_player.match_performance.participation_weight)
-                )
-                def_change = (
-                    (def_perf - float(pred_def))
-                    * mult_def
-                    * float(pre_player.match_performance.participation_weight)
-                )
-
-                if math.isnan(off_change) or math.isnan(def_change):
-                    raise ValueError(
-                        f"NaN player rating change for player_id={pid}, match_id={r[cn.match_id]}"
+                perf_value = pre_player.match_performance.performance_value
+                if perf_value is None:
+                    off_change = 0.0
+                    def_change = 0.0
+                else:
+                    off_perf = float(perf_value)
+                    def_perf = float(team2_def_perf)
+
+                    if not self.use_off_def_split:
+                        pred_def = pred_off
+                        def_perf = off_perf
+
+                    mult_off = self._applied_multiplier_off(off_state)
+                    mult_def = self._applied_multiplier_def(def_state)
+
+                    off_change = (
+                        (off_perf - float(pred_off))
+                        * mult_off
+                        * float(pre_player.match_performance.participation_weight)
+                    )
+                    def_change = (
+                        (def_perf - float(pred_def))
+                        * mult_def
+                        * float(pre_player.match_performance.participation_weight)
                     )
 
+                    if math.isnan(off_change) or math.isnan(def_change):
+                        raise ValueError(
+                            f"NaN player rating change for player_id={pid}, match_id={r[cn.match_id]}"
+                        )
+
                 player_updates.append(
                     (
                         pid,
@@ -933,7 +943,7 @@ class PlayerRatingGenerator(RatingGenerator):
                     self.performance_column in team_player
                     and team_player[self.performance_column] is not None
                 )
-                else 0.0
+                else None
             )
 
             mp = MatchPerformance(
@@ -1023,18 +1033,22 @@ class PlayerRatingGenerator(RatingGenerator):
 
     def _team_off_perf_from_collection(self, c: PreMatchPlayersCollection) -> float:
         # observed offense perf = weighted mean of player performance_value using participation_weight if present
+        # skip players with null performance
         cn = self.column_names
         if not c.pre_match_player_ratings:
             return 0.0
         wsum = 0.0
         psum = 0.0
         for pre in c.pre_match_player_ratings:
+            perf_val = pre.match_performance.performance_value
+            if perf_val is None:
+                continue
             w = (
                 float(pre.match_performance.participation_weight)
                 if cn.participation_weight
                 else 1.0
             )
-            psum += float(pre.match_performance.performance_value) * w
+            psum += float(perf_val) * w
             wsum += w
         return psum / wsum if wsum else 0.0
 
@@ -1101,13 +1115,13 @@ class PlayerRatingGenerator(RatingGenerator):
             self.PLAYER_PRED_PERF_COL: [],
         }
 
-        def get_perf_value(team_player: dict) -> float:
+        def get_perf_value(team_player: dict) -> float | None:
             if (
                 self.performance_column in team_player
                 and team_player[self.performance_column] is not None
             ):
                 return float(team_player[self.performance_column])
-            return 0.0
+            return None
 
         def ensure_new_player(
             pid: str,
@@ -1187,8 +1201,9 @@ class PlayerRatingGenerator(RatingGenerator):
                     )
                     off_vals.append(float(local_off[pid].rating_value))
 
-                    psum += float(mp.performance_value) * float(pw)
-                    wsum += float(pw)
+                    if mp.performance_value is not None:
+                        psum += float(mp.performance_value) * float(pw)
+                        wsum += float(pw)
 
                 team_off_perf = psum / wsum if wsum else 0.0
                 return pre_list, player_ids, off_vals, proj_w, team_off_perf

{spforge-0.8.19 → spforge-0.8.20/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.19
+Version: 0.8.20
 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.19 → spforge-0.8.20}/tests/ratings/test_player_rating_generator.py

@@ -722,6 +722,198 @@ def test_fit_transform_null_performance_handling(base_cn, sample_df):
     assert len(res) == 4
 
 
+def test_fit_transform_null_performance__no_rating_change(base_cn):
+    """Players with null performance should have zero rating change, not be treated as 0.0 perf."""
+    # Match 1: Both players have performance (P1=0.6, P2=0.4)
+    # Match 2: P1 has null performance, P2 has 0.6
+    # Match 3: Both players have performance again
+    df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P1", "P2", "P1", "P2"],
+            "tid": ["T1", "T2", "T1", "T2", "T1", "T2"],
+            "mid": ["M1", "M1", "M2", "M2", "M3", "M3"],
+            "dt": [
+                "2024-01-01",
+                "2024-01-01",
+                "2024-01-02",
+                "2024-01-02",
+                "2024-01-03",
+                "2024-01-03",
+            ],
+            "perf": [0.6, 0.4, None, 0.6, 0.6, 0.4],  # P1 has null in M2
+            "pw": [1.0, 1.0, 1.0, 1.0, 1.0, 1.0],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+    )
+    result = gen.fit_transform(df)
+
+    # Get P1's pre-match rating for M2 (after M1) and M3 (after M2 with null perf)
+    p1_rating_before_m2 = result.filter(
+        (pl.col("pid") == "P1") & (pl.col("mid") == "M2")
+    )["player_off_rating_perf"][0]
+    p1_rating_before_m3 = result.filter(
+        (pl.col("pid") == "P1") & (pl.col("mid") == "M3")
+    )["player_off_rating_perf"][0]
+
+    # Key assertion: P1's rating before M3 should equal rating before M2
+    # because null performance in M2 means NO rating change
+    assert p1_rating_before_m3 == p1_rating_before_m2, (
+        f"P1's rating changed after null performance game! "
+        f"Before M2={p1_rating_before_m2}, Before M3={p1_rating_before_m3}"
+    )
+
+    # Also verify null is not treated as 0.0 by comparing with explicit 0.0
+    df_with_zero = df.with_columns(
+        pl.when((pl.col("pid") == "P1") & (pl.col("mid") == "M2"))
+        .then(0.0)
+        .otherwise(pl.col("perf"))
+        .alias("perf")
+    )
+
+    gen_zero = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+    )
+    result_zero = gen_zero.fit_transform(df_with_zero)
+
+    p1_rating_before_m3_with_zero = result_zero.filter(
+        (pl.col("pid") == "P1") & (pl.col("mid") == "M3")
+    )["player_off_rating_perf"][0]
+
+    # With 0.0 perf, rating should drop (different from null)
+    assert p1_rating_before_m3 > p1_rating_before_m3_with_zero, (
+        f"Null performance is being treated as 0.0! "
+        f"Rating with null={p1_rating_before_m3}, rating with 0.0={p1_rating_before_m3_with_zero}"
+    )
+
+
+def test_fit_transform_null_performance__still_outputs_player_rating(base_cn):
+    """Players with null performance should still have their pre-match rating in output."""
+    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, None, 0.4, 0.5],  # P2 has null performance
+            "pw": [1.0, 1.0, 1.0, 1.0],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+    )
+    result = gen.fit_transform(df)
+
+    # P2 should still be in output with their pre-match rating
+    assert len(result) == 4
+    p2_row = result.filter(pl.col("pid") == "P2")
+    assert len(p2_row) == 1
+    assert "player_off_rating_perf" in result.columns
+    # P2's rating should be the start rating (1000.0) since they're new and had no update
+    assert p2_row["player_off_rating_perf"][0] == 1000.0
+
+
+def test_transform_null_performance__no_rating_change(base_cn):
+    """In transform (historical), null performance should result in no rating change."""
+    # First fit with some data
+    fit_df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2"],
+            "tid": ["T1", "T2"],
+            "mid": ["M1", "M1"],
+            "dt": ["2024-01-01", "2024-01-01"],
+            "perf": [0.6, 0.4],
+            "pw": [1.0, 1.0],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+    )
+    gen.fit_transform(fit_df)
+
+    p1_rating_before = gen._player_off_ratings["P1"].rating_value
+
+    # Now transform with P1 having null performance
+    transform_df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2"],
+            "tid": ["T1", "T2"],
+            "mid": ["M2", "M2"],
+            "dt": ["2024-01-02", "2024-01-02"],
+            "perf": [None, 0.6],  # P1 has null
+            "pw": [1.0, 1.0],
+        }
+    )
+
+    gen.transform(transform_df)
+
+    p1_rating_after = gen._player_off_ratings["P1"].rating_value
+
+    # P1's rating should not change significantly (only confidence decay, not performance-based)
+    # Since null perf means no rating change from performance
+    assert abs(p1_rating_after - p1_rating_before) < 0.01, (
+        f"P1's rating changed significantly with null performance: "
+        f"before={p1_rating_before}, after={p1_rating_after}"
+    )
+
+
+def test_future_transform_null_performance__outputs_projections(base_cn):
+    """In future_transform, null performance should still output rating projections."""
+    # First fit with some data
+    fit_df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2"],
+            "tid": ["T1", "T2"],
+            "mid": ["M1", "M1"],
+            "dt": ["2024-01-01", "2024-01-01"],
+            "perf": [0.6, 0.4],
+            "pw": [1.0, 1.0],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+    )
+    gen.fit_transform(fit_df)
+
+    p1_rating_before = gen._player_off_ratings["P1"].rating_value
+
+    # Future transform (no performance needed, but if null it shouldn't affect anything)
+    future_df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2"],
+            "tid": ["T1", "T2"],
+            "mid": ["M2", "M2"],
+            "dt": ["2024-01-02", "2024-01-02"],
+            "pw": [1.0, 1.0],
+            # No perf column - this is a future match
+        }
+    )
+
+    result = gen.future_transform(future_df)
+
+    # Should output projections for all players
+    assert len(result) == 2
+    assert "player_off_rating_perf" in result.columns
+
+    # Ratings should NOT be updated (future_transform doesn't update state)
+    assert gen._player_off_ratings["P1"].rating_value == p1_rating_before
+
+
 # --- transform & future_transform Tests ---