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

spforge/feature_generator/_base.py

@@ -176,6 +176,8 @@ class LagGenerator(FeatureGenerator):
         if additional_cols:
             cols.extend(additional_cols)
 
+        cols = list(dict.fromkeys(cols))
+
         if self._df is None:
             self._df = df.select(cols)
         else:

spforge/ratings/_player_rating.py

@@ -330,7 +330,21 @@ class PlayerRatingGenerator(RatingGenerator):
             df = df.drop(cols_to_drop)
         return df
 
+    def _validate_playing_time_columns(self, df: pl.DataFrame) -> None:
+        cn = self.column_names
+        if cn.team_players_playing_time and cn.team_players_playing_time not in df.columns:
+            raise ValueError(
+                f"team_players_playing_time column '{cn.team_players_playing_time}' "
+                f"not found in DataFrame. Available columns: {list(df.columns)}"
+            )
+        if cn.opponent_players_playing_time and cn.opponent_players_playing_time not in df.columns:
+            raise ValueError(
+                f"opponent_players_playing_time column '{cn.opponent_players_playing_time}' "
+                f"not found in DataFrame. Available columns: {list(df.columns)}"
+            )
+
     def _historical_transform(self, df: pl.DataFrame) -> pl.DataFrame:
+        self._validate_playing_time_columns(df)
         df = self._scale_participation_weight_columns(df)
         match_df = self._create_match_df(df)
         ratings = self._calculate_ratings(match_df)
@@ -359,6 +373,7 @@ class PlayerRatingGenerator(RatingGenerator):
         return self._remove_internal_scaled_columns(result)
 
     def _future_transform(self, df: pl.DataFrame) -> pl.DataFrame:
+        self._validate_playing_time_columns(df)
         df = self._scale_participation_weight_columns(df)
         match_df = self._create_match_df(df)
         ratings = self._calculate_future_ratings(match_df)
@@ -466,10 +481,14 @@ class PlayerRatingGenerator(RatingGenerator):
                 pred_off = self._performance_predictor.predict_performance(
                     player_rating=pre_player,
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=team2_def_rating
+                        id=team2,
+                        players=c2.pre_match_player_ratings,
+                        rating_value=team2_def_rating,
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=team1_off_rating
+                        id=team1,
+                        players=c1.pre_match_player_ratings,
+                        rating_value=team1_off_rating,
                     ),
                 )
 
@@ -484,10 +503,14 @@ class PlayerRatingGenerator(RatingGenerator):
                         other=getattr(pre_player, "other", None),
                     ),
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=team2_off_rating
+                        id=team2,
+                        players=c2.pre_match_player_ratings,
+                        rating_value=team2_off_rating,
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=team1_def_rating
+                        id=team1,
+                        players=c1.pre_match_player_ratings,
+                        rating_value=team1_def_rating,
                     ),
                 )
 
@@ -551,10 +574,14 @@ class PlayerRatingGenerator(RatingGenerator):
                 pred_off = self._performance_predictor.predict_performance(
                     player_rating=pre_player,
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=team1_def_rating
+                        id=team1,
+                        players=c1.pre_match_player_ratings,
+                        rating_value=team1_def_rating,
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=team2_off_rating
+                        id=team2,
+                        players=c2.pre_match_player_ratings,
+                        rating_value=team2_off_rating,
                     ),
                 )
 
@@ -569,10 +596,14 @@ class PlayerRatingGenerator(RatingGenerator):
                         other=getattr(pre_player, "other", None),
                     ),
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=team1_off_rating
+                        id=team1,
+                        players=c1.pre_match_player_ratings,
+                        rating_value=team1_off_rating,
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=team2_def_rating
+                        id=team2,
+                        players=c2.pre_match_player_ratings,
+                        rating_value=team2_def_rating,
                     ),
                 )
 
