spforge 0.8.19__tar.gz → 0.8.23__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.19
+Version: 0.8.23
 Summary: A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data.
 Author-email: Mathias Holmstrøm <mathiasholmstom@gmail.com>
 License: See LICENSE file

{spforge-0.8.19 → spforge-0.8.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.19"
+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.19 → 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.19 → 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
@@ -484,26 +491,33 @@ class PlayerRatingGenerator(RatingGenerator):
                     ),
                 )
 
-                off_perf = float(pre_player.match_performance.performance_value)
-                def_perf = float(team1_def_perf)  # same for all players on team1 (derived)
+                perf_value = pre_player.match_performance.performance_value
+                if perf_value is None:
+                    off_change = 0.0
+                else:
+                    off_perf = float(perf_value)
+                    mult_off = self._applied_multiplier_off(off_state)
+                    off_change = (
+                        (off_perf - float(pred_off))
+                        * mult_off
+                        * float(pre_player.match_performance.participation_weight)
+                    )
 
-                if not self.use_off_def_split:
-                    pred_def = pred_off
-                    def_perf = off_perf
+                if perf_value is None or team1_def_perf is None:
+                    def_change = 0.0
+                else:
+                    def_perf = float(team1_def_perf)
 
-                mult_off = self._applied_multiplier_off(off_state)
-                mult_def = self._applied_multiplier_def(def_state)
+                    if not self.use_off_def_split:
+                        pred_def = pred_off
+                        def_perf = float(perf_value)
 
-                off_change = (
-                    (off_perf - float(pred_off))
-                    * mult_off
-                    * float(pre_player.match_performance.participation_weight)
-                )
-                def_change = (
-                    (def_perf - float(pred_def))
-                    * mult_def
-                    * float(pre_player.match_performance.participation_weight)
-                )
+                    mult_def = self._applied_multiplier_def(def_state)
+                    def_change = (
+                        (def_perf - float(pred_def))
+                        * mult_def
+                        * float(pre_player.match_performance.participation_weight)
+                    )
 
                 if math.isnan(off_change) or math.isnan(def_change):
                     raise ValueError(
@@ -562,26 +576,33 @@ class PlayerRatingGenerator(RatingGenerator):
                     ),
                 )
 
-                off_perf = float(pre_player.match_performance.performance_value)
-                def_perf = float(team2_def_perf)
+                perf_value = pre_player.match_performance.performance_value
+                if perf_value is None:
+                    off_change = 0.0
+                else:
+                    off_perf = float(perf_value)
+                    mult_off = self._applied_multiplier_off(off_state)
+                    off_change = (
+                        (off_perf - float(pred_off))
+                        * mult_off
+                        * float(pre_player.match_performance.participation_weight)
+                    )
 
-                if not self.use_off_def_split:
-                    pred_def = pred_off
-                    def_perf = off_perf
+                if perf_value is None or team2_def_perf is None:
+                    def_change = 0.0
+                else:
+                    def_perf = float(team2_def_perf)
 
-                mult_off = self._applied_multiplier_off(off_state)
-                mult_def = self._applied_multiplier_def(def_state)
+                    if not self.use_off_def_split:
+                        pred_def = pred_off
+                        def_perf = float(perf_value)
 
-                off_change = (
-                    (off_perf - float(pred_off))
-                    * mult_off
-                    * float(pre_player.match_performance.participation_weight)
-                )
-                def_change = (
-                    (def_perf - float(pred_def))
-                    * mult_def
-                    * float(pre_player.match_performance.participation_weight)
-                )
+                    mult_def = self._applied_multiplier_def(def_state)
+                    def_change = (
+                        (def_perf - float(pred_def))
+                        * mult_def
+                        * float(pre_player.match_performance.participation_weight)
+                    )
 
                 if math.isnan(off_change) or math.isnan(def_change):
                     raise ValueError(
@@ -933,7 +954,7 @@ class PlayerRatingGenerator(RatingGenerator):
                     self.performance_column in team_player
                     and team_player[self.performance_column] is not None
                 )
-                else 0.0
+                else None
             )
 
             mp = MatchPerformance(
@@ -1021,22 +1042,28 @@ class PlayerRatingGenerator(RatingGenerator):
 
         return pre_match_player_ratings, pre_match_player_off_values
 
-    def _team_off_perf_from_collection(self, c: PreMatchPlayersCollection) -> float:
+    def _team_off_perf_from_collection(
+        self, c: PreMatchPlayersCollection
+    ) -> float | None:
         # observed offense perf = weighted mean of player performance_value using participation_weight if present
+        # skip players with null performance
         cn = self.column_names
         if not c.pre_match_player_ratings:
-            return 0.0
+            return None
         wsum = 0.0
         psum = 0.0
         for pre in c.pre_match_player_ratings:
+            perf_val = pre.match_performance.performance_value
+            if perf_val is None:
+                continue
             w = (
                 float(pre.match_performance.participation_weight)
                 if cn.participation_weight
                 else 1.0
             )
-            psum += float(pre.match_performance.performance_value) * w
+            psum += float(perf_val) * w
             wsum += w
-        return psum / wsum if wsum else 0.0
+        return psum / wsum if wsum else None
 
     def _team_off_def_rating_from_collection(
         self, c: PreMatchPlayersCollection
@@ -1101,13 +1128,13 @@ class PlayerRatingGenerator(RatingGenerator):
             self.PLAYER_PRED_PERF_COL: [],
         }
 
-        def get_perf_value(team_player: dict) -> float:
+        def get_perf_value(team_player: dict) -> float | None:
             if (
                 self.performance_column in team_player
                 and team_player[self.performance_column] is not None
             ):
                 return float(team_player[self.performance_column])
-            return 0.0
+            return None
 
         def ensure_new_player(
             pid: str,
@@ -1187,8 +1214,9 @@ class PlayerRatingGenerator(RatingGenerator):
                     )
                     off_vals.append(float(local_off[pid].rating_value))
 
-                    psum += float(mp.performance_value) * float(pw)
-                    wsum += float(pw)
+                    if mp.performance_value is not None:
+                        psum += float(mp.performance_value) * float(pw)
+                        wsum += float(pw)
 
                 team_off_perf = psum / wsum if wsum else 0.0
                 return pre_list, player_ids, off_vals, proj_w, team_off_perf

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.19
+Version: 0.8.23
 Summary: A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data.
 Author-email: Mathias Holmstrøm <mathiasholmstom@gmail.com>
 License: See LICENSE file