spforge 0.8.27__py3-none-any.whl → 0.8.30__py3-none-any.whl

spforge/data_structures.py

@@ -12,6 +12,8 @@ class ColumnNames:
     position: str | None = None
     participation_weight: str | None = None
     projected_participation_weight: str | None = None
+    defense_participation_weight: str | None = None
+    projected_defense_participation_weight: str | None = None
     update_match_id: str | None = None
     parent_team_id: str | None = None
     team_players_playing_time: str | None = None
@@ -81,6 +83,8 @@ class MatchPerformance:
     performance_value: float | None
     participation_weight: float | None
     projected_participation_weight: float
+    defense_participation_weight: float | None = None
+    projected_defense_participation_weight: float | None = None
     team_players_playing_time: dict[str, float] | None = None
     opponent_players_playing_time: dict[str, float] | None = None
 

spforge/ratings/_player_rating.py

@@ -39,6 +39,8 @@ from spforge.feature_generator._utils import to_polars
 PLAYER_STATS = "__PLAYER_STATS"
 _SCALED_PW = "__scaled_participation_weight__"
 _SCALED_PPW = "__scaled_projected_participation_weight__"
+_SCALED_DPW = "__scaled_defense_participation_weight__"
+_SCALED_PDPW = "__scaled_projected_defense_participation_weight__"
 
 
 class PlayerRatingGenerator(RatingGenerator):
@@ -166,6 +168,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
 
@@ -174,6 +188,8 @@ class PlayerRatingGenerator(RatingGenerator):
         self.auto_scale_participation_weights = bool(auto_scale_participation_weights)
         self._participation_weight_max: float | None = None
         self._projected_participation_weight_max: float | None = None
+        self._defense_participation_weight_max: float | None = None
+        self._projected_defense_participation_weight_max: float | None = None
 
         self._player_off_ratings: dict[str, PlayerRating] = {}
         self._player_def_ratings: dict[str, PlayerRating] = {}
@@ -221,8 +237,11 @@ class PlayerRatingGenerator(RatingGenerator):
             eps = 1e-6
             return min_val < -eps or max_val > (1.0 + eps)
 
-        if _out_of_bounds(cn.participation_weight) or _out_of_bounds(
-            cn.projected_participation_weight
+        if (
+            _out_of_bounds(cn.participation_weight)
+            or _out_of_bounds(cn.projected_participation_weight)
+            or _out_of_bounds(cn.defense_participation_weight)
+            or _out_of_bounds(cn.projected_defense_participation_weight)
         ):
             self.scale_participation_weights = True
             logging.warning(
@@ -277,6 +296,25 @@ class PlayerRatingGenerator(RatingGenerator):
         elif self._participation_weight_max is not None:
             self._projected_participation_weight_max = self._participation_weight_max
 
+        if cn.defense_participation_weight and cn.defense_participation_weight in df.columns:
+            q_val = pl_df[cn.defense_participation_weight].quantile(0.99, "linear")
+            if q_val is not None:
+                self._defense_participation_weight_max = float(q_val)
+        elif self._participation_weight_max is not None:
+            self._defense_participation_weight_max = self._participation_weight_max
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+        ):
+            q_val = pl_df[cn.projected_defense_participation_weight].quantile(0.99, "linear")
+            if q_val is not None:
+                self._projected_defense_participation_weight_max = float(q_val)
+        elif self._defense_participation_weight_max is not None:
+            self._projected_defense_participation_weight_max = self._defense_participation_weight_max
+        elif self._projected_participation_weight_max is not None:
+            self._projected_defense_participation_weight_max = self._projected_participation_weight_max
+
     def _scale_participation_weight_columns(self, df: pl.DataFrame) -> pl.DataFrame:
         """Create internal scaled participation weight columns without mutating originals."""
         if not self.scale_participation_weights:
@@ -309,6 +347,32 @@ class PlayerRatingGenerator(RatingGenerator):
                 .alias(_SCALED_PPW)
             )
 
