spforge 0.8.4__py3-none-any.whl → 0.8.8__py3-none-any.whl

tests/scorer/test_score.py

@@ -2048,3 +2048,93 @@ def test_all_scorers_handle_all_nan_targets(df_type):
         assert np.isnan(score) or score == 0.0
     except (ValueError, IndexError):
         pass
+SCORER_VALIDATION_CASES = [
+    pytest.param(
+        lambda: MeanBiasScorer(pred_column="pred", target="target", validation_column="is_validation"),
+        lambda: pd.DataFrame(
+            {
+                "pred": [2.0, 0.0],
+                "target": [1.0, 2.0],
+                "is_validation": [1, 0],
+            }
+        ),
+        id="mean_bias",
+    ),
+    pytest.param(
+        lambda: PWMSE(pred_column="pred", target="target", labels=[0, 1], validation_column="is_validation"),
+        lambda: pd.DataFrame(
+            {
+                "pred": [[0.7, 0.3], [0.4, 0.6]],
+                "target": [0, 1],
+                "is_validation": [1, 0],
+            }
+        ),
+        id="pwmse",
+    ),
+    pytest.param(
+        lambda: SklearnScorer(
+            scorer_function=mean_absolute_error, pred_column="pred", target="target", validation_column="is_validation"
+        ),
+        lambda: pd.DataFrame(
+            {
+                "pred": [1.0, 0.0],
+                "target": [1.0, 0.0],
+                "is_validation": [1, 0],
+            }
+        ),
+        id="sklearn",
+    ),
+    pytest.param(
+        lambda: ProbabilisticMeanBias(
+            pred_column="pred", target="target", class_column_name="classes", validation_column="is_validation"
+        ),
+        lambda: pd.DataFrame(
+            {
+                "pred": [[0.2, 0.8], [0.6, 0.4]],
+                "target": [1, 0],
+                "classes": [[0, 1], [0, 1]],
+                "is_validation": [1, 0],
+            }
+        ),
+        id="probabilistic_mean_bias",
+    ),
+    pytest.param(
+        lambda: OrdinalLossScorer(pred_column="pred", target="target", classes=[0, 1], validation_column="is_validation"),
+        lambda: pd.DataFrame(
+            {
+                "pred": [[0.2, 0.8], [0.6, 0.4]],
+                "target": [1, 0],
+                "is_validation": [1, 0],
+            }
+        ),
+        id="ordinal_loss",
+    ),
+    pytest.param(
+        lambda: ThresholdEventScorer(
+            dist_column="dist",
+            threshold_column="threshold",
+            outcome_column="outcome",
+            comparator=Operator.GREATER_THAN_OR_EQUALS,
+            validation_column="is_validation",
+        ),
+        lambda: pd.DataFrame(
+            {
+                "dist": [[0.2, 0.8], [0.6, 0.4], [0.3, 0.7]],
+                "threshold": [0.5, 0.2, 0.3],
+                "outcome": [1, 0, 1],
+                "is_validation": [1, 1, 0],
+            }
+        ),
+        id="threshold_event",
+    ),
+]
+
+
+@pytest.mark.parametrize("scorer_factory, df_factory", SCORER_VALIDATION_CASES)
+def test_scorers_respect_validation_column(scorer_factory, df_factory):
+    """Scorers should filter on validation_column when specified."""
+    df = df_factory()
+    df_valid = df[df["is_validation"] == 1]
+    score_all = scorer_factory().score(df)
+    score_valid = scorer_factory().score(df_valid)
+    assert score_all == score_valid

tests/test_feature_generator_pipeline.py

@@ -16,6 +16,49 @@ def column_names():
     )
 
 
+class PolarsOnlyGenerator:
+    def __init__(self):
+        self._features_out = ["polars_only_feature"]
+
+    @property
+    def features_out(self):
+        return self._features_out
+
+    def fit_transform(self, df, column_names=None):
+        if not isinstance(df, pl.DataFrame):
+            raise TypeError("Expected polars DataFrame")
+        return df.with_columns((pl.col("points") * 2).alias("polars_only_feature"))
+
+    def transform(self, df):
+        if not isinstance(df, pl.DataFrame):
+            raise TypeError("Expected polars DataFrame")
+        return df.with_columns((pl.col("points") * 2).alias("polars_only_feature"))
+
+    def future_transform(self, df):
+        return self.transform(df)
+
+
+def test_feature_generator_pipeline__passes_native_polars_to_custom_generator(column_names):
+    data = pl.DataFrame(
+        {
+            "game_id": [1, 1],
+            "team_id": ["A", "B"],
+            "player_id": ["p1", "p2"],
+            "date": pd.to_datetime(["2023-01-01", "2023-01-01"]),
+            "points": [10, 15],
+        }
+    )
+
+    pipeline = FeatureGeneratorPipeline(
+        feature_generators=[PolarsOnlyGenerator()],
+        column_names=column_names,
+    )
+
+    result = pipeline.fit_transform(data, column_names=column_names)
+
+    assert "polars_only_feature" in result.columns
+
+
 @pytest.mark.parametrize("df_type", [pd.DataFrame, pl.DataFrame])
 def test_feature_generator_pipeline__fit_transform_preserves_row_count(df_type, column_names):
     """FeatureGeneratorPipeline.fit_transform should preserve row count."""