spforge 0.8.20__tar.gz → 0.8.25__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.20"
+version = "0.8.25"
 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.25}/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-0.8.20 → spforge-0.8.25}/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.25}/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)
@@ -433,9 +448,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
@@ -459,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,
                     ),
                 )
 
@@ -477,33 +503,39 @@ 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,
                     ),
                 )
 
                 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
@@ -542,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,
                     ),
                 )
 
@@ -560,43 +596,49 @@ 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,
                     ),
                 )
 
                 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(
                     (
@@ -870,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]
@@ -946,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:
@@ -1031,12 +1093,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 +1114,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
@@ -1181,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
@@ -1237,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
                     ),
                 )
 
@@ -1254,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
                     ),
                 )
 
@@ -1282,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
                     ),
                 )
 
@@ -1299,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-0.8.20 → spforge-0.8.25}/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.25}/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.20 → spforge-0.8.25/spforge.egg-info}/PKG-INFO

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