+        if (
+            cn.defense_participation_weight
+            and cn.defense_participation_weight in df.columns
+            and self._defense_participation_weight_max is not None
+            and self._defense_participation_weight_max > 0
+        ):
+            denom = float(self._defense_participation_weight_max)
+            df = df.with_columns(
+                (pl.col(cn.defense_participation_weight) / denom)
+                .clip(0.0, 1.0)
+                .alias(_SCALED_DPW)
+            )
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+            and self._projected_defense_participation_weight_max is not None
+            and self._projected_defense_participation_weight_max > 0
+        ):
+            denom = float(self._projected_defense_participation_weight_max)
+            df = df.with_columns(
+                (pl.col(cn.projected_defense_participation_weight) / denom)
+                .clip(0.0, 1.0)
+                .alias(_SCALED_PDPW)
+            )
+
         return df
 
     def _get_participation_weight_col(self) -> str:
@@ -327,7 +391,9 @@ class PlayerRatingGenerator(RatingGenerator):
 
     def _remove_internal_scaled_columns(self, df: pl.DataFrame) -> pl.DataFrame:
         """Remove internal scaled columns before returning."""
-        cols_to_drop = [c for c in [_SCALED_PW, _SCALED_PPW] if c in df.columns]
+        cols_to_drop = [
+            c for c in [_SCALED_PW, _SCALED_PPW, _SCALED_DPW, _SCALED_PDPW] if c in df.columns
+        ]
         if cols_to_drop:
             df = df.drop(cols_to_drop)
         return df
@@ -517,6 +583,7 @@ class PlayerRatingGenerator(RatingGenerator):
                 )
 
                 perf_value = pre_player.match_performance.performance_value
+
                 if perf_value is None:
                     off_change = 0.0
                 else:
@@ -541,7 +608,7 @@ class PlayerRatingGenerator(RatingGenerator):
                     def_change = (
                         (def_perf - float(pred_def))
                         * mult_def
-                        * float(pre_player.match_performance.participation_weight)
+                        * float(pre_player.match_performance.defense_participation_weight)
                     )
 
                 if math.isnan(off_change) or math.isnan(def_change):
@@ -610,6 +677,7 @@ class PlayerRatingGenerator(RatingGenerator):
                 )
 
                 perf_value = pre_player.match_performance.performance_value
+
                 if perf_value is None:
                     off_change = 0.0
                 else:
@@ -634,7 +702,7 @@ class PlayerRatingGenerator(RatingGenerator):
                     def_change = (
                         (def_perf - float(pred_def))
                         * mult_def
-                        * float(pre_player.match_performance.participation_weight)
+                        * float(pre_player.match_performance.defense_participation_weight)
                     )
 
                 if math.isnan(off_change) or math.isnan(def_change):
@@ -908,6 +976,19 @@ class PlayerRatingGenerator(RatingGenerator):
         if _SCALED_PPW in df.columns:
             player_stat_cols.append(_SCALED_PPW)
 
+        if cn.defense_participation_weight and cn.defense_participation_weight in df.columns:
+            player_stat_cols.append(cn.defense_participation_weight)
+        if _SCALED_DPW in df.columns:
+            player_stat_cols.append(_SCALED_DPW)
+
+        if (
+            cn.projected_defense_participation_weight
+            and cn.projected_defense_participation_weight in df.columns
+        ):
+            player_stat_cols.append(cn.projected_defense_participation_weight)
+        if _SCALED_PDPW in df.columns:
+            player_stat_cols.append(_SCALED_PDPW)
+
         if cn.position and cn.position in df.columns:
             player_stat_cols.append(cn.position)
 
@@ -1027,6 +1108,28 @@ class PlayerRatingGenerator(RatingGenerator):
                 projected_participation_weight = participation_weight
             projected_participation_weights.append(projected_participation_weight)
 
