spforge 0.8.35__tar.gz → 0.8.36__tar.gz

{spforge-0.8.35/spforge.egg-info → spforge-0.8.36}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.35"
+version = "0.8.36"
 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.35 → spforge-0.8.36}/spforge/ratings/_base.py

@@ -156,17 +156,20 @@ class RatingGenerator(FeatureGenerator):
                 )
 
         perf = df[self.performance_column]
-        if perf.max() > 1.02 or perf.min() < -0.02:
-            raise ValueError(
-                f"Max {self.performance_column} must be less than than 1.02 and min value larger than -0.02. "
-                "Either transform it manually or set auto_scale_performance to True"
-            )
+        # Filter to finite values for validation (NaN/inf are treated as missing data)
+        finite_perf = perf.filter(perf.is_finite())
+        if len(finite_perf) > 0:
+            if finite_perf.max() > 1.02 or finite_perf.min() < -0.02:
+                raise ValueError(
+                    f"Max {self.performance_column} must be less than than 1.02 and min value larger than -0.02. "
+                    "Either transform it manually or set auto_scale_performance to True"
+                )
 
-        if perf.mean() < 0.42 or perf.mean() > 0.58:
-            raise ValueError(
-                f"Mean {self.performance_column} must be between 0.42 and 0.58. "
-                "Either transform it manually or set auto_scale_performance to True"
-            )
+            if finite_perf.mean() < 0.42 or finite_perf.mean() > 0.58:
+                raise ValueError(
+                    f"Mean {self.performance_column} must be between 0.42 and 0.58. "
+                    "Either transform it manually or set auto_scale_performance to True"
+                )
 
         pl_df: pl.DataFrame
         pl_df = df.to_native() if df.implementation.is_polars() else df.to_polars().to_native()

{spforge-0.8.35 → spforge-0.8.36}/spforge/ratings/_player_rating.py

@@ -587,8 +587,9 @@ class PlayerRatingGenerator(RatingGenerator):
                 )
 
                 perf_value = pre_player.match_performance.performance_value
+                perf_is_valid = perf_value is not None and math.isfinite(float(perf_value))
 
-                if perf_value is None:
+                if not perf_is_valid:
                     off_change = 0.0
                 else:
                     off_perf = float(perf_value)
@@ -599,7 +600,7 @@ class PlayerRatingGenerator(RatingGenerator):
                         * float(pre_player.match_performance.participation_weight)
                     )
 
-                if team1_def_perf is None or (not self.use_off_def_split and perf_value is None):
+                if team1_def_perf is None or (not self.use_off_def_split and not perf_is_valid):
                     def_change = 0.0
                 else:
                     def_perf = float(team1_def_perf)
@@ -681,8 +682,9 @@ class PlayerRatingGenerator(RatingGenerator):
                 )
 
                 perf_value = pre_player.match_performance.performance_value
+                perf_is_valid = perf_value is not None and math.isfinite(float(perf_value))
 
-                if perf_value is None:
+                if not perf_is_valid:
                     off_change = 0.0
                 else:
                     off_perf = float(perf_value)
@@ -693,7 +695,7 @@ class PlayerRatingGenerator(RatingGenerator):
                         * float(pre_player.match_performance.participation_weight)
                     )
 
-                if team2_def_perf is None or (not self.use_off_def_split and perf_value is None):
+                if team2_def_perf is None or (not self.use_off_def_split and not perf_is_valid):
                     def_change = 0.0
                 else:
                     def_perf = float(team2_def_perf)
@@ -1254,7 +1256,7 @@ class PlayerRatingGenerator(RatingGenerator):
         self, c: PreMatchPlayersCollection
     ) -> float | None:
         # observed offense perf = weighted mean of player performance_value using participation_weight if present
-        # skip players with null performance
+        # skip players with null/non-finite performance
         cn = self.column_names
         if not c.pre_match_player_ratings:
             return None
@@ -1264,12 +1266,15 @@ class PlayerRatingGenerator(RatingGenerator):
             perf_val = pre.match_performance.performance_value
             if perf_val is None:
                 continue
+            perf_float = float(perf_val)
+            if not math.isfinite(perf_float):
+                continue
             w = (
                 float(pre.match_performance.participation_weight)
                 if cn.participation_weight
                 else 1.0
             )
-            psum += float(perf_val) * w
+            psum += perf_float * w
             wsum += w
         return psum / wsum if wsum else None
 
@@ -1341,7 +1346,9 @@ class PlayerRatingGenerator(RatingGenerator):
                 self.performance_column in team_player
                 and team_player[self.performance_column] is not None
             ):
-                return float(team_player[self.performance_column])
+                val = float(team_player[self.performance_column])
+                if math.isfinite(val):
+                    return val
             return None
 
         def ensure_new_player(

{spforge-0.8.35 → spforge-0.8.36/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.35
+Version: 0.8.36
 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.35 → spforge-0.8.36}/tests/ratings/test_player_rating_generator.py

@@ -2938,3 +2938,141 @@ def test_player_opponent_mean_projected_feature(base_cn, sample_df):
         (pl.col("player_opponent_mean_projected_perf") - expected).abs().max()
     ).item()
     assert diff < 1e-6, f"Max difference from expected mean: {diff}"
