spforge 0.8.35__tar.gz → 0.8.37__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.35"
+version = "0.8.37"
 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.37}/spforge/performance_transformers/_performance_manager.py

@@ -86,8 +86,8 @@ class PerformanceManager(BaseEstimator, TransformerMixin):
         transformer_names: list[TransformerName] | None = None,
         custom_transformers: list[NarwhalsFeatureTransformer] | None = None,
         prefix: str = "performance__",
-        min_value: float = -0.02,
-        max_value: float = 1.02,
+        min_value: float = 0.0,
+        max_value: float = 1.0,
         zero_inflation_threshold: float = 0.15,
     ):
         self.features = features
@@ -209,8 +209,8 @@ class PerformanceWeightsManager(PerformanceManager):
         transformer_names: (
             list[Literal["partial_standard_scaler", "symmetric", "min_max"]] | None
         ) = None,
-        max_value: float = 1.02,
-        min_value: float = -0.02,
+        max_value: float = 1.0,
+        min_value: float = 0.0,
         prefix: str = "performance__",
         return_all_features: bool = False,
         zero_inflation_threshold: float = 0.15,

{spforge-0.8.35 → spforge-0.8.37}/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.37}/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.37/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.35
+Version: 0.8.37
 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.37}/tests/performance_transformers/test_performance_manager.py

@@ -203,8 +203,8 @@ def test_performance_manager_aliases_unprefixed_input_when_transformer_expects_p
         transformer_names=[],
         prefix="performance__",
         performance_column="weighted_performance",
-        min_value=-0.02,
-        max_value=1.02,
+        min_value=0.0,
+        max_value=1.0,
     )
 
     pm.fit(df)
@@ -434,3 +434,99 @@ class TestZeroInflationHandling:
 
         # Should have switched to quantile scaler
         assert manager._using_quantile_scaler is True
+
+
+class TestAutoScalePerformanceBounds:
+    """Tests for ensuring scaled performance stays within [0, 1] bounds."""
+
+    @pytest.mark.parametrize("frame", ["pd", "pl"])
+    def test_auto_scale_performance_preserves_non_negative(self, frame):
+        """Scaled performance should be non-negative when input is non-negative."""
+        np.random.seed(42)
+        # Create data similar to free throw % - centered around 0.77 with some zeros
+        n = 400
+        data = []
+        for _ in range(n):
+            if np.random.random() < 0.25:  # 25% zeros (missed all free throws)
+                data.append(0.0)
+            else:
+                # Values between 0.6 and 1.0, centered around 0.77
+                data.append(np.clip(np.random.normal(0.77, 0.15), 0.0, 1.0))
+
+        df = _make_native_df(frame, {"x": data})
+
+        pm = PerformanceManager(
+            features=["x"],
+            transformer_names=["symmetric", "partial_standard_scaler", "min_max"],
+            prefix="performance__",
+            performance_column="perf",
+        )
+
+        result = pm.fit_transform(df)
+        result_nw = nw.from_native(result)
+        scaled = result_nw["performance__perf"].to_numpy()
+
+        assert np.all(scaled >= 0), f"Scaled performance should not be negative, min was {scaled.min()}"
+
+    @pytest.mark.parametrize("frame", ["pd", "pl"])
+    def test_auto_scale_performance_output_range(self, frame):
+        """Scaled performance should be in [0, 1] when input is in [0, 1]."""
+        np.random.seed(42)
+        # Create data with performance in [0, 1] but skewed distribution
+        n = 400
+        data = []
+        for _ in range(n):
+            if np.random.random() < 0.25:
+                data.append(0.0)
+            else:
+                data.append(np.clip(np.random.normal(0.77, 0.15), 0.0, 1.0))
+
+        df = _make_native_df(frame, {"x": data})
+
+        pm = PerformanceManager(
+            features=["x"],
+            transformer_names=["symmetric", "partial_standard_scaler", "min_max"],
+            prefix="performance__",
+            performance_column="perf",
+        )
+
+        result = pm.fit_transform(df)
+        result_nw = nw.from_native(result)
+        scaled = result_nw["performance__perf"].to_numpy()
+
+        assert np.all(scaled >= 0.0), f"Scaled min should be >= 0, got {scaled.min()}"
+        assert np.all(scaled <= 1.0), f"Scaled max should be <= 1, got {scaled.max()}"
+
+    @pytest.mark.parametrize("frame", ["pd", "pl"])
+    def test_default_bounds_are_unit_interval(self, frame):
+        """Test that default bounds are [0, 1]."""
+        pm = PerformanceManager(
+            features=["x"],
+            transformer_names=[],
+            prefix="",
+            performance_column="x",
+        )
+
+        assert pm.min_value == 0.0
+        assert pm.max_value == 1.0
+
+    @pytest.mark.parametrize("frame", ["pd", "pl"])
+    def test_custom_bounds_still_work(self, frame):
+        """Test that custom bounds can still be specified."""
+        df = _make_native_df(frame, {"x": [-10.0, 0.5, 10.0]})
+
+        pm = PerformanceManager(
+            features=["x"],
+            transformer_names=[],
+            prefix="",
+            performance_column="x",
+            min_value=-0.5,
+            max_value=1.5,
+        )
+
+        result = pm.fit_transform(df)
+        result_nw = nw.from_native(result)
+        scaled = result_nw["x"].to_numpy()
+
+        assert scaled.min() >= -0.5
+        assert scaled.max() <= 1.5

{spforge-0.8.35 → spforge-0.8.37}/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