+            # Use scaled defense participation weight if available, otherwise default to participation_weight
+            if _SCALED_DPW in team_player:
+                defense_participation_weight = team_player.get(_SCALED_DPW, participation_weight)
+            elif cn.defense_participation_weight:
+                defense_participation_weight = team_player.get(
+                    cn.defense_participation_weight, participation_weight
+                )
+            else:
+                defense_participation_weight = participation_weight
+
+            # Use scaled projected defense participation weight if available
+            if _SCALED_PDPW in team_player:
+                projected_defense_participation_weight = team_player.get(
+                    _SCALED_PDPW, defense_participation_weight
+                )
+            elif cn.projected_defense_participation_weight:
+                projected_defense_participation_weight = team_player.get(
+                    cn.projected_defense_participation_weight, defense_participation_weight
+                )
+            else:
+                projected_defense_participation_weight = defense_participation_weight
+
             perf_val = (
                 float(team_player[self.performance_column])
                 if (
@@ -1047,6 +1150,8 @@ class PlayerRatingGenerator(RatingGenerator):
                 performance_value=perf_val,
                 projected_participation_weight=projected_participation_weight,
                 participation_weight=participation_weight,
+                defense_participation_weight=defense_participation_weight,
+                projected_defense_participation_weight=projected_defense_participation_weight,
                 team_players_playing_time=team_playing_time,
                 opponent_players_playing_time=opponent_playing_time,
             )
@@ -1282,6 +1387,22 @@ class PlayerRatingGenerator(RatingGenerator):
                         ppw = pw
                     proj_w.append(float(ppw))
 
+                    # Use scaled defense participation weight if available
+                    if _SCALED_DPW in tp:
+                        dpw = tp.get(_SCALED_DPW, pw)
+                    elif cn.defense_participation_weight:
+                        dpw = tp.get(cn.defense_participation_weight, pw)
+                    else:
+                        dpw = pw
+
+                    # Use scaled projected defense participation weight if available
+                    if _SCALED_PDPW in tp:
+                        pdpw = tp.get(_SCALED_PDPW, dpw)
+                    elif cn.projected_defense_participation_weight:
+                        pdpw = tp.get(cn.projected_defense_participation_weight, dpw)
+                    else:
+                        pdpw = dpw
+
                     team_playing_time = self._get_players_playing_time(
                         tp, cn.team_players_playing_time
                     )
@@ -1293,6 +1414,8 @@ class PlayerRatingGenerator(RatingGenerator):
                         performance_value=get_perf_value(tp),
                         projected_participation_weight=ppw,
                         participation_weight=pw,
+                        defense_participation_weight=dpw,
+                        projected_defense_participation_weight=pdpw,
                         team_players_playing_time=team_playing_time,
                         opponent_players_playing_time=opponent_playing_time,
                     )

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/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.27.dist-info → spforge-0.8.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.27
+Version: 0.8.30
 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.27.dist-info → spforge-0.8.30.dist-info}/RECORD

@@ -16,7 +16,7 @@ examples/nba/data/utils.py,sha256=41hxLQ1d6ZgBEcHa5MI0-fG5KbsRi07cclMPQZM95ek,50
 spforge/__init__.py,sha256=8vZhy7XUpzqWkVKpXqwqOLDkQlNytRhyf4qjwObfXgU,468
 spforge/autopipeline.py,sha256=rZ6FhJxcgNLvtr3hTVkEiW4BiorgXxADThfMuQ42orE,29866
 spforge/base_feature_generator.py,sha256=RbD00N6oLCQQcEb_VF5wbwZztl-X8k9B0Wlaj9Os1iU,668
-spforge/data_structures.py,sha256=k82v5r79vl0_FAVvsxVF9Nbzb5FoHqVrlHZlEXGc5gQ,7298
+spforge/data_structures.py,sha256=AltcyPvEI2qLuk43qwnljTj-QZzLMw1UEL6-lWQvqLQ,7530
 spforge/features_generator_pipeline.py,sha256=n8vzZKqXNFcFRDWZhllnkhAh5NFXdOD3FEIOpHcay8E,8208
 spforge/utils.py,sha256=2RlivUtMX5wQWpFVUyFfexDJE0wV6uZ4dnNzvoDmVhI,2644
 spforge/cross_validator/__init__.py,sha256=1QHgTFIZ73EZ_MgJlUKimxdUmB7MFaOEy6jsUs6V0T0,134