@@ -881,6 +912,12 @@ class PlayerRatingGenerator(RatingGenerator):
         if cn.league and cn.league in df.columns:
             player_stat_cols.append(cn.league)
 
+        if cn.team_players_playing_time and cn.team_players_playing_time in df.columns:
+            player_stat_cols.append(cn.team_players_playing_time)
+
+        if cn.opponent_players_playing_time and cn.opponent_players_playing_time in df.columns:
+            player_stat_cols.append(cn.opponent_players_playing_time)
+
         df = df.with_columns(pl.struct(player_stat_cols).alias(PLAYER_STATS))
 
         group_cols = [cn.match_id, cn.team_id, cn.start_date]
@@ -957,10 +994,24 @@ class PlayerRatingGenerator(RatingGenerator):
                 else None
             )
 
+            team_playing_time = None
+            opponent_playing_time = None
+            if cn.team_players_playing_time:
+                raw_value = team_player.get(cn.team_players_playing_time)
+                if raw_value is not None:
+                    team_playing_time = raw_value
+
+            if cn.opponent_players_playing_time:
+                raw_value = team_player.get(cn.opponent_players_playing_time)
+                if raw_value is not None:
+                    opponent_playing_time = raw_value
+
             mp = MatchPerformance(
                 performance_value=perf_val,
                 projected_participation_weight=projected_participation_weight,
                 participation_weight=participation_weight,
+                team_players_playing_time=team_playing_time,
+                opponent_players_playing_time=opponent_playing_time,
             )
 
             if player_id in self._player_off_ratings and player_id in self._player_def_ratings:
@@ -1194,10 +1245,23 @@ class PlayerRatingGenerator(RatingGenerator):
                         ppw = pw
                     proj_w.append(float(ppw))
 
+                    team_playing_time = None
+                    opponent_playing_time = None
+                    if cn.team_players_playing_time:
+                        raw_value = tp.get(cn.team_players_playing_time)
+                        if raw_value is not None:
+                            team_playing_time = raw_value
+                    if cn.opponent_players_playing_time:
+                        raw_value = tp.get(cn.opponent_players_playing_time)
+                        if raw_value is not None:
+                            opponent_playing_time = raw_value
+
                     mp = MatchPerformance(
                         performance_value=get_perf_value(tp),
                         projected_participation_weight=ppw,
                         participation_weight=pw,
+                        team_players_playing_time=team_playing_time,
+                        opponent_players_playing_time=opponent_playing_time,
                     )
 
                     ensure_new_player(pid, day_number, mp, league, position, pre_list)  # noqa: B023
@@ -1250,10 +1314,10 @@ class PlayerRatingGenerator(RatingGenerator):
                 pred_off = self._performance_predictor.predict_performance(
                     player_rating=pre,
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=t2_def_rating
+                        id=team2, players=t2_pre, rating_value=t2_def_rating
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=t1_off_rating
+                        id=team1, players=t1_pre, rating_value=t1_off_rating
                     ),
                 )
 
@@ -1267,10 +1331,10 @@ class PlayerRatingGenerator(RatingGenerator):
                         position=pre.position,
                     ),
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=t2_off_rating
+                        id=team2, players=t2_pre, rating_value=t2_off_rating
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=t1_def_rating
+                        id=team1, players=t1_pre, rating_value=t1_def_rating
                     ),
                 )
 
@@ -1295,10 +1359,10 @@ class PlayerRatingGenerator(RatingGenerator):
                 pred_off = self._performance_predictor.predict_performance(
                     player_rating=pre,
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=t1_def_rating
+                        id=team1, players=t1_pre, rating_value=t1_def_rating
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=t2_off_rating
+                        id=team2, players=t2_pre, rating_value=t2_off_rating
                     ),
                 )
 
@@ -1312,10 +1376,10 @@ class PlayerRatingGenerator(RatingGenerator):
                         position=pre.position,
                     ),
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=t1_off_rating
+                        id=team1, players=t1_pre, rating_value=t1_off_rating
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=t2_def_rating
+                        id=team2, players=t2_pre, rating_value=t2_def_rating
                     ),
                 )
 

