spforge 0.8.20__tar.gz → 0.8.23__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.20"
+version = "0.8.23"
 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.20 → spforge-0.8.23}/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-0.8.20 → spforge-0.8.23}/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
@@ -487,23 +494,25 @@ class PlayerRatingGenerator(RatingGenerator):
                 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)
                     )
+
+                if perf_value is None or team1_def_perf is None:
+                    def_change = 0.0
+                else:
+                    def_perf = float(team1_def_perf)
+
+                    if not self.use_off_def_split:
+                        pred_def = pred_off
+                        def_perf = float(perf_value)
+
+                    mult_def = self._applied_multiplier_def(def_state)
                     def_change = (
                         (def_perf - float(pred_def))
                         * mult_def
@@ -570,33 +579,35 @@ class PlayerRatingGenerator(RatingGenerator):
                 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)
                     )
+
+                if perf_value is None or team2_def_perf is None:
+                    def_change = 0.0
+                else:
+                    def_perf = float(team2_def_perf)
+
+                    if not self.use_off_def_split:
+                        pred_def = pred_off
+                        def_perf = float(perf_value)
+
+                    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(
-                            f"NaN player rating change for player_id={pid}, match_id={r[cn.match_id]}"
-                        )
+                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(
                     (
@@ -1031,12 +1042,14 @@ 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:
@@ -1050,7 +1063,7 @@ class PlayerRatingGenerator(RatingGenerator):
             )
             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

{spforge-0.8.20 → spforge-0.8.23}/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.20 → spforge-0.8.23/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.20
+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.20 → spforge-0.8.23}/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,18 @@ 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."""
@@ -1706,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)
     )
@@ -1715,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
-
-
-@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",
-        ]
+    assert len(result) == 4
 
-    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(
@@ -2008,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."
+    )

{spforge-0.8.20 → spforge-0.8.23}/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(