@@ -51,18 +51,18 @@ spforge/performance_transformers/_performance_manager.py,sha256=WmjmlMEnq7y75MiI
 spforge/performance_transformers/_performances_transformers.py,sha256=0lxuWjAfWBRXRgQsNJHjw3P-nlTtHBu4_bOVdoy7hq4,15536
 spforge/ratings/__init__.py,sha256=OZVH2Lo6END3n1X8qi4QcyAPlThIwAYwVKCiIuOQSQU,576
 spforge/ratings/_base.py,sha256=ne4BRrYFPqMirdFPVnyDN44wjFQwOQgWoUXu_59xgWE,14687
-spforge/ratings/_player_rating.py,sha256=TDw0LM-sLn27fprUhOW5csaDqAhzagoVm8SPKipZZmg,61106
+spforge/ratings/_player_rating.py,sha256=0VZYTWdoZoxPpw1UhTsRxlwMJjBAGNr2EdGOQkT2BpE,67097
 spforge/ratings/_team_rating.py,sha256=3m90-R2zW0k5EHwjw-83Hacz91fGmxW1LQ8ZUGHlgt4,24970
 spforge/ratings/enums.py,sha256=s7z_RcZS6Nlgfa_6tasO8_IABZJwywexe7sep9DJBgo,1739
 spforge/ratings/league_identifier.py,sha256=_KDUKOwoNU6RNFKE5jju4eYFGVNGBdJsv5mhNvMakfc,6019
 spforge/ratings/league_start_rating_optimizer.py,sha256=Q4Vo3QT-r55qP4aD9WftsTB00UOSRvxM1khlyuAGWNM,8582
-spforge/ratings/player_performance_predictor.py,sha256=UPzOEbougHT6FcmOiuTa3vEM6q8FZq-SjKb0AqD0JS4,8365
+spforge/ratings/player_performance_predictor.py,sha256=GtPpYlALgbQk8YHeaiRbpRvJHxeAhKpRxsaVUc9zR5o,7963
 spforge/ratings/start_rating_generator.py,sha256=eSasa5Oe9n4IoTGjFCYyFQAGrJtzrBW-Qor97lmaYuM,6776
 spforge/ratings/team_performance_predictor.py,sha256=ThQOmYQUqKBB46ONYHOMM2arXFH8AkyKpAZzs80SjHA,7217
 spforge/ratings/team_start_rating_generator.py,sha256=vK-_m8KwcHopchch_lKNHSGLiiNm5q9Lenm0d1cP_po,5110
 spforge/ratings/utils.py,sha256=_zFemqz2jJkH8rn2EZpDt8N6FELUmYp9qCnPzRtOIGU,4497
 spforge/scorer/__init__.py,sha256=wj8PCvYIl6742Xwmt86c3oy6iqE8Ss-OpwHud6kd9IY,256
-spforge/scorer/_score.py,sha256=jZPaKiSpb14Lzec4HWrK3CfpkqPaN33mriHUZosRozM,60566
+spforge/scorer/_score.py,sha256=rGbzTiiS0KVbsGgJ742JoLDEoK79LbgTTuas6XHSZpw,65370
 spforge/transformers/__init__.py,sha256=IPCsMcsgBqG52d0ttATLCY4HvFCQZddExlLt74U-zuI,390
 spforge/transformers/_base.py,sha256=-smr_McQF9bYxM5-Agx6h7Xv_fhZzPfpAdQV-qK18bs,1134
 spforge/transformers/_net_over_predicted.py,sha256=5dC8pvA1DNO0yXPSgJSMGU8zAHi-maUELm7FqFQVo-U,2321
@@ -71,7 +71,7 @@ spforge/transformers/_other_transformer.py,sha256=w2a7Wnki3vJe4GAkSa4kealw0GILIo
 spforge/transformers/_predictor.py,sha256=2sE6gfVrilXzPVcBurSrtqHw33v2ljygQcEYXt9LhZc,3119
 spforge/transformers/_simple_transformer.py,sha256=zGUFNQYMeoDSa2CoQejQNiNmKCBN5amWTvyOchiUHj0,5660
 spforge/transformers/_team_ratio_predictor.py,sha256=g8_bR53Yyv0iNCtol1O9bgJSeZcIco_AfbQuUxQJkeY,6884