+
+
+class TestNaNPerformanceHandling:
+    """Tests that PlayerRatingGenerator handles NaN performance values correctly."""
+
+    @pytest.fixture
+    def nan_cn(self):
+        return ColumnNames(
+            player_id="player_id",
+            team_id="team_id",
+            match_id="match_id",
+            start_date="start_date",
+            participation_weight="participation_weight",
+        )
+
+    def _create_test_df(self, performance_values: list) -> pl.DataFrame:
+        """Create minimal test DataFrame with 2 teams, 2 players each."""
+        import numpy as np
+
+        return pl.DataFrame({
+            "match_id": ["game1"] * 4,
+            "player_id": ["p1", "p2", "p3", "p4"],
+            "team_id": ["A", "A", "B", "B"],
+            "start_date": ["2024-01-01"] * 4,
+            "performance": performance_values,
+            "participation_weight": [1.0] * 4,
+        })
+
+    def test_nan_performance_does_not_raise(self, nan_cn):
+        """NaN performance values should not raise ValueError."""
+        import numpy as np
+
+        # Use values that give mean ~0.5 when NaN is excluded
+        df = self._create_test_df([0.6, np.nan, 0.4, 0.5])
+
+        gen = PlayerRatingGenerator(
+            performance_column="performance",
+            column_names=nan_cn,
+            features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+        )
+
+        # Should not raise
+        result = gen.fit_transform(df)
+        assert len(result) == 4
+
+    def test_inf_performance_does_not_raise(self, nan_cn):
+        """Inf performance values should not raise ValueError."""
+        # Use values that give mean ~0.5 when inf is excluded
+        df = self._create_test_df([0.6, float('inf'), 0.4, 0.5])
+
+        gen = PlayerRatingGenerator(
+            performance_column="performance",
+            column_names=nan_cn,
+            features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+        )
+
+        result = gen.fit_transform(df)
+        assert len(result) == 4
+
+    def test_neg_inf_performance_does_not_raise(self, nan_cn):
+        """Negative inf performance values should not raise ValueError."""
+        # Use values that give mean ~0.5 when -inf is excluded
+        df = self._create_test_df([0.6, float('-inf'), 0.4, 0.5])
+
+        gen = PlayerRatingGenerator(
+            performance_column="performance",
+            column_names=nan_cn,
+            features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+        )
+
+        result = gen.fit_transform(df)
+        assert len(result) == 4
+
+    def test_nan_performance_treated_as_zero_rating_change(self, nan_cn):
+        """Players with NaN performance should have zero rating change."""
+        import numpy as np
+
+        # Two games: first establishes ratings, second tests NaN handling
+        df = pl.DataFrame({
+            "match_id": ["game1"] * 4 + ["game2"] * 4,
+            "player_id": ["p1", "p2", "p3", "p4"] * 2,
+            "team_id": ["A", "A", "B", "B"] * 2,
+            "start_date": ["2024-01-01"] * 4 + ["2024-01-02"] * 4,
+            "performance": [0.5, 0.5, 0.5, 0.5, 0.6, np.nan, 0.4, 0.5],
+            "participation_weight": [1.0] * 8,
+        })
+
+        gen = PlayerRatingGenerator(
+            performance_column="performance",
+            column_names=nan_cn,
+            features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+        )
+
+        result = gen.fit_transform(df)
+
+        # Get player p2's ratings for both games
+        p2_game1 = result.filter(
+            (pl.col("player_id") == "p2") & (pl.col("match_id") == "game1")
+        )["player_off_rating_performance"][0]
+
+        p2_game2 = result.filter(
+            (pl.col("player_id") == "p2") & (pl.col("match_id") == "game2")
+        )["player_off_rating_performance"][0]
+
+        # Rating should not change when performance is NaN
+        assert p2_game1 == p2_game2, "NaN performance should result in zero rating change"
+
+    def test_all_nan_performance_in_match_handled(self, nan_cn):
+        """Match where all players have NaN should not raise."""
+        import numpy as np
+
+        # All NaN - validation is skipped when no finite values exist
+        df = self._create_test_df([np.nan, np.nan, np.nan, np.nan])
+
+        gen = PlayerRatingGenerator(
+            performance_column="performance",
+            column_names=nan_cn,
+            features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+        )
+
+        result = gen.fit_transform(df)
+        assert len(result) == 4
+
+    def test_mixed_nan_none_performance(self, nan_cn):
+        """Mix of NaN and None performance values should both be handled."""
+        import numpy as np
+
+        # Use values that give mean ~0.5 when NaN/None are excluded
+        df = self._create_test_df([0.6, np.nan, None, 0.5])
+
+        gen = PlayerRatingGenerator(
+            performance_column="performance",
+            column_names=nan_cn,
+            features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+        )
+
+        result = gen.fit_transform(df)
+        assert len(result) == 4