spforge/ratings/player_performance_predictor.py

@@ -133,7 +133,7 @@ class RatingPlayerDifferencePerformancePredictor(PlayerPerformancePredictor):
             team_rating_value = team_rating.rating_value
 
         if player_rating.match_performance.opponent_players_playing_time and isinstance(
-            player_rating.match_performance.team_players_playing_time, dict
+            player_rating.match_performance.opponent_players_playing_time, dict
         ):
             weight_opp_rating = 0
             sum_playing_time = 0

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

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

@@ -34,7 +34,7 @@ spforge/estimator/_group_by_estimator.py,sha256=o-xv_PJJyWBaKv5Eo4EPbOvb9i0CuebZ
 spforge/estimator/_ordinal_classifier.py,sha256=j_dfVHeX-6eZgPwwsYbkbP6bPrKH2a5S-N8vfP5hneA,1993
 spforge/estimator/_sklearn_enhancer_estimator.py,sha256=DZ-UlmeazXPd6uEnlbVv79syZ5FPa64voUyKArtjjUs,4664
 spforge/feature_generator/__init__.py,sha256=wfLfUkC_lLOCpy7NgDytK-l3HUAuhikuQXdKCgSGbuA,556
-spforge/feature_generator/_base.py,sha256=8_RtsnMvc1JOwAeUmnA-WP_Za3HvlBU4jZkg0yI0M-8,16299
+spforge/feature_generator/_base.py,sha256=eL0P4RRqSFaekko_RxtHKs5UXSCxdR3CG57Yvo7ryBo,16341
 spforge/feature_generator/_lag.py,sha256=Qe34y_iQ90GKlIDfXiYahRobAZB8J-BE1MCrfSPuCSY,6821
 spforge/feature_generator/_net_over_predicted.py,sha256=nngVzgLLxgOj8d9avSJCXaC_jNVOl33pWpQJB9RAKTU,2092
 spforge/feature_generator/_regressor_feature_generator.py,sha256=CM8fPbbX5A_wgT5AT0zbs3YBgsZIVKE74C9vS6V6Q4U,5043
@@ -51,12 +51,12 @@ spforge/performance_transformers/_performance_manager.py,sha256=WmjmlMEnq7y75MiI
 spforge/performance_transformers/_performances_transformers.py,sha256=0lxuWjAfWBRXRgQsNJHjw3P-nlTtHBu4_bOVdoy7hq4,15536
 spforge/ratings/__init__.py,sha256=OZVH2Lo6END3n1X8qi4QcyAPlThIwAYwVKCiIuOQSQU,576
 spforge/ratings/_base.py,sha256=ne4BRrYFPqMirdFPVnyDN44wjFQwOQgWoUXu_59xgWE,14687
-spforge/ratings/_player_rating.py,sha256=zhTI6isbNXYy9xAyMt_6nlOktsk6TukDVWV7vS7G4qg,57190
+spforge/ratings/_player_rating.py,sha256=zltf4utwzKQxkTA8DAPZ4LWRDlwGxoiKFaiPIo4sdNw,60323
 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
-spforge/ratings/player_performance_predictor.py,sha256=cMxzQuk0nF1MsT_M32g-3mxVdAEbZ-S7TUjEPYdo3Yg,8361
+spforge/ratings/player_performance_predictor.py,sha256=UPzOEbougHT6FcmOiuTa3vEM6q8FZq-SjKb0AqD0JS4,8365
 spforge/ratings/start_rating_generator.py,sha256=eSasa5Oe9n4IoTGjFCYyFQAGrJtzrBW-Qor97lmaYuM,6776
 spforge/ratings/team_performance_predictor.py,sha256=ThQOmYQUqKBB46ONYHOMM2arXFH8AkyKpAZzs80SjHA,7217
 spforge/ratings/team_start_rating_generator.py,sha256=vK-_m8KwcHopchch_lKNHSGLiiNm5q9Lenm0d1cP_po,5110