-spforge-0.8.27.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.30.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 tests/test_autopipeline.py,sha256=7cNAn-nmGolfyfk3THh9IKcHZfRA-pLYC_xAyMg-No4,26863
 tests/test_autopipeline_context.py,sha256=IuRUY4IA6uMObvbl2pXSaXO2_tl3qX6wEbTZY0dkTMI,1240
 tests/test_feature_generator_pipeline.py,sha256=CK0zVL8PfTncy3RmG9i-YpgwjOIV7yJhV7Q44tbetI8,19020
@@ -94,20 +94,21 @@ tests/hyperparameter_tuning/test_estimator_tuner.py,sha256=iewME41d6LR2aQ0OtohGF
 tests/hyperparameter_tuning/test_rating_tuner.py,sha256=usjC2ioO_yWRjjNAlRTyMVYheOrCi0kKocmHQHdTmpM,18699
 tests/performance_transformers/test_performance_manager.py,sha256=gjuuV_hb27kCo_kUecPKG3Cbot2Gqis1W3kw2A4ovS4,10690
 tests/performance_transformers/test_performances_transformers.py,sha256=A-tGiCx7kXrj1cVj03Bc7prOeZ1_Ryz8YFx9uj3eK6w,11064
-tests/ratings/test_player_rating_generator.py,sha256=tpU83Orw1nlus29a0s9vc1pghL-f2rs642viW_6wFgk,83633
+tests/ratings/test_player_rating_generator.py,sha256=F4mW7J4djkFpt0GgORIfVz0jKegfGNwPqGtXp44VOSc,100762
 tests/ratings/test_player_rating_no_mutation.py,sha256=GzO3Hl__5K68DS3uRLefwnbcTJOvBM7cZqww4M21UZM,8493
 tests/ratings/test_ratings_property.py,sha256=ckyfGILXa4tfQvsgyXEzBDNr2DUmHwFRV13N60w66iE,6561
 tests/ratings/test_team_rating_generator.py,sha256=SqQcfckNmJJc99feCdnmkNYDape-p69e92Dp8Vzpu2w,101156
 tests/ratings/test_utils_scaled_weights.py,sha256=iHxe6ZDUB_I2B6HT0xTGqXBkl7gRlqVV0e_7Lwun5po,4988
 tests/scorer/test_score.py,sha256=rw3xJs6xqWVpalVMUQz557m2JYGR7PmhrsjfTex0b0c,79121
 tests/scorer/test_score_aggregation_granularity.py,sha256=O5TRlG9UE4NBpF0tL_ywZKDmkMIorwrxgTegQ75Tr7A,15871
+tests/scorer/test_scorer_name.py,sha256=puwlfy_tdtFUfcWdRqUNJcytSIDlbBnksFbqqXHgOBg,10347
 tests/transformers/test_estimator_transformer_context.py,sha256=5GOHbuWCWBMFwwOTJOuD4oNDsv-qDR0OxNZYGGuMdag,1819
 tests/transformers/test_net_over_predicted.py,sha256=vh7O1iRRPf4vcW9aLhOMAOyatfM5ZnLsQBKNAYsR3SU,3363
 tests/transformers/test_other_transformer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/transformers/test_predictor_transformer.py,sha256=N1aBYLjN3ldpYZLwjih_gTFYSMitrZu-PNK78W6RHaQ,6877
 tests/transformers/test_simple_transformer.py,sha256=wWR0qjLb_uS4HXrJgGdiqugOY1X7kwd1_OPS02IT2b8,4676
 tests/transformers/test_team_ratio_predictor.py,sha256=fOUP_JvNJi-3kom3ZOs1EdG0I6Z8hpLpYKNHu1eWtOw,8562
-spforge-0.8.27.dist-info/METADATA,sha256=Bl0sOhG9rDGmQpTThxwNPlAKyXeR6dCxWlGmbHH0LN0,20048
-spforge-0.8.27.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-spforge-0.8.27.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
-spforge-0.8.27.dist-info/RECORD,,
+spforge-0.8.30.dist-info/METADATA,sha256=DHqd51r8ONs36cHM0-CaWQJW_4QIKmX5MDNvl-2xTfo,20048
+spforge-0.8.30.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+spforge-0.8.30.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
+spforge-0.8.30.dist-info/RECORD,,