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

spforge/ratings/_base.py

@@ -176,6 +176,9 @@ class RatingGenerator(FeatureGenerator):
     @to_polars
     @nw.narwhalify
     def transform(self, df: IntoFrameT) -> IntoFrameT:
+        if self.performance_manager and self.performance_manager.ori_performance_column in df.columns:
+            df = nw.from_native(self.performance_manager.transform(df))
+
         pl_df: pl.DataFrame
         pl_df = df.to_native() if df.implementation.is_polars() else df.to_polars().to_native()
         return self._historical_transform(pl_df)
@@ -188,6 +191,9 @@ class RatingGenerator(FeatureGenerator):
         - use existing ratings to compute pre-match ratings/features
         - do NOT update ratings
         """
+        if self.performance_manager and self.performance_manager.ori_performance_column in df.columns:
+            df = nw.from_native(self.performance_manager.transform(df))
+
         pl_df: pl.DataFrame
         pl_df = df.to_native() if df.implementation.is_polars() else df.to_polars().to_native()
         return self._future_transform(pl_df)

spforge/ratings/_player_rating.py

@@ -433,9 +433,16 @@ class PlayerRatingGenerator(RatingGenerator):
             team1_off_perf = self._team_off_perf_from_collection(c1)
             team2_off_perf = self._team_off_perf_from_collection(c2)
 
+            team1_def_perf: float | None = None
+            team2_def_perf: float | None = None
+
             if self.use_off_def_split:
-                team1_def_perf = 1.0 - team2_off_perf
-                team2_def_perf = 1.0 - team1_off_perf
+                team1_def_perf = (
+                    1.0 - team2_off_perf if team2_off_perf is not None else None
+                )
+                team2_def_perf = (
+                    1.0 - team1_off_perf if team1_off_perf is not None else None
+                )
             else:
                 team1_def_perf = team1_off_perf
                 team2_def_perf = team2_off_perf
@@ -484,26 +491,33 @@ 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)
+                perf_value = pre_player.match_performance.performance_value
+                if perf_value is None:
+                    off_change = 0.0
+                else:
+                    off_perf = float(perf_value)
+                    mult_off = self._applied_multiplier_off(off_state)
+                    off_change = (
+                        (off_perf - float(pred_off))
+                        * mult_off
+                        * float(pre_player.match_performance.participation_weight)
+                    )
 
-                if not self.use_off_def_split:
-                    pred_def = pred_off
-                    def_perf = off_perf
+                if perf_value is None or team1_def_perf is None:
+                    def_change = 0.0
+                else:
+                    def_perf = float(team1_def_perf)
 
-                mult_off = self._applied_multiplier_off(off_state)
-                mult_def = self._applied_multiplier_def(def_state)
+                    if not self.use_off_def_split:
+                        pred_def = pred_off
+                        def_perf = float(perf_value)
 
-                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)
-                )
+                    mult_def = self._applied_multiplier_def(def_state)
+                    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,26 +576,33 @@ class PlayerRatingGenerator(RatingGenerator):
                     ),
                 )
 
-                off_perf = float(pre_player.match_performance.performance_value)
-                def_perf = float(team2_def_perf)
+                perf_value = pre_player.match_performance.performance_value
+                if perf_value is None:
+                    off_change = 0.0
+                else:
+                    off_perf = float(perf_value)
+                    mult_off = self._applied_multiplier_off(off_state)
+                    off_change = (
+                        (off_perf - float(pred_off))
+                        * mult_off
+                        * float(pre_player.match_performance.participation_weight)
+                    )
 
-                if not self.use_off_def_split:
-                    pred_def = pred_off
-                    def_perf = off_perf
+                if perf_value is None or team2_def_perf is None:
+                    def_change = 0.0
+                else:
+                    def_perf = float(team2_def_perf)
 
-                mult_off = self._applied_multiplier_off(off_state)
-                mult_def = self._applied_multiplier_def(def_state)
+                    if not self.use_off_def_split:
+                        pred_def = pred_off
+                        def_perf = float(perf_value)
 
-                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)
-                )
+                    mult_def = self._applied_multiplier_def(def_state)
+                    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(
@@ -933,7 +954,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(
@@ -1021,22 +1042,28 @@ class PlayerRatingGenerator(RatingGenerator):
 
         return pre_match_player_ratings, pre_match_player_off_values
 
-    def _team_off_perf_from_collection(self, c: PreMatchPlayersCollection) -> float:
+    def _team_off_perf_from_collection(
+        self, c: PreMatchPlayersCollection
+    ) -> float | None:
         # 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
+            return None
         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
+        return psum / wsum if wsum else None
 
     def _team_off_def_rating_from_collection(
         self, c: PreMatchPlayersCollection
@@ -1101,13 +1128,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 +1214,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/ratings/_team_rating.py

@@ -326,16 +326,7 @@ class TeamRatingGenerator(RatingGenerator):
             opp_off_pre = float(o_off.rating_value)
             opp_def_pre = float(o_def.rating_value)
 
-            off_perf = (
-                float(r[self.performance_column])
-                if r.get(self.performance_column) is not None
-                else 0.0
-            )
-            opp_off_perf = float(r[perf_opp_col]) if r.get(perf_opp_col) is not None else 0.0
-            if self.use_off_def_split:
-                def_perf = 1.0 - opp_off_perf
-            else:
-                def_perf = off_perf
+            off_perf_raw = r.get(self.performance_column)
 
             pred_off = self._performance_predictor.predict_performance(
                 rating_value=s_off.rating_value, opponent_team_rating_value=o_def.rating_value
@@ -346,16 +337,28 @@ class TeamRatingGenerator(RatingGenerator):
             if not self.use_off_def_split:
                 pred_def = pred_off
 
-            mult_off = self._applied_multiplier(s_off, self.rating_change_multiplier_offense)
-            mult_def = self._applied_multiplier(s_def, self.rating_change_multiplier_defense)
-
-            off_change = (off_perf - pred_off) * mult_off
-            def_change = (def_perf - pred_def) * mult_def
-
-            if math.isnan(off_change) or math.isnan(def_change):
-                raise ValueError(
-                    f"NaN rating change for team_id={team_id}, match_id={r[cn.match_id]}"
-                )
+            # Null performance means no rating change
+            if off_perf_raw is None:
+                off_change = 0.0
+                def_change = 0.0
+            else:
+                off_perf = float(off_perf_raw)
+                opp_off_perf = float(r[perf_opp_col]) if r.get(perf_opp_col) is not None else 0.0
+                if self.use_off_def_split:
+                    def_perf = 1.0 - opp_off_perf
+                else:
+                    def_perf = off_perf
+
+                mult_off = self._applied_multiplier(s_off, self.rating_change_multiplier_offense)
+                mult_def = self._applied_multiplier(s_def, self.rating_change_multiplier_defense)
+
+                off_change = (off_perf - pred_off) * mult_off
+                def_change = (def_perf - pred_def) * mult_def
+
+                if math.isnan(off_change) or math.isnan(def_change):
+                    raise ValueError(
+                        f"NaN rating change for team_id={team_id}, match_id={r[cn.match_id]}"
+                    )
 
             rows.append(
                 {

{spforge-0.8.19.dist-info → spforge-0.8.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.19
+Version: 0.8.23
 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.23.dist-info}/RECORD

@@ -50,9 +50,9 @@ spforge/performance_transformers/__init__.py,sha256=U6d7_kltbUMLYCGBk4QAFVPJTxXD
 spforge/performance_transformers/_performance_manager.py,sha256=WmjmlMEnq7y75MiI_s9Y-9eMXIyhPTUKrwsXRtgYp0k,9620
 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/_team_rating.py,sha256=T0kFiv3ykYSrVGGsVRa8ZxLB0WMnagxqdFDzl9yZ_9g,24813
+spforge/ratings/_base.py,sha256=ne4BRrYFPqMirdFPVnyDN44wjFQwOQgWoUXu_59xgWE,14687
+spforge/ratings/_player_rating.py,sha256=zhTI6isbNXYy9xAyMt_6nlOktsk6TukDVWV7vS7G4qg,57190
+spforge/ratings/_team_rating.py,sha256=3m90-R2zW0k5EHwjw-83Hacz91fGmxW1LQ8ZUGHlgt4,24970
 spforge/ratings/enums.py,sha256=s7z_RcZS6Nlgfa_6tasO8_IABZJwywexe7sep9DJBgo,1739
 spforge/ratings/league_identifier.py,sha256=_KDUKOwoNU6RNFKE5jju4eYFGVNGBdJsv5mhNvMakfc,6019
 spforge/ratings/league_start_rating_optimizer.py,sha256=Q4Vo3QT-r55qP4aD9WftsTB00UOSRvxM1khlyuAGWNM,8582
@@ -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.23.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,10 +94,10 @@ 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=51iWgQRBHbb2-IPeajpej9ncGDWI1eUYdWrLXaKd9Ig,72232
 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
+tests/ratings/test_team_rating_generator.py,sha256=SqQcfckNmJJc99feCdnmkNYDape-p69e92Dp8Vzpu2w,101156
 tests/ratings/test_utils_scaled_weights.py,sha256=iHxe6ZDUB_I2B6HT0xTGqXBkl7gRlqVV0e_7Lwun5po,4988
 tests/scorer/test_score.py,sha256=rw3xJs6xqWVpalVMUQz557m2JYGR7PmhrsjfTex0b0c,79121
 tests/scorer/test_score_aggregation_granularity.py,sha256=h-hyFOLzwp-92hYVU7CwvlRJ8jhB4DzXCtqgI-zcoqM,13677
@@ -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.23.dist-info/METADATA,sha256=jlkQ3fEjfwmJ_euPrFO6OlI-hT0LMQN928wz87B1qVU,20048
+spforge-0.8.23.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+spforge-0.8.23.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
+spforge-0.8.23.dist-info/RECORD,,

tests/ratings/test_player_rating_generator.py

@@ -107,6 +107,7 @@ def test_fit_transform_participation_weight_scaling(base_cn):
 
 def test_fit_transform_batch_update_logic(base_cn):
     """Test that ratings do not update between matches if update_match_id is the same."""
+    from dataclasses import replace
 
     df = pl.DataFrame(
         {
@@ -119,36 +120,25 @@ def test_fit_transform_batch_update_logic(base_cn):
             "pw": [1.0, 1.0, 1.0, 1.0],
         }
     )
-    from dataclasses import replace
 
     cn = replace(base_cn, update_match_id="update_id")
     gen = PlayerRatingGenerator(
-        performance_column="perf", column_names=cn, auto_scale_performance=True
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
     )
     output = gen.fit_transform(df)
 
-    assert len(output) >= 2
-
-    assert len(gen._player_off_ratings) > 0
+    assert len(output) == 4
 
+    m1_rows = output.filter(pl.col("mid") == "M1")
+    m2_rows = output.filter(pl.col("mid") == "M2")
+    assert m1_rows["player_off_rating_perf"][0] == 1000.0
+    assert m2_rows["player_off_rating_perf"][0] == 1000.0
 
-@pytest.mark.parametrize(
-    "feature",
-    [
-        RatingKnownFeatures.PLAYER_OFF_RATING,
-        RatingKnownFeatures.TEAM_OFF_RATING_PROJECTED,
-        RatingKnownFeatures.TEAM_RATING_DIFFERENCE_PROJECTED,
-    ],
-)
-def test_fit_transform_requested_features_presence(base_cn, sample_df, feature):
-    """Verify that specific requested features appear in the resulting DataFrame."""
-    gen = PlayerRatingGenerator(
-        performance_column="perf", column_names=base_cn, features_out=[feature]
-    )
-    res = gen.fit_transform(sample_df)
-
-    expected_col = f"{feature}_perf"
-    assert expected_col in res.columns
+    assert gen._player_off_ratings["P1"].rating_value > 1000.0
+    assert gen._player_off_ratings["P2"].rating_value < 1000.0
 
 
 def test_future_transform_no_state_mutation(base_cn, sample_df):
@@ -170,7 +160,10 @@ def test_future_transform_no_state_mutation(base_cn, sample_df):
 def test_future_transform_cold_start_player(base_cn, sample_df):
     """Check that future_transform handles players not seen during fit_transform."""
     gen = PlayerRatingGenerator(
-        performance_column="perf", column_names=base_cn, auto_scale_performance=True
+        performance_column="perf",
+        column_names=base_cn,
+        auto_scale_performance=True,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
     )
     gen.fit_transform(sample_df)
 
@@ -187,12 +180,16 @@ def test_future_transform_cold_start_player(base_cn, sample_df):
     res = gen.future_transform(new_player_df)
 
     assert "P99" in res["pid"].to_list()
+    assert len(res) == 4
 
-    assert len(res) >= 2
+    p99_row = res.filter(pl.col("pid") == "P99")
+    assert p99_row["player_off_rating_perf"][0] == 1000.0
 
 
 def test_transform_is_identical_to_future_transform(base_cn, sample_df):
     """Verify that the standard transform() call redirects to future_transform logic."""
+    import polars.testing as pl_testing
+
     gen = PlayerRatingGenerator(
         performance_column="perf", column_names=base_cn, auto_scale_performance=True
     )
@@ -202,9 +199,10 @@ def test_transform_is_identical_to_future_transform(base_cn, sample_df):
     res_transform = gen.transform(sample_df)
     res_future = gen.future_transform(sample_df)
 
-    assert len(res_transform) == len(res_future)
-
-    assert set(res_transform.columns) == set(res_future.columns)
+    pl_testing.assert_frame_equal(
+        res_transform.select(sorted(res_transform.columns)).sort("pid"),
+        res_future.select(sorted(res_future.columns)).sort("pid"),
+    )
 
 
 def test_fit_transform_offense_defense_independence(base_cn):
@@ -406,9 +404,11 @@ def test_fit_transform_when_date_formats_vary_then_processes_successfully_player
 
     result = gen.fit_transform(df)
 
-    assert len(result) >= 2
+    assert len(result) == 4
 
-    assert len(gen._player_off_ratings) > 0
+    assert gen._player_off_ratings["P1"].rating_value > 1000.0
+    assert gen._player_off_ratings["P2"].rating_value < 1000.0
+    assert gen._player_off_ratings["P3"].rating_value > gen._player_off_ratings["P4"].rating_value
 
 
 @pytest.mark.parametrize(
@@ -710,17 +710,210 @@ def test_fit_transform_confidence_decay_over_time(base_cn):
 
 
 def test_fit_transform_null_performance_handling(base_cn, sample_df):
-    """Rows with null performance should be handled or skipped without crashing."""
+    """Rows with null performance should be handled without crashing and not affect ratings."""
     df_with_null = sample_df.with_columns(
         pl.when(pl.col("pid") == "P1").then(None).otherwise(pl.col("perf")).alias("perf")
     )
     gen = PlayerRatingGenerator(performance_column="perf", column_names=base_cn)
 
-    # Depending on implementation, it might skip P1 or treat as 0.
-    # The key is that the generator shouldn't crash.
     res = gen.fit_transform(df_with_null)
     assert len(res) == 4
 
+    assert gen._player_off_ratings["P2"].rating_value < 1000.0
+    assert gen._player_off_ratings["P3"].rating_value > 1000.0
+
+
+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 ---
 
@@ -1514,7 +1707,6 @@ def test_player_rating_features_out_combinations(
     )
     result = gen.fit_transform(sample_df)
 
-    # Check that all expected columns are present
     result_cols = (
         result.columns.tolist() if hasattr(result.columns, "tolist") else list(result.columns)
     )
@@ -1523,93 +1715,17 @@ def test_player_rating_features_out_combinations(
             col in result_cols
         ), f"Expected column '{col}' not found in output. Columns: {result_cols}"
 
-    # Check that result has data
-    assert len(result) > 0
+    assert len(result) == 4
 
-
-@pytest.mark.parametrize("output_suffix", [None, "v2", "custom_suffix", "test123"])
-def test_player_rating_suffix_applied_to_all_features(base_cn, sample_df, output_suffix):
-    """Test that output_suffix is correctly applied to all requested features."""
-    features = [
-        RatingKnownFeatures.PLAYER_OFF_RATING,
-        RatingKnownFeatures.PLAYER_DEF_RATING,
-        RatingKnownFeatures.TEAM_OFF_RATING_PROJECTED,
-    ]
-    non_predictor = [
-        RatingUnknownFeatures.PLAYER_PREDICTED_OFF_PERFORMANCE,
-        RatingUnknownFeatures.TEAM_RATING,
-    ]
-
-    gen = PlayerRatingGenerator(
-        performance_column="perf",
-        column_names=base_cn,
-        auto_scale_performance=True,
-        features_out=features,
-        non_predictor_features_out=non_predictor,
-        output_suffix=output_suffix,
-    )
-    result = gen.fit_transform(sample_df)
-
-    # Build expected column names
-    if output_suffix:
-        expected_cols = [
-            f"player_off_rating_{output_suffix}",
-            f"player_def_rating_{output_suffix}",
-            f"team_off_rating_projected_{output_suffix}",
-            f"player_predicted_off_performance_{output_suffix}",
-            f"team_rating_{output_suffix}",
-        ]
-    else:
-        # When output_suffix=None, it defaults to performance column name ("perf")
-        expected_cols = [
-            "player_off_rating_perf",
-            "player_def_rating_perf",
-            "team_off_rating_projected_perf",
-            "player_predicted_off_performance_perf",
-            "team_rating_perf",
-        ]
-
-    result_cols = (
-        result.columns.tolist() if hasattr(result.columns, "tolist") else list(result.columns)
-    )
     for col in expected_cols:
-        assert col in result_cols, f"Expected column '{col}' not found. Columns: {result_cols}"
-
-
-def test_player_rating_only_requested_features_present(base_cn, sample_df):
-    """Test that only requested features (and input columns) are present in output."""
-    gen = PlayerRatingGenerator(
-        performance_column="perf",
-        column_names=base_cn,
-        auto_scale_performance=True,
-        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
-        non_predictor_features_out=None,
-        output_suffix=None,
-    )
-    result = gen.fit_transform(sample_df)
-
-    # Should have input columns + requested feature
-    input_cols = set(sample_df.columns)
-    result_cols = set(result.columns)
-
-    # Check that input columns are preserved
-    for col in input_cols:
-        assert col in result_cols, f"Input column '{col}' missing from output"
-
-    # Check that requested feature is present (with performance column suffix)
-    assert "player_off_rating_perf" in result_cols
-
-    # Check that other rating features are NOT present (unless they're input columns)
-    unwanted_features = [
-        "player_def_rating",
-        "team_off_rating_projected",
-        "player_predicted_off_performance",
-    ]
-    for feature in unwanted_features:
-        if feature not in input_cols:
-            assert (
-                feature not in result_cols
-            ), f"Unrequested feature '{feature}' should not be in output"
+        if "rating" in col and "difference" not in col:
+            values = result[col].to_list()
+            for v in values:
+                assert 500 < v < 1500, f"Rating {col}={v} outside reasonable range"
+        elif "predicted" in col:
+            values = result[col].to_list()
+            for v in values:
+                assert 0.0 <= v <= 1.0, f"Prediction {col}={v} outside [0,1]"
 
 
 def test_player_rating_team_with_strong_offense_and_weak_defense_gets_expected_ratings_and_predictions(
@@ -1816,3 +1932,110 @@ def test_fit_transform__start_league_quantile_uses_existing_player_ratings(base_
         f"but got {new_player_start_rating:.1f}. "
         "start_league_quantile has no effect because update_players_to_leagues is never called."
     )
+
+
+def test_fit_transform__precise_rating_calculation(base_cn, sample_df):
+    """Verify precise rating calculations match expected formulas."""
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        auto_scale_performance=False,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+    )
+    gen.fit_transform(sample_df)
+
+    expected_mult = 50 * (17 / 14) * 0.9 + 5
+
+    assert gen._player_off_ratings["P1"].rating_value == pytest.approx(
+        1000 + 0.1 * expected_mult, rel=1e-6
+    )
+
+    assert gen._player_off_ratings["P2"].rating_value == pytest.approx(
+        1000 - 0.1 * expected_mult, rel=1e-6
+    )
+
+    assert gen._player_off_ratings["P3"].rating_value == pytest.approx(
+        1000 + 0.2 * expected_mult, rel=1e-6
+    )
+
+    assert gen._player_off_ratings["P4"].rating_value == pytest.approx(
+        1000 - 0.2 * expected_mult, rel=1e-6
+    )
+
+    assert gen._player_def_ratings["P1"].rating_value == pytest.approx(1000.0, rel=1e-6)
+
+
+def test_fit_transform_when_all_players_have_null_performance_then_no_rating_change(base_cn):
+    """
+    When ALL players on a team have null performance, opponent defense ratings should not change.
+
+    Scenario:
+    - Match 1: Normal match with performance values (P1=0.6 on T1, P2=0.4 on T2)
+    - Match 2: T1 has ALL null performance, T2 has normal performance (0.6)
+
+    Expected:
+    - T2 players' defensive rating should NOT change after M2 because T1's offensive
+      performance is unknown (all null) - we can't evaluate how well T2 defended
+    - T1 players' offensive rating should NOT change after M2 (null perf = no update)
+    """
+    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",
+                "2024-01-01",
+                "2024-01-01",
+                "2024-01-01",
+                "2024-01-02",
+                "2024-01-02",
+                "2024-01-02",
+                "2024-01-02",
+            ],
+            "perf": [0.6, 0.4, 0.6, 0.4, None, None, 0.6, 0.4],
+            "pw": [1.0, 1.0, 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,
+            RatingKnownFeatures.PLAYER_DEF_RATING,
+        ],
+    )
+    result = gen.fit_transform(df)
+
+    p3_def_before_m2 = result.filter((pl.col("pid") == "P3") & (pl.col("mid") == "M2"))[
+        "player_def_rating_perf"
+    ][0]
+    p4_def_before_m2 = result.filter((pl.col("pid") == "P4") & (pl.col("mid") == "M2"))[
+        "player_def_rating_perf"
+    ][0]
+
+    p3_def_after_m2 = gen._player_def_ratings["P3"].rating_value
+    p4_def_after_m2 = gen._player_def_ratings["P4"].rating_value
+
+    assert p3_def_before_m2 == p3_def_after_m2, (
+        f"P3's def rating changed after M2 with all-null T1 performance! "
+        f"Before={p3_def_before_m2}, After={p3_def_after_m2}. "
+        "T2 defense should not be evaluated when T1 offense is unknown."
+    )
+    assert p4_def_before_m2 == p4_def_after_m2, (
+        f"P4's def rating changed after M2 with all-null T1 performance! "
+        f"Before={p4_def_before_m2}, After={p4_def_after_m2}. "
+        "T2 defense should not be evaluated when T1 offense is unknown."
+    )
+
+    p1_off_before_m2 = result.filter((pl.col("pid") == "P1") & (pl.col("mid") == "M2"))[
+        "player_off_rating_perf"
+    ][0]
+    p1_off_after_m2 = gen._player_off_ratings["P1"].rating_value
+
+    assert p1_off_before_m2 == p1_off_after_m2, (
+        f"P1's off rating changed after M2 with null performance! "
+        f"Before={p1_off_before_m2}, After={p1_off_after_m2}. "
+        "Null performance should result in no rating change."
+    )

tests/ratings/test_team_rating_generator.py

@@ -835,6 +835,149 @@ def test_fit_transform_when_performance_out_of_range_then_error_is_raised(column
         generator.fit_transform(df)
 
 
+def test_fit_transform_when_performance_is_null_then_no_rating_change(column_names):
+    """
+    When performance is null, then we should expect to see no rating change
+    because null means missing data, not 0.0 (worst) performance.
+    The team's pre-match rating for the next game should equal their rating before the null game.
+    """
+    generator = TeamRatingGenerator(
+        performance_column="won",
+        column_names=column_names,
+        start_team_rating=1000.0,
+        confidence_weight=0.0,
+        output_suffix="",
+        features_out=[RatingKnownFeatures.TEAM_OFF_RATING_PROJECTED],
+    )
+
+    # Match 1: team_a perf=0.6, team_b perf=0.4
+    # Match 2: team_a has null performance, team_b perf=0.6
+    # Match 3: team_a perf=0.6, team_b perf=0.4
+    df = pl.DataFrame(
+        {
+            "match_id": [1, 1, 2, 2, 3, 3],
+            "team_id": ["team_a", "team_b", "team_a", "team_b", "team_a", "team_b"],
+            "start_date": [
+                datetime(2024, 1, 1),
+                datetime(2024, 1, 1),
+                datetime(2024, 1, 2),
+                datetime(2024, 1, 2),
+                datetime(2024, 1, 3),
+                datetime(2024, 1, 3),
+            ],
+            "won": [0.6, 0.4, None, 0.6, 0.6, 0.4],  # team_a has null in match 2
+        }
+    )
+
+    result = generator.fit_transform(df)
+
+    # Get team_a's pre-match rating for match 2 (after match 1) and match 3 (after match 2)
+    team_a_rating_before_m2 = result.filter(
+        (pl.col("team_id") == "team_a") & (pl.col("match_id") == 2)
+    )["team_off_rating_projected"][0]
+    team_a_rating_before_m3 = result.filter(
+        (pl.col("team_id") == "team_a") & (pl.col("match_id") == 3)
+    )["team_off_rating_projected"][0]
+
+    # Key assertion: rating before M3 should equal rating before M2
+    # because null performance in M2 means NO rating change
+    assert team_a_rating_before_m3 == team_a_rating_before_m2, (
+        f"team_a's rating changed after null performance game! "
+        f"Before M2={team_a_rating_before_m2}, Before M3={team_a_rating_before_m3}"
+    )
+
+    # Also verify null is not treated as 0.0 by comparing with explicit 0.0
+    # Use 0.3 instead of 0.0 to keep mean in valid range
+    df_with_low_perf = df.with_columns(
+        pl.when((pl.col("team_id") == "team_a") & (pl.col("match_id") == 2))
+        .then(0.3)  # Low performance (below predicted ~0.5) causes rating drop
+        .otherwise(pl.col("won"))
+        .alias("won")
+    )
+
+    gen_low = TeamRatingGenerator(
+        performance_column="won",
+        column_names=column_names,
+        start_team_rating=1000.0,
+        confidence_weight=0.0,
+        output_suffix="",
+        features_out=[RatingKnownFeatures.TEAM_OFF_RATING_PROJECTED],
+    )
+    result_low = gen_low.fit_transform(df_with_low_perf)
+
+    team_a_rating_before_m3_with_low = result_low.filter(
+        (pl.col("team_id") == "team_a") & (pl.col("match_id") == 3)
+    )["team_off_rating_projected"][0]
+
+    # With low perf (0.3), rating should drop (different from null which has no change)
+    assert team_a_rating_before_m3 > team_a_rating_before_m3_with_low, (
+        f"Null performance is being treated as low performance! "
+        f"Rating with null={team_a_rating_before_m3}, rating with low perf={team_a_rating_before_m3_with_low}"
+    )
+
+
+def test_transform_when_auto_scale_performance_then_uses_correct_column(column_names):
+    """
+    When auto_scale_performance=True, the performance manager renames the column
+    (e.g., 'won' -> 'performance__won'). Transform should still work by applying
+    the performance manager to transform the input data.
+
+    Bug: Currently transform doesn't apply the performance manager, causing
+    a column mismatch where it looks for 'performance__won' but data has 'won'.
+    This results in None being returned and defaulting to 0.0 performance.
+    """
+    generator = TeamRatingGenerator(
+        performance_column="won",
+        column_names=column_names,
+        start_team_rating=1000.0,
+        confidence_weight=0.0,
+        output_suffix="",
+        auto_scale_performance=True,
+    )
+
+    # fit_transform with valid performance values
+    fit_df = pl.DataFrame(
+        {
+            "match_id": [1, 1],
+            "team_id": ["team_a", "team_b"],
+            "start_date": [datetime(2024, 1, 1), datetime(2024, 1, 1)],
+            "won": [0.6, 0.4],
+        }
+    )
+    generator.fit_transform(fit_df)
+
+    # After fit_transform, performance_column is changed to 'performance__won'
+    assert generator.performance_column == "performance__won", (
+        f"Expected performance_column to be 'performance__won' but got '{generator.performance_column}'"
+    )
+
+    team_a_rating_before = generator._team_off_ratings["team_a"].rating_value
+
+    # transform with same format data (original column name 'won')
+    # team_a has good performance (0.6 > predicted ~0.5), so rating should INCREASE
+    transform_df = pl.DataFrame(
+        {
+            "match_id": [2, 2],
+            "team_id": ["team_a", "team_b"],
+            "start_date": [datetime(2024, 1, 2), datetime(2024, 1, 2)],
+            "won": [0.6, 0.4],  # Original column name, not 'performance__won'
+        }
+    )
+
+    generator.transform(transform_df)
+
+    team_a_rating_after = generator._team_off_ratings["team_a"].rating_value
+
+    # With 0.6 performance (above predicted ~0.5), rating should INCREASE
+    # Bug: column mismatch causes perf to default to 0.0, making rating DECREASE
+    assert team_a_rating_after > team_a_rating_before, (
+        f"Rating should increase with good performance (0.6), but it went from "
+        f"{team_a_rating_before} to {team_a_rating_after}. This indicates transform "
+        f"is not finding the performance column (looking for '{generator.performance_column}' "
+        f"but data has 'won') and defaulting to 0.0 performance."
+    )
+
+
 @pytest.mark.parametrize("confidence_weight", [0.0, 0.5, 1.0])
 def test_fit_transform_when_confidence_weight_varies_then_new_teams_have_different_rating_changes(
     column_names, confidence_weight
@@ -1283,12 +1426,11 @@ def test_transform_when_called_after_fit_transform_then_uses_updated_ratings(
     assert team_a_row["team_off_rating_projected"][0] == pytest.approx(team_a_rating_after_first)
 
 
-def test_transform_when_called_without_performance_column_then_defaults_to_zero(column_names):
+def test_transform_when_called_without_performance_column_then_no_rating_change(column_names):
     """
     When transform is called without performance column, then we should expect to see
