spforge 0.8.36__tar.gz → 0.8.37__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.36"
+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.36 → 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.36 → spforge-0.8.37/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.36
+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.36 → 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