@@ -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.23.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.25.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
@@ -89,12 +89,12 @@ tests/feature_generator/test_regressor_feature_generator.py,sha256=3Wfw1NbD11p2N
 tests/feature_generator/test_rolling_against_opponent.py,sha256=20kH1INrWy6DV7ASx8xVKuovDoHwK7L0-lAnzv1YQMs,5667
 tests/feature_generator/test_rolling_mean_binary.py,sha256=KuIavJ37Pt8icAb50B23lxdWEPVSHQ7NZHisD1BDpmU,16216
 tests/feature_generator/test_rolling_mean_days.py,sha256=EyOvdJDnmgPfe13uQBOkwo7fAteBQx-tnyuGM4ng2T8,18884
-tests/feature_generator/test_rolling_window.py,sha256=YBJo36OK3ILYeXrH06ylXqviUcCaGYaVQaK5RJzwM7Y,23239
+tests/feature_generator/test_rolling_window.py,sha256=_o9oljcAIZ14iI7e8WFeAsfXxILnyqBffit21HOvII4,24378
 tests/hyperparameter_tuning/test_estimator_tuner.py,sha256=iewME41d6LR2aQ0OtohGFtN_ocJUwTeqvs6L0QDmfG4,4413
 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=51iWgQRBHbb2-IPeajpej9ncGDWI1eUYdWrLXaKd9Ig,72232
+tests/ratings/test_player_rating_generator.py,sha256=Z66LN1-YdUHrS6dszWZf4HeENRyH8oEtu4Nlsh1MpMI,82442
 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=SqQcfckNmJJc99feCdnmkNYDape-p69e92Dp8Vzpu2w,101156
@@ -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.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,,
+spforge-0.8.25.dist-info/METADATA,sha256=JwBRy1-fD-a4UzeS_DeCv9AoXfbvbI7DghMls363RQ4,20048
+spforge-0.8.25.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+spforge-0.8.25.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
+spforge-0.8.25.dist-info/RECORD,,

tests/feature_generator/test_rolling_window.py

@@ -684,3 +684,39 @@ def test_rolling_mean_historical_transform_higher_granularity(column_names, use_
         }
     )
     pd.testing.assert_frame_equal(transformed_df, expected_df, check_like=True, check_dtype=False)
+
+
+@pytest.mark.parametrize("df", [pd.DataFrame, pl.DataFrame])
+def test_rolling_window__feature_also_used_as_column_names_field(df):
+    column_names = ColumnNames(
+        match_id="game_id",
+        player_id="player_id",
+        team_id="team_id",
+        start_date="game_date",
+        participation_weight="three_pointers_attempted",
+    )
+    data = df(
+        {
+            "game_id": [1, 1, 2, 2],
+            "player_id": ["a", "b", "a", "b"],
+            "team_id": [1, 2, 1, 2],
+            "game_date": [
+                pd.to_datetime("2023-01-01"),
+                pd.to_datetime("2023-01-01"),
+                pd.to_datetime("2023-01-02"),
+                pd.to_datetime("2023-01-02"),
+            ],
+            "three_pointers_attempted": [5.0, 3.0, 7.0, 4.0],
+        }
+    )
+
+    transformer = RollingWindowTransformer(
+        features=["three_pointers_attempted"],
+        window=20,
+        granularity=["player_id"],
+    )
+
+    transformed_df = transformer.fit_transform(data, column_names=column_names)
+
+    assert transformer.features_out[0] in transformed_df.columns
+    assert len(transformed_df) == len(data)

tests/ratings/test_player_rating_generator.py

@@ -2039,3 +2039,283 @@ def test_fit_transform_when_all_players_have_null_performance_then_no_rating_cha
         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