-    it works but defaults performance to 0.0 because _calculate_ratings uses
-    r.get(self.performance_column) which returns None, defaulting to 0.0.
-    This means ratings will be updated as if teams lost (performance=0.0).
+    ratings remain unchanged because null/missing performance means no rating update
+    (not treated as 0.0 which would cause a rating drop).
     """
     generator = TeamRatingGenerator(
         performance_column="won",
@@ -1321,7 +1463,8 @@ def test_transform_when_called_without_performance_column_then_defaults_to_zero(
     generator.transform(df)
     team_a_rating_after = generator._team_off_ratings["team_a"].rating_value
 
-    assert team_a_rating_after < team_a_rating_before
+    # Null/missing performance means no rating change
+    assert team_a_rating_after == team_a_rating_before
 
 
 def test_future_transform_when_called_then_ratings_not_updated(basic_rating_generator):
@@ -1539,14 +1682,13 @@ def test_transform_vs_future_transform_when_same_match_then_transform_updates_ra
     assert team_a_rating_after_future == team_a_rating_before_2
 
 
-def test_transform_vs_future_transform_when_performance_column_missing_then_both_work_but_transform_defaults_performance(
+def test_transform_vs_future_transform_when_performance_column_missing_then_both_work_with_no_rating_change(
     column_names,
 ):
     """
     When performance column is missing, then we should expect to see
-    both future_transform and transform work, but transform defaults performance
-    to 0.0 (treating it as a loss), while future_transform doesn't need performance
-    at all since it only computes predictions.
+    both future_transform and transform work, and both result in no rating change
+    because null/missing performance means no update (not treated as 0.0).
     """
     generator = TeamRatingGenerator(
         performance_column="won",
@@ -1594,8 +1736,9 @@ def test_transform_vs_future_transform_when_performance_column_missing_then_both
     result_transform = generator.transform(transform_df)
     assert result_transform is not None
 
+    # Null/missing performance means no rating change
     team_a_rating_after_transform = generator._team_off_ratings["team_a"].rating_value
-    assert team_a_rating_after_transform < team_a_rating_before
+    assert team_a_rating_after_transform == team_a_rating_before
 
 
 def test_transform_vs_future_transform_when_games_played_then_transform_increments_but_future_transform_does_not(
@@ -1878,7 +2021,6 @@ def test_transform_when_date_formats_vary_then_processes_successfully(column_nam
         start_team_rating=1000.0,
         confidence_weight=0.0,
         output_suffix="",
-        auto_scale_performance=True,
     )
 
     fit_df = pl.DataFrame(