spforge 0.8.19__py3-none-any.whl → 0.8.20__py3-none-any.whl

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.dist-info → spforge-0.8.20.dist-info}/METADATA

@@ -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.dist-info → spforge-0.8.20.dist-info}/RECORD

@@ -51,7 +51,7 @@ spforge/performance_transformers/_performance_manager.py,sha256=WmjmlMEnq7y75MiI
 spforge/performance_transformers/_performances_transformers.py,sha256=0lxuWjAfWBRXRgQsNJHjw3P-nlTtHBu4_bOVdoy7hq4,15536
 spforge/ratings/__init__.py,sha256=OZVH2Lo6END3n1X8qi4QcyAPlThIwAYwVKCiIuOQSQU,576
 spforge/ratings/_base.py,sha256=dRMkIGj5-2zKddygaEA4g16WCyXon7v8Xa1ymm7IuoM,14335
-spforge/ratings/_player_rating.py,sha256=JSTXdaRw_b8ZoZxgmMnZrYG7gPg8GKawqalLd16SK1M,56066
+spforge/ratings/_player_rating.py,sha256=TI0mEGZKEkf86TzOcP689C1jClYrXncjOnGwtsltMrk,56734
 spforge/ratings/_team_rating.py,sha256=T0kFiv3ykYSrVGGsVRa8ZxLB0WMnagxqdFDzl9yZ_9g,24813
 spforge/ratings/enums.py,sha256=s7z_RcZS6Nlgfa_6tasO8_IABZJwywexe7sep9DJBgo,1739
 spforge/ratings/league_identifier.py,sha256=_KDUKOwoNU6RNFKE5jju4eYFGVNGBdJsv5mhNvMakfc,6019
@@ -71,7 +71,7 @@ spforge/transformers/_other_transformer.py,sha256=w2a7Wnki3vJe4GAkSa4kealw0GILIo
 spforge/transformers/_predictor.py,sha256=2sE6gfVrilXzPVcBurSrtqHw33v2ljygQcEYXt9LhZc,3119
 spforge/transformers/_simple_transformer.py,sha256=zGUFNQYMeoDSa2CoQejQNiNmKCBN5amWTvyOchiUHj0,5660
 spforge/transformers/_team_ratio_predictor.py,sha256=g8_bR53Yyv0iNCtol1O9bgJSeZcIco_AfbQuUxQJkeY,6884
-spforge-0.8.19.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.20.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 tests/test_autopipeline.py,sha256=7cNAn-nmGolfyfk3THh9IKcHZfRA-pLYC_xAyMg-No4,26863
 tests/test_autopipeline_context.py,sha256=IuRUY4IA6uMObvbl2pXSaXO2_tl3qX6wEbTZY0dkTMI,1240
 tests/test_feature_generator_pipeline.py,sha256=CK0zVL8PfTncy3RmG9i-YpgwjOIV7yJhV7Q44tbetI8,19020
@@ -94,7 +94,7 @@ tests/hyperparameter_tuning/test_estimator_tuner.py,sha256=iewME41d6LR2aQ0OtohGF
 tests/hyperparameter_tuning/test_rating_tuner.py,sha256=usjC2ioO_yWRjjNAlRTyMVYheOrCi0kKocmHQHdTmpM,18699
 tests/performance_transformers/test_performance_manager.py,sha256=gjuuV_hb27kCo_kUecPKG3Cbot2Gqis1W3kw2A4ovS4,10690
 tests/performance_transformers/test_performances_transformers.py,sha256=A-tGiCx7kXrj1cVj03Bc7prOeZ1_Ryz8YFx9uj3eK6w,11064
-tests/ratings/test_player_rating_generator.py,sha256=SKLaBQBsHYslc2Nia2AxZ8A9Cy16MbZAWjLyOjvcMnA,64094
+tests/ratings/test_player_rating_generator.py,sha256=Bb_KR61-DbRUSiZDyfdSvZpMrJ0QDGHxGMFBNTq3Igw,70813
 tests/ratings/test_player_rating_no_mutation.py,sha256=GzO3Hl__5K68DS3uRLefwnbcTJOvBM7cZqww4M21UZM,8493
 tests/ratings/test_ratings_property.py,sha256=ckyfGILXa4tfQvsgyXEzBDNr2DUmHwFRV13N60w66iE,6561
 tests/ratings/test_team_rating_generator.py,sha256=cDnf1zHiYC7pkgydE3MYr8wSTJIq-bPfSqhIRI_4Tic,95357
@@ -107,7 +107,7 @@ tests/transformers/test_other_transformer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRk
 tests/transformers/test_predictor_transformer.py,sha256=N1aBYLjN3ldpYZLwjih_gTFYSMitrZu-PNK78W6RHaQ,6877
 tests/transformers/test_simple_transformer.py,sha256=wWR0qjLb_uS4HXrJgGdiqugOY1X7kwd1_OPS02IT2b8,4676
 tests/transformers/test_team_ratio_predictor.py,sha256=fOUP_JvNJi-3kom3ZOs1EdG0I6Z8hpLpYKNHu1eWtOw,8562
-spforge-0.8.19.dist-info/METADATA,sha256=4q1uKNTzmI9bwRwMJQaM0N6SAaC1RDembf_Gfbm2-mw,20048
-spforge-0.8.19.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-spforge-0.8.19.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
-spforge-0.8.19.dist-info/RECORD,,
+spforge-0.8.20.dist-info/METADATA,sha256=27uVILTzrjbdXCa91c0X4d9Fbfrw1bIOyuHFy45Nejw,20048
+spforge-0.8.20.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+spforge-0.8.20.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
+spforge-0.8.20.dist-info/RECORD,,

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 ---