spforge 0.8.26__tar.gz → 0.8.29__tar.gz

{spforge-0.8.26/spforge.egg-info → spforge-0.8.29}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.26"
+version = "0.8.29"
 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.26 → spforge-0.8.29}/spforge/ratings/_player_rating.py

@@ -2,8 +2,10 @@
 from __future__ import annotations
 
 import copy
-import math
+import json
 import logging
+import math
+from collections.abc import Mapping
 from typing import Any, Literal
 
 import narwhals.stable.v2 as nw
@@ -164,6 +166,18 @@ class PlayerRatingGenerator(RatingGenerator):
         self.start_min_match_count_team_rating = start_min_match_count_team_rating
         self.start_hardcoded_start_rating = start_harcoded_start_rating
 
+        if hasattr(self._performance_predictor, '_reference_rating'):
+            effective_start = self.start_hardcoded_start_rating
+
+            if effective_start is None and self.start_league_ratings:
+                league_ratings = list(self.start_league_ratings.values())
+                effective_start = sum(league_ratings) / len(league_ratings)
+
+            if effective_start is None:
+                effective_start = 1000
+
+            self._performance_predictor._reference_rating = effective_start
+
         self.team_id_change_confidence_sum_decrease = team_id_change_confidence_sum_decrease
         self.column_names = column_names
 
@@ -515,6 +529,7 @@ class PlayerRatingGenerator(RatingGenerator):
                 )
 
                 perf_value = pre_player.match_performance.performance_value
+
                 if perf_value is None:
                     off_change = 0.0
                 else:
@@ -608,6 +623,7 @@ class PlayerRatingGenerator(RatingGenerator):
                 )
 
                 perf_value = pre_player.match_performance.performance_value
+
                 if perf_value is None:
                     off_change = 0.0
                 else:
@@ -912,10 +928,16 @@ class PlayerRatingGenerator(RatingGenerator):
         if cn.league and cn.league in df.columns:
             player_stat_cols.append(cn.league)
 
-        if cn.team_players_playing_time and cn.team_players_playing_time in df.columns:
+        if (
+            cn.team_players_playing_time
+            and cn.team_players_playing_time in df.columns
+        ):
             player_stat_cols.append(cn.team_players_playing_time)
 
-        if cn.opponent_players_playing_time and cn.opponent_players_playing_time in df.columns:
+        if (
+            cn.opponent_players_playing_time
+            and cn.opponent_players_playing_time in df.columns
+        ):
             player_stat_cols.append(cn.opponent_players_playing_time)
 
         df = df.with_columns(pl.struct(player_stat_cols).alias(PLAYER_STATS))
@@ -948,6 +970,40 @@ class PlayerRatingGenerator(RatingGenerator):
         match_df = self._add_day_number(match_df, cn.start_date, "__day_number")
         return match_df
 
+    def _get_players_playing_time(
+        self, source: Mapping[str, Any], column_name: str | None
+    ) -> dict[str, float] | None:
+        if not column_name:
+            return None
+        return self._normalize_players_playing_time(source.get(column_name))
+
+    @staticmethod
+    def _normalize_players_playing_time(raw_value: Any) -> dict[str, float] | None:
+        if raw_value is None:
+            return None
+
+        if isinstance(raw_value, str):
+            raw_text = raw_value
+            raw_value = raw_value.strip()
+            if not raw_value:
+                return None
+            try:
+                raw_value = json.loads(raw_value)
+            except json.JSONDecodeError as exc:
+                raise ValueError(
+                    f"unable to parse playing time JSON {raw_text!r}: {exc}"
+                ) from exc
+
+        if isinstance(raw_value, Mapping):
+            normalized: dict[str, float] = {}
+            for key, value in raw_value.items():
+                if value is None:
+                    continue
+                normalized[str(key)] = float(value)
+            return normalized or None
+
+        return None
+
     def _create_pre_match_players_collection(
         self, r: dict, stats_col: str, day_number: int, team_id: str
     ) -> PreMatchPlayersCollection:
@@ -994,17 +1050,12 @@ class PlayerRatingGenerator(RatingGenerator):
                 else None
             )
 
-            team_playing_time = None
-            opponent_playing_time = None
-            if cn.team_players_playing_time:
-                raw_value = team_player.get(cn.team_players_playing_time)
-                if raw_value is not None:
-                    team_playing_time = raw_value
-
-            if cn.opponent_players_playing_time:
-                raw_value = team_player.get(cn.opponent_players_playing_time)
-                if raw_value is not None:
-                    opponent_playing_time = raw_value
+            team_playing_time = self._get_players_playing_time(
+                team_player, cn.team_players_playing_time
+            )
+            opponent_playing_time = self._get_players_playing_time(
+                team_player, cn.opponent_players_playing_time
+            )
 
             mp = MatchPerformance(
                 performance_value=perf_val,
@@ -1245,16 +1296,12 @@ class PlayerRatingGenerator(RatingGenerator):
                         ppw = pw
                     proj_w.append(float(ppw))
 
-                    team_playing_time = None
-                    opponent_playing_time = None
-                    if cn.team_players_playing_time:
-                        raw_value = tp.get(cn.team_players_playing_time)
-                        if raw_value is not None:
-                            team_playing_time = raw_value
-                    if cn.opponent_players_playing_time:
-                        raw_value = tp.get(cn.opponent_players_playing_time)
-                        if raw_value is not None:
-                            opponent_playing_time = raw_value
+                    team_playing_time = self._get_players_playing_time(
+                        tp, cn.team_players_playing_time
+                    )
+                    opponent_playing_time = self._get_players_playing_time(
+                        tp, cn.opponent_players_playing_time
+                    )
 
                     mp = MatchPerformance(
                         performance_value=get_perf_value(tp),

{spforge-0.8.26 → spforge-0.8.29}/spforge/ratings/player_performance_predictor.py

@@ -31,6 +31,7 @@ class PlayerPerformancePredictor(ABC):
         pass
 
 
+
 class PlayerRatingNonOpponentPerformancePredictor(PlayerPerformancePredictor):
 
     def __init__(
@@ -38,18 +39,22 @@ class PlayerRatingNonOpponentPerformancePredictor(PlayerPerformancePredictor):
         coef: float = 0.0015,
         last_sample_count: int = 1500,
         min_count_for_historical_average: int = 200,
-        historical_average_value_default: float = 1000,
     ):
         self.coef = coef
         self.last_sample_count = last_sample_count
         self.min_count_for_historical_average = min_count_for_historical_average
-        self.historical_average_value_default = historical_average_value_default
         if self.min_count_for_historical_average < 1:
             raise ValueError("min_count_for_historical_average must be positive")
-        self._prev_entries_ratings = []
+        self._reference_rating: float | None = None
 
     def reset(self):
-        self._prev_entries_ratings = []
+        pass
+
+    def _get_reference_rating(self) -> float:
+        """Get reference rating from rating generator, or default to 1000."""
+        if self._reference_rating is not None:
+            return self._reference_rating
+        return 1000
 
     def predict_performance(
         self,
@@ -57,21 +62,14 @@ class PlayerRatingNonOpponentPerformancePredictor(PlayerPerformancePredictor):
         opponent_team_rating: PreMatchTeamRating,
         team_rating: PreMatchTeamRating,
     ) -> float:
-        start_index = max(0, len(self._prev_entries_ratings) - self.last_sample_count)
-        recent_prev_entries_ratings = self._prev_entries_ratings[start_index:]
-        if len(recent_prev_entries_ratings) > self.min_count_for_historical_average:
-            historical_average_rating = sum(recent_prev_entries_ratings) / len(
-                recent_prev_entries_ratings
-            )
-        else:
-            historical_average_rating = self.historical_average_value_default
+        historical_average_rating = self._get_reference_rating()
+
         net_mean_rating_over_historical_average = (
             player_rating.rating_value - historical_average_rating
         )
 
         value = self.coef * net_mean_rating_over_historical_average
         prediction = (math.exp(value)) / (1 + math.exp(value))
-        self._prev_entries_ratings.append(player_rating.rating_value)
 
         return prediction
 

{spforge-0.8.26 → spforge-0.8.29}/spforge/scorer/_score.py

@@ -267,6 +267,7 @@ class BaseScorer(ABC):
         granularity: list[str] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         """
         :param target: The column name of the target
@@ -277,6 +278,9 @@ class BaseScorer(ABC):
         :param aggregation_level: The columns to group by before calculating the score (e.g., group from game-player to game-team)
         :param aggregation_method: Aggregation methods for pred/target when aggregation_level is set.
         :param granularity: The columns to calculate separate scores for each unique combination (e.g., different scores for each team)
+        :param compare_to_naive: If True, returns naive_score - model_score (improvement over naive baseline)
+        :param naive_granularity: Granularity for computing naive baseline predictions
+        :param _name_override: Override auto-generated name (internal use)
         """
         self.target = target
         self.pred_column = pred_column
@@ -295,6 +299,7 @@ class BaseScorer(ABC):
         self.granularity = granularity
         self.compare_to_naive = compare_to_naive
         self.naive_granularity = naive_granularity
+        self._name_override = _name_override
 
     def _resolve_aggregation_method(self, key: str) -> Any:
         if self.aggregation_method is None:
@@ -359,6 +364,98 @@ class BaseScorer(ABC):
             mask = col_mask if mask is None else (mask & col_mask)
         return df.filter(mask)
 
+    def _get_scorer_id(self) -> str:
+        """Get scorer-specific identifier in snake_case. Override in subclasses if needed."""
+        import re
+        name = self.__class__.__name__
+        # Check if name is all uppercase (acronym like PWMSE)
+        if name.isupper():
+            return name.lower()
+        # Otherwise use regular snake_case conversion
+        return re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()
+
+    def _format_column_list(self, columns: list[str], max_display: int = 3) -> str:
+        """Format column list with abbreviation for long lists."""
+        if len(columns) <= max_display:
+            return "+".join(columns)
+        shown = "+".join(columns[:max_display])
+        remaining = len(columns) - max_display
+        return f"{shown}+{remaining}more"
+
+    def _sanitize_column_name(self, name: str) -> str:
+        """Replace special characters with underscores."""
+        import re
+        return re.sub(r'[^a-zA-Z0-9_]', '_', name)
+
+    def _count_user_filters(self) -> int:
+        """Count filters excluding auto-added validation filter."""
+        if not self.filters:
+            return 0
+        if self.validation_column is None:
+            return len(self.filters)
+        count = 0
+        for f in self.filters:
+            if not (f.column_name == self.validation_column and
+                    f.operator == Operator.EQUALS and
+                    f.value == 1):
+                count += 1
+        return count
+
+    def _generate_name(self) -> str:
+        """Generate readable name from scorer configuration."""
+        parts = []
+
+        parts.append(self._get_scorer_id())
+
+        parts.append(self._sanitize_column_name(self.target))
+
+        if self.granularity:
+            gran_str = self._format_column_list(self.granularity)
+            parts.append(f"gran:{gran_str}")
+
+        if self.compare_to_naive:
+            if self.naive_granularity:
+                naive_str = self._format_column_list(self.naive_granularity)
+                parts.append(f"naive:{naive_str}")
+            else:
+                parts.append("naive")
+
+        if self.aggregation_level:
+            agg_str = self._format_column_list(self.aggregation_level)
+            parts.append(f"agg:{agg_str}")
+
+        filter_count = self._count_user_filters()
+        if filter_count > 0:
+            parts.append(f"filters:{filter_count}")
+
+        return "_".join(parts)
+
+    @property
+    def name(self) -> str:
+        """
+        Generate a human-readable name for this scorer.
+
+        Returns descriptive name based on scorer configuration including
+        target, granularity, naive comparison, aggregation, and filters.
+        Only includes components that are actually set (non-None/non-empty).
+
+        Format: {scorer_id}_{target}[_gran:{cols}][_naive[:cols]][_agg:{cols}][_filters:{n}]
+
+        Can be overridden by passing _name_override to constructor.
+
+        Examples:
+            >>> scorer = MeanBiasScorer(target="points", pred_column="pred")
+            >>> scorer.name
+            'mean_bias_scorer_points'
+
+            >>> scorer = MeanBiasScorer(target="points", granularity=["team_id"], compare_to_naive=True)
+            >>> scorer.name
+            'mean_bias_scorer_points_gran:team_id_naive'
+        """
+        if hasattr(self, '_name_override') and self._name_override is not None:
+            return self._name_override
+        return self._generate_name()
+
     @abstractmethod
     def score(self, df: IntoFrameT) -> float | dict[tuple, float]:
         """
@@ -385,6 +482,7 @@ class PWMSE(BaseScorer):
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
         evaluation_labels: list[int] | None = None,
+        _name_override: str | None = None,
     ):
         self.pred_column_name = pred_column
         super().__init__(
@@ -397,6 +495,7 @@ class PWMSE(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
         self.labels = labels
         self.evaluation_labels = evaluation_labels
@@ -553,6 +652,7 @@ class MeanBiasScorer(BaseScorer):
         labels: list[int] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         """
         :param pred_column: The column name of the predictions
@@ -563,6 +663,7 @@ class MeanBiasScorer(BaseScorer):
         :param granularity: The columns to calculate separate scores for each unique combination (e.g., different scores for each team)
         :param filters: The filters to apply before calculating
         :param labels: The labels corresponding to each index in probability distributions (e.g., [-5, -4, ..., 35] for rush yards)
+        :param _name_override: Override auto-generated name (internal use)
         """
 
         self.pred_column_name = pred_column
@@ -577,6 +678,7 @@ class MeanBiasScorer(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
 
     def _mean_bias_score(self, df: IntoFrameT) -> float:
@@ -691,6 +793,7 @@ class SklearnScorer(BaseScorer):
         params: dict[str, Any] = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         """
         :param pred_column: The column name of the predictions
@@ -701,6 +804,7 @@ class SklearnScorer(BaseScorer):
         :param aggregation_level: The columns to group by before calculating the score (e.g., group from game-player to game-team)
         :param granularity: The columns to calculate separate scores for each unique combination (e.g., different scores for each team)
         :param filters: The filters to apply before calculating
+        :param _name_override: Override auto-generated name (internal use)
         """
 
         super().__init__(
@@ -713,11 +817,22 @@ class SklearnScorer(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
         self.pred_column_name = pred_column
         self.scorer_function = scorer_function
         self.params = params or {}
 
+    def _get_scorer_id(self) -> str:
+        """Use the scorer function name."""
+        if hasattr(self.scorer_function, '__name__'):
+            name = self.scorer_function.__name__
+            # Handle lambda functions
+            if name == '<lambda>':
+                return "custom_metric"
+            return name
+        return "custom_metric"
+
     def _pad_probabilities(
         self, y_true: list[Any], probabilities: list[list[float]]
     ) -> tuple[list[list[float]], dict[str, Any]]:
@@ -827,6 +942,7 @@ class ProbabilisticMeanBias(BaseScorer):
         filters: list[Filter] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
 
         self.pred_column_name = pred_column
@@ -841,6 +957,7 @@ class ProbabilisticMeanBias(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
 
     def _aggregate_pandas_series(
@@ -1064,6 +1181,7 @@ class OrdinalLossScorer(BaseScorer):
         labels: list[int] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         self.pred_column_name = pred_column
         super().__init__(
@@ -1076,6 +1194,7 @@ class OrdinalLossScorer(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
         self.classes = classes
 
@@ -1263,6 +1382,7 @@ class ThresholdEventScorer(BaseScorer):
         filters: list["Filter"] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         self.pred_column_name = dist_column
         super().__init__(
@@ -1275,6 +1395,7 @@ class ThresholdEventScorer(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
 
         self.dist_column = dist_column

{spforge-0.8.26 → spforge-0.8.29/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.26
+Version: 0.8.29
 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.26 → spforge-0.8.29}/spforge.egg-info/SOURCES.txt

@@ -109,6 +109,7 @@ tests/ratings/test_team_rating_generator.py
 tests/ratings/test_utils_scaled_weights.py
 tests/scorer/test_score.py
 tests/scorer/test_score_aggregation_granularity.py
+tests/scorer/test_scorer_name.py
 tests/transformers/test_estimator_transformer_context.py
 tests/transformers/test_net_over_predicted.py
 tests/transformers/test_other_transformer.py