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

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,390 @@ 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."
+    )
+
+
+# --- team_players_playing_time Tests ---
+
+
+def test_fit_transform_team_players_playing_time_column_not_found_raises_error(base_cn):
+    """Specifying a nonexistent team_players_playing_time column should raise ValueError."""
+    from dataclasses import replace
+
+    cn = replace(base_cn, team_players_playing_time="nonexistent_column")
+
+    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=cn,
+    )
+
+    with pytest.raises(ValueError, match="team_players_playing_time column"):
+        gen.fit_transform(df)
+
+
+def test_fit_transform_opponent_players_playing_time_column_not_found_raises_error(base_cn):
+    """Specifying a nonexistent opponent_players_playing_time column should raise ValueError."""
+    from dataclasses import replace
+
+    cn = replace(base_cn, opponent_players_playing_time="nonexistent_column")
+
+    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=cn,
+    )
+
+    with pytest.raises(ValueError, match="opponent_players_playing_time column"):
+        gen.fit_transform(df)
+
+
+def test_fit_transform_null_playing_time_uses_standard_team_rating(base_cn):
+    """When team_players_playing_time is null for a row, should use standard team rating."""
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        team_players_playing_time="team_pt",
+        opponent_players_playing_time="opp_pt",
+    )
+
+    # First establish ratings with a normal match (no playing time data)
+    df1 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.8, 0.6, 0.4, 0.2],
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            "team_pt": [None, None, None, None],
+            "opp_pt": [None, None, None, None],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+        non_predictor_features_out=[RatingUnknownFeatures.PLAYER_PREDICTED_OFF_PERFORMANCE],
+    )
+
+    result = gen.fit_transform(df1)
+
+    # Should work without error and produce predictions
+    assert len(result) == 4
+    assert "player_predicted_off_performance_perf" in result.columns
+
+    # All predictions should be valid (between 0 and 1)
+    predictions = result["player_predicted_off_performance_perf"].to_list()
+    for pred in predictions:
+        assert 0.0 <= pred <= 1.0
+
+
+def test_fit_transform_weighted_calculation_with_playing_time(base_cn):
+    """Test that playing time weighted calculation produces different predictions."""
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        team_players_playing_time="team_pt",
+        opponent_players_playing_time="opp_pt",
+    )
+
+    # First establish different ratings for players
+    df1 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.9, 0.1, 0.5, 0.5],  # P1 high rating, P2 low rating
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            "team_pt": [None, None, None, None],
+            "opp_pt": [None, None, None, None],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        start_harcoded_start_rating=1000.0,
+        non_predictor_features_out=[RatingUnknownFeatures.PLAYER_PREDICTED_OFF_PERFORMANCE],
+    )
+    gen.fit_transform(df1)
+
+    # Verify P1 and P2 have different ratings now
+    p1_rating = gen._player_off_ratings["P1"].rating_value
+    p2_rating = gen._player_off_ratings["P2"].rating_value
+    assert p1_rating > p2_rating, "Setup: P1 should have higher rating than P2"
+
+    # Second match with playing time data
+    # P3 faces opponent P1 80% of time (high rating), P4 faces P2 80% of time (low rating)
+    # Use consistent schema for all dict entries (all keys present in all rows)
+    df2 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M2", "M2", "M2", "M2"],
+            "dt": ["2024-01-02"] * 4,
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            # Team playing time - who they play WITH on same team
+            "team_pt": [
+                {"P1": 0.0, "P2": 1.0, "P3": 0.5, "P4": 0.5},  # P1 on T1, plays with P2
+                {"P1": 1.0, "P2": 0.0, "P3": 0.5, "P4": 0.5},  # P2 on T1, plays with P1
+                {"P1": 0.5, "P2": 0.5, "P3": 0.0, "P4": 1.0},  # P3 on T2, plays with P4
+                {"P1": 0.5, "P2": 0.5, "P3": 1.0, "P4": 0.0},  # P4 on T2, plays with P3
+            ],
+            # Opponent playing time - who they face on opposing team
+            "opp_pt": [
+                {"P1": 0.0, "P2": 0.0, "P3": 0.5, "P4": 0.5},  # P1 faces T2 opponents evenly
+                {"P1": 0.0, "P2": 0.0, "P3": 0.5, "P4": 0.5},  # P2 faces T2 opponents evenly
+                {"P1": 0.8, "P2": 0.2, "P3": 0.0, "P4": 0.0},  # P3 faces P1 80% of time
+                {"P1": 0.2, "P2": 0.8, "P3": 0.0, "P4": 0.0},  # P4 faces P2 80% of time
+            ],
+        }
+    )
+
+    result = gen.future_transform(df2)
+
+    # Verify we get predictions
+    assert len(result) == 4
+
+    # Get predictions for P3 and P4
+    # P3 faces stronger opponents (mainly P1), P4 faces weaker opponents (mainly P2)
+    # So P3 should have lower predicted performance than P4 (all else equal)
+    p3_pred = result.filter(pl.col("pid") == "P3")["player_predicted_off_performance_perf"][0]
+    p4_pred = result.filter(pl.col("pid") == "P4")["player_predicted_off_performance_perf"][0]
+
+    # P3 faces P1 (high rating) 80% of time, P4 faces P2 (low rating) 80% of time
+    # So P4 should have higher predicted performance
+    assert p4_pred > p3_pred, (
+        f"P4 (facing weak opponents) should have higher prediction than P3 (facing strong opponents). "
+        f"P3 pred={p3_pred:.4f}, P4 pred={p4_pred:.4f}"
+    )
+
+
+def test_future_transform_weighted_calculation_with_playing_time(base_cn):
+    """Test that future_transform correctly uses playing time weights."""
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        team_players_playing_time="team_pt",
+        opponent_players_playing_time="opp_pt",
+    )
+
+    # First establish ratings
+    df1 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.9, 0.1, 0.5, 0.5],
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            "team_pt": [None, None, None, None],
+            "opp_pt": [None, None, None, None],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        start_harcoded_start_rating=1000.0,
+        non_predictor_features_out=[RatingUnknownFeatures.PLAYER_PREDICTED_OFF_PERFORMANCE],
+    )
+    gen.fit_transform(df1)
+
+    # Future match with playing time weights (consistent schema)
+    future_df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M2", "M2", "M2", "M2"],
+            "dt": ["2024-01-02"] * 4,
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            "team_pt": [
+                {"P1": 0.0, "P2": 1.0, "P3": 0.5, "P4": 0.5},  # P1 plays with P2
+                {"P1": 1.0, "P2": 0.0, "P3": 0.5, "P4": 0.5},  # P2 plays with P1
+                {"P1": 0.5, "P2": 0.5, "P3": 0.0, "P4": 1.0},  # P3 plays with P4
+                {"P1": 0.5, "P2": 0.5, "P3": 1.0, "P4": 0.0},  # P4 plays with P3
+            ],
+            "opp_pt": [
+                {"P1": 0.0, "P2": 0.0, "P3": 1.0, "P4": 0.0},  # P1 faces only P3
+                {"P1": 0.0, "P2": 0.0, "P3": 0.0, "P4": 1.0},  # P2 faces only P4
+                {"P1": 1.0, "P2": 0.0, "P3": 0.0, "P4": 0.0},  # P3 faces only P1
+                {"P1": 0.0, "P2": 1.0, "P3": 0.0, "P4": 0.0},  # P4 faces only P2
+            ],
+        }
+    )
+
+    result = gen.future_transform(future_df)
+
+    # Verify predictions are valid
+    assert len(result) == 4
+    predictions = result["player_predicted_off_performance_perf"].to_list()
+    for pred in predictions:
+        assert 0.0 <= pred <= 1.0
+
+
+def test_fit_transform_backward_compatible_without_playing_time_columns(base_cn):
+    """Behavior should be unchanged when team_players_playing_time columns are not specified."""
+    df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.6, 0.4, 0.7, 0.3],
+            "pw": [1.0, 1.0, 1.0, 1.0],
+        }
+    )
+
+    # Without specifying playing time columns (backward compatible)
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,  # No playing time columns specified
+        auto_scale_performance=True,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+    )
+
+    result = gen.fit_transform(df)
+
+    # Should work normally
+    assert len(result) == 4
+    assert "player_off_rating_perf" in result.columns
+
+    # Ratings should be updated normally
+    assert gen._player_off_ratings["P1"].rating_value != 1000.0
+    assert gen._player_off_ratings["P3"].rating_value > gen._player_off_ratings["P4"].rating_value