spforge 0.8.26__py3-none-any.whl → 0.8.29__py3-none-any.whl

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

@@ -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.dist-info → spforge-0.8.29.dist-info}/RECORD

@@ -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=zltf4utwzKQxkTA8DAPZ4LWRDlwGxoiKFaiPIo4sdNw,60323
+spforge/ratings/_player_rating.py,sha256=y6i7vv3RcNpYmcjBelu_lJXQmZQ4kOgswXeRwyc7ieY,61621
 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.26.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.29.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=Z66LN1-YdUHrS6dszWZf4HeENRyH8oEtu4Nlsh1MpMI,82442
+tests/ratings/test_player_rating_generator.py,sha256=gfNb2OcxGbs9MrPNZj_ShBk5VwLHNxXliUF9bsrvHcE,96836
 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.26.dist-info/METADATA,sha256=zywZZIfNsJ6DhREXxcqGD14itLC2woDadHSANqD61Ek,20048
-spforge-0.8.26.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-spforge-0.8.26.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
-spforge-0.8.26.dist-info/RECORD,,
+spforge-0.8.29.dist-info/METADATA,sha256=T-ruW0iWlC_xBOBpvNf6lBI55ErBY5clTPmkahthCLI,20048
+spforge-0.8.29.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+spforge-0.8.29.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
+spforge-0.8.29.dist-info/RECORD,,

tests/ratings/test_player_rating_generator.py

@@ -4,7 +4,12 @@ import polars as pl
 import pytest
 
 from spforge import ColumnNames
-from spforge.data_structures import RatingState
+from spforge.data_structures import (
+    MatchPerformance,
+    PlayerRating,
+    PreMatchPlayerRating,
+    PreMatchTeamRating,
+)
 from spforge.ratings import PlayerRatingGenerator, RatingKnownFeatures, RatingUnknownFeatures
 
 
@@ -78,6 +83,39 @@ def test_fit_transform_updates_internal_state(base_cn, sample_df):
     assert "P1" in gen._player_off_ratings
     assert "P1" in gen._player_def_ratings
 
+
+def test_pre_match_collection_parses_playing_time_json(base_cn):
+    """JSON strings in the team/opponent playing time columns should become dicts."""
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        team_players_playing_time="team_pt",
+        opponent_players_playing_time="opp_pt",
+    )
+    gen = PlayerRatingGenerator(performance_column="perf", column_names=cn)
+    gen._player_off_ratings["P1"] = PlayerRating(id="P1", rating_value=100.0)
+    gen._player_def_ratings["P1"] = PlayerRating(id="P1", rating_value=100.0)
+
+    stats_entry = {
+        cn.player_id: "P1",
+        "perf": 0.75,
+        cn.participation_weight: 1.0,
+        cn.team_players_playing_time: '{"P1": 30}',
+        cn.opponent_players_playing_time: '{"P3": 25}',
+    }
+
+    collection = gen._create_pre_match_players_collection(
+        r={"__PLAYER_STATS": [stats_entry]},
+        stats_col="__PLAYER_STATS",
+        day_number=1,
+        team_id="T1",
+    )
+
+    match_perf = collection.pre_match_player_ratings[0].match_performance
+    assert match_perf.team_players_playing_time == {"P1": 30.0}
+    assert match_perf.opponent_players_playing_time == {"P3": 25.0}
+
     assert gen._player_off_ratings["P1"].rating_value > 0
 
 
@@ -105,6 +143,60 @@ def test_fit_transform_participation_weight_scaling(base_cn):
     assert half_rating > 0
 
 
+def test_player_rating_generator_team_rating_coef_affects_predictor(base_cn):
+    """Passing a team rating coefficient should affect the predictor used by the generator."""
+    generator = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        performance_predictor="difference",
+        team_rating_diff_coef=0.5,
+        rating_diff_coef=0.0,
+        rating_diff_team_from_entity_coef=0.0,
+    )
+
+    predictor = generator._performance_predictor
+    match_perf = MatchPerformance(
+        performance_value=0.5,
+        participation_weight=1.0,
+        projected_participation_weight=1.0,
+    )
+    player_rating = PreMatchPlayerRating(
+        id="P1",
+        rating_value=100.0,
+        games_played=1,
+        league=None,
+        position=None,
+        match_performance=match_perf,
+    )
+    opponent_team_rating = PreMatchTeamRating(id="Opp", players=[], rating_value=100.0)
+    high_team_rating = PreMatchTeamRating(
+        id="TeamHigh",
+        players=[player_rating],
+        rating_value=110.0,
+    )
+    low_team_rating = PreMatchTeamRating(
+        id="TeamLow",
+        players=[player_rating],
+        rating_value=90.0,
+    )
+
+    high_pred = predictor.predict_performance(
+        player_rating=player_rating,
+        opponent_team_rating=opponent_team_rating,
+        team_rating=high_team_rating,
+    )
+    low_pred = predictor.predict_performance(
+        player_rating=player_rating,
+        opponent_team_rating=opponent_team_rating,
+        team_rating=low_team_rating,
+    )
+
+    assert predictor.team_rating_diff_coef == 0.5
+    assert high_pred > low_pred
+    assert high_pred > 0.5
+    assert low_pred < 0.5
+
+
 def test_fit_transform_batch_update_logic(base_cn):
     """Test that ratings do not update between matches if update_match_id is the same."""
     from dataclasses import replace
@@ -2319,3 +2411,302 @@ def test_fit_transform_backward_compatible_without_playing_time_columns(base_cn)
     # Ratings should be updated normally
     assert gen._player_off_ratings["P1"].rating_value != 1000.0
     assert gen._player_off_ratings["P3"].rating_value > gen._player_off_ratings["P4"].rating_value
+
+
+def test_fit_transform_ignore_opponent_predictor_adapts_to_performance_drift(base_cn):
+    """
+    Test that PlayerRatingNonOpponentPerformancePredictor converges to actual
+    performance with fixed reference (not stuck at 0.5 like rolling average).
+
+    With pre-scaled data (mean=0.48 ≠ 0.5), predictions should converge to 0.48,
+    not stay stuck at 0.5. This verifies the fixed reference allows convergence.
+    """
+    import numpy as np
+
+    np.random.seed(42)  # Reproducible test
+    n_matches = 1500
+    n_players_per_team = 5
+    n_teams = 2
+
+    # Target mean intentionally NOT 0.5 to test convergence
+    target_mean = 0.48
+
+    data = {
+        "pid": [],
+        "tid": [],
+        "mid": [],
+        "dt": [],
+        "perf": [],
+        "pw": [],
+    }
+
+    match_id = 0
+    for i in range(n_matches // 2):
+        date = datetime(2019, 1, 1) + timedelta(days=i * 2)
+        date_str = date.strftime("%Y-%m-%d")
+
+        # Generate performance data already in [0,1] with mean at target
+        # Small std to keep values tightly around target mean
+        for team_idx in range(n_teams):
+            team_id = f"T{team_idx + 1}"
+            for player_idx in range(n_players_per_team):
+                player_id = f"P{team_idx}_{player_idx}"
+                # Draw from normal distribution, clip to [0,1]
+                perf = np.random.normal(target_mean, 0.08)
+                perf = max(0.0, min(1.0, perf))
+
+                data["pid"].append(player_id)
+                data["tid"].append(team_id)
+                data["mid"].append(f"M{match_id}")
+                data["dt"].append(date_str)
+                data["perf"].append(perf)
+                data["pw"].append(1.0)
+
+        match_id += 1
+
+    df = pl.DataFrame(data)
+
+    # Verify input data has mean ≠ 0.5 (before any scaling)
+    input_mean = sum(data["perf"]) / len(data["perf"])
+    assert abs(input_mean - target_mean) < 0.01, f"Input data mean should be ~{target_mean}"
+
+    # Use ignore_opponent predictor with fixed reference
+    # CRITICAL: auto_scale_performance=False to preserve the input mean
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        performance_predictor="ignore_opponent",
+        auto_scale_performance=False,  # Keep input mean at 0.48
+        start_harcoded_start_rating=1000.0,
+        rating_change_multiplier_offense=100,  # Faster convergence for test
+        rating_change_multiplier_defense=100,
+        non_predictor_features_out=[RatingUnknownFeatures.PLAYER_PREDICTED_PERFORMANCE],
+    )
+
+    result = gen.fit_transform(df)
+
+    # Check tail (after convergence period)
+    tail_start_match = (n_matches // 2) - 200
+    tail_df = result.filter(
+        pl.col("mid").cast(pl.Utf8).str.extract(r"M(\d+)", 1).cast(pl.Int32) >= tail_start_match
+    )
+
+    tail_actual = tail_df["perf"].to_list()
+    tail_preds = tail_df["player_predicted_performance_perf"].to_list()
+
+    mean_actual = sum(tail_actual) / len(tail_actual)
+    mean_pred = sum(tail_preds) / len(tail_preds)
+
+    # With fixed reference, predictions should converge close to actual mean
+    deviation = abs(mean_pred - mean_actual)
+    assert deviation < 0.015, (
+        f"Mean predicted performance {mean_pred:.4f} deviates from "
+        f"actual mean {mean_actual:.4f} by {deviation:.4f}. "
+        f"With fixed reference, predictions should converge to actual performance mean."
+    )
+
+    # Verify we're not stuck at 0.5 (the original rolling average bug)
+    assert abs(mean_pred - 0.5) > 0.01, (
+        f"Mean predicted performance {mean_pred:.4f} is too close to 0.5. "
+        f"System appears stuck at sigmoid midpoint (original rolling average bug)."
+    )
+
+
+def test_fit_transform_ignore_opponent_with_autoscale_and_temporal_drift(base_cn):
+    """
+    Test that fixed reference works with auto_scale_performance=True and temporal drift.
+
+    With balanced data (overall mean=0.5) and temporal drift (early=0.505, late=0.495):
+    - Auto_scale preserves overall mean at 0.5
+    - Predictions track the SCALED values (not raw 0.505/0.495)
+    - Drift is preserved (early predictions > late predictions)
+    """
+    import numpy as np
+
+    np.random.seed(42)
+    n_matches = 1000
+    n_players_per_team = 5
+
+    data = {
+        "pid": [],
+        "tid": [],
+        "mid": [],
+        "dt": [],
+        "perf": [],
+        "pw": [],
+    }
+
+    match_id = 0
+    for i in range(n_matches // 2):
+        date = datetime(2019, 1, 1) + timedelta(days=i * 2)
+        date_str = date.strftime("%Y-%m-%d")
+
+        # Temporal drift: 0.505 -> 0.495 (overall mean = 0.5)
+        progress = i / (n_matches // 2)
+        period_mean = 0.505 - (0.01 * progress)
+
+        for team_idx in range(2):
+            team_id = f"T{team_idx + 1}"
+            for player_idx in range(n_players_per_team):
+                player_id = f"P{team_idx}_{player_idx}"
+                # Add variance around period mean
+                perf = np.random.normal(period_mean, 0.03)
+                perf = max(0.0, min(1.0, perf))
+
+                data["pid"].append(player_id)
+                data["tid"].append(team_id)
+                data["mid"].append(f"M{match_id}")
+                data["dt"].append(date_str)
+                data["perf"].append(perf)
+                data["pw"].append(1.0)
+
+        match_id += 1
+
+    df = pl.DataFrame(data)
+
+    # Verify raw data is balanced
+    raw_mean = sum(data["perf"]) / len(data["perf"])
+    assert abs(raw_mean - 0.5) < 0.01, f"Raw data should have mean ≈ 0.5, got {raw_mean}"
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        performance_predictor="ignore_opponent",
+        auto_scale_performance=True,  # ← Key: with auto_scale
+        start_harcoded_start_rating=1000.0,
+        rating_change_multiplier_offense=100,
+        rating_change_multiplier_defense=100,
+        non_predictor_features_out=[RatingUnknownFeatures.PLAYER_PREDICTED_PERFORMANCE],
+    )
+
+    result = gen.fit_transform(df)
+
+    # Check that auto_scale created the performance column
+    assert "performance__perf" in result.columns
+
+    # Get overall scaled mean
+    all_scaled = result["performance__perf"].to_list()
+    overall_scaled_mean = sum(all_scaled) / len(all_scaled)
+
+    # Verify overall scaled mean ≈ 0.5 (auto_scale preserves balance)
+    assert abs(overall_scaled_mean - 0.5) < 0.01, (
+        f"Auto_scale should preserve overall mean at 0.5, got {overall_scaled_mean}"
+    )
+
+    # Get early and late periods
+    early_df = result.filter(
+        pl.col("mid").cast(pl.Utf8).str.extract(r"M(\d+)", 1).cast(pl.Int32) < 100
+    )
+    late_df = result.filter(
+        pl.col("mid").cast(pl.Utf8).str.extract(r"M(\d+)", 1).cast(pl.Int32) >= (n_matches//2 - 100)
+    )
+
+    early_actual_scaled = early_df["performance__perf"].to_list()
+    early_preds = early_df["player_predicted_performance_perf"].to_list()
+    late_actual_scaled = late_df["performance__perf"].to_list()
+    late_preds = late_df["player_predicted_performance_perf"].to_list()
+
+    early_actual_mean = sum(early_actual_scaled) / len(early_actual_scaled)
+    early_pred_mean = sum(early_preds) / len(early_preds)
+    late_actual_mean = sum(late_actual_scaled) / len(late_actual_scaled)
+    late_pred_mean = sum(late_preds) / len(late_preds)
+
+    # Verify drift is preserved after scaling (strict bounds based on 0.505→0.495 drift)
+    assert early_actual_mean > 0.51, (
+        f"Early period should be > 0.51 after scaling, got {early_actual_mean:.4f}"
+    )
+    assert late_actual_mean < 0.49, (
+        f"Late period should be < 0.49 after scaling, got {late_actual_mean:.4f}"
+    )
+
+    # Verify drift magnitude is significant
+    drift_magnitude = early_actual_mean - late_actual_mean
+    assert drift_magnitude > 0.02, (
+        f"Drift magnitude should be > 0.02, got {drift_magnitude:.4f}"
+    )
+
+    # Verify predictions track the SCALED values (not raw 0.505/0.495)
+    # Tolerance: 0.025 accounts for convergence lag with temporal drift
+    early_deviation = abs(early_pred_mean - early_actual_mean)
+    late_deviation = abs(late_pred_mean - late_actual_mean)
+
+    assert early_deviation < 0.025, (
+        f"Early predictions should converge to scaled actual ({early_actual_mean:.4f}), "
+        f"got {early_pred_mean:.4f}, deviation={early_deviation:.4f}"
+    )
+    assert late_deviation < 0.025, (
+        f"Late predictions should converge to scaled actual ({late_actual_mean:.4f}), "
+        f"got {late_pred_mean:.4f}, deviation={late_deviation:.4f}"
+    )
+
+    # Verify drift is tracked in predictions
+    assert early_pred_mean > late_pred_mean, (
+        f"Predictions should track temporal drift: early ({early_pred_mean:.4f}) > late ({late_pred_mean:.4f})"
+    )
+
+
+def test_ignore_opponent_predictor_reference_rating_set_correctly(base_cn):
+    """
+    Test that PlayerRatingNonOpponentPerformancePredictor._reference_rating
+    is set correctly from start rating parameters.
+    """
+    # Test 1: With hardcoded start rating
+    gen1 = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        performance_predictor="ignore_opponent",
+        auto_scale_performance=True,
+        start_harcoded_start_rating=1100.0,
+    )
+    assert gen1._performance_predictor._reference_rating == 1100.0, (
+        f"Expected reference rating 1100.0, got {gen1._performance_predictor._reference_rating}"
+    )
+
+    # Test 2: Without hardcoded start (should default to 1000)
+    gen2 = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        performance_predictor="ignore_opponent",
+        auto_scale_performance=True,
+    )
+    assert gen2._performance_predictor._reference_rating == 1000.0, (
+        f"Expected reference rating 1000.0, got {gen2._performance_predictor._reference_rating}"
+    )
+
+    # Test 3: With league ratings (single league)
+    gen3 = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        performance_predictor="ignore_opponent",
+        auto_scale_performance=True,
+        start_league_ratings={"NBA": 1150},
+    )
+    assert gen3._performance_predictor._reference_rating == 1150.0, (
+        f"Expected reference rating 1150.0, got {gen3._performance_predictor._reference_rating}"
+    )
+
+    # Test 4: With multiple league ratings (should use mean)
+    gen4 = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        performance_predictor="ignore_opponent",
+        auto_scale_performance=True,
+        start_league_ratings={"NBA": 1100, "G-League": 900, "EuroLeague": 1000},
+    )
+    expected_mean = (1100 + 900 + 1000) / 3
+    assert gen4._performance_predictor._reference_rating == expected_mean, (
+        f"Expected reference rating {expected_mean}, got {gen4._performance_predictor._reference_rating}"
+    )
+
+    # Test 5: Hardcoded start rating takes precedence over league ratings
+    gen5 = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,
+        performance_predictor="ignore_opponent",
+        auto_scale_performance=True,
+        start_harcoded_start_rating=1200.0,
+        start_league_ratings={"NBA": 1100},
+    )
+    assert gen5._performance_predictor._reference_rating == 1200.0, (
+        f"Expected hardcoded start rating 1200.0 to take precedence, got {gen5._performance_predictor._reference_rating}"
+    )

tests/scorer/test_scorer_name.py

@@ -0,0 +1,292 @@
+import pytest
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+
+from spforge.scorer import (
+    Filter,
+    MeanBiasScorer,
+    Operator,
+    OrdinalLossScorer,
+    SklearnScorer,
+)
+from spforge.scorer._score import (
+    PWMSE,
+    ProbabilisticMeanBias,
+    ThresholdEventScorer,
+)
+
+
+class TestScorerNameProperty:
+    """Test the auto-generated name property for all scorers."""
+
+    def test_simple_mean_bias_scorer(self):
+        scorer = MeanBiasScorer(target="points", pred_column="pred")
+        assert scorer.name == "mean_bias_scorer_points"
+
+    def test_simple_pwmse(self):
+        scorer = PWMSE(target="goals", pred_column="pred", labels=list(range(10)))
+        assert scorer.name == "pwmse_goals"
+
+    def test_simple_ordinal_loss(self):
+        scorer = OrdinalLossScorer(target="points", pred_column="pred", classes=list(range(0, 41)))
+        assert scorer.name == "ordinal_loss_scorer_points"
+
+    def test_simple_sklearn_scorer(self):
+        scorer = SklearnScorer(target="yards", pred_column="pred", scorer_function=mean_absolute_error)
+        assert scorer.name == "mean_absolute_error_yards"
+
+    def test_simple_probabilistic_mean_bias(self):
+        scorer = ProbabilisticMeanBias(target="points", pred_column="pred")
+        assert scorer.name == "probabilistic_mean_bias_points"
+
+    def test_simple_threshold_event_scorer(self):
+        scorer = ThresholdEventScorer(
+            dist_column="dist",
+            threshold_column="threshold",
+            outcome_column="outcome",
+            labels=list(range(10))
+        )
+        assert scorer.name == "threshold_event_scorer___event__"
+
+    def test_with_single_granularity(self):
+        scorer = MeanBiasScorer(target="points", pred_column="pred", granularity=["team_id"])
+        assert scorer.name == "mean_bias_scorer_points_gran:team_id"
+
+    def test_with_multiple_granularity(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            granularity=["game_id", "team_id"]
+        )
+        assert scorer.name == "mean_bias_scorer_points_gran:game_id+team_id"
+
+    def test_with_long_granularity_abbreviated(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            granularity=["col1", "col2", "col3", "col4", "col5"]
+        )
+        assert scorer.name == "mean_bias_scorer_points_gran:col1+col2+col3+2more"
+
+    def test_with_naive_comparison_no_granularity(self):
+        scorer = SklearnScorer(
+            target="goals",
+            pred_column="pred",
+            scorer_function=mean_absolute_error,
+            compare_to_naive=True
+        )
+        assert scorer.name == "mean_absolute_error_goals_naive"
+
+    def test_with_naive_comparison_with_naive_granularity(self):
+        scorer = MeanBiasScorer(
+            target="yards",
+            pred_column="pred",
+            compare_to_naive=True,
+            naive_granularity=["season"]
+        )
+        assert scorer.name == "mean_bias_scorer_yards_naive:season"
+
+    def test_with_aggregation_level(self):
+        scorer = MeanBiasScorer(
+            target="yards",
+            pred_column="pred",
+            aggregation_level=["game_id", "player_id"]
+        )
+        assert scorer.name == "mean_bias_scorer_yards_agg:game_id+player_id"
+
+    def test_with_user_filters_only(self):
+        scorer = MeanBiasScorer(
+            target="yards",
+            pred_column="pred",
+            filters=[
+                Filter("minutes", 0, Operator.GREATER_THAN),
+                Filter("position", "QB", Operator.EQUALS)
+            ]
+        )
+        assert scorer.name == "mean_bias_scorer_yards_filters:2"
+
+    def test_validation_column_not_counted_in_filters(self):
+        scorer = MeanBiasScorer(
+            target="yards",
+            pred_column="pred",
+            validation_column="is_valid",
+            filters=[Filter("minutes", 0, Operator.GREATER_THAN)]
+        )
+        # Should only count the minutes filter, not the auto-added validation filter
+        assert scorer.name == "mean_bias_scorer_yards_filters:1"
+
+    def test_validation_column_alone_not_shown(self):
+        scorer = MeanBiasScorer(
+            target="yards",
+            pred_column="pred",
+            validation_column="is_valid"
+        )
+        # Validation filter auto-added but not counted
+        assert scorer.name == "mean_bias_scorer_yards"
+
+    def test_complex_configuration_all_components(self):
+        scorer = MeanBiasScorer(
+            target="yards",
+            pred_column="pred",
+            granularity=["game_id", "team_id"],
+            compare_to_naive=True,
+            naive_granularity=["season"],
+            aggregation_level=["game_id", "player_id"],
+            filters=[Filter("minutes", 0, Operator.GREATER_THAN)]
+        )
+        assert scorer.name == "mean_bias_scorer_yards_gran:game_id+team_id_naive:season_agg:game_id+player_id_filters:1"
+
+    def test_sklearn_with_different_function(self):
+        scorer = SklearnScorer(
+            target="points",
+            pred_column="pred",
+            scorer_function=mean_squared_error
+        )
+        assert scorer.name == "mean_squared_error_points"
+
+    def test_sklearn_with_lambda_fallback(self):
+        scorer = SklearnScorer(
+            target="points",
+            pred_column="pred",
+            scorer_function=lambda y_true, y_pred: 0.0
+        )
+        assert scorer.name == "custom_metric_points"
+
+    def test_special_characters_sanitized(self):
+        scorer = MeanBiasScorer(target="points-per-game", pred_column="pred")
+        assert scorer.name == "mean_bias_scorer_points_per_game"
+
+    def test_special_characters_in_target_sanitized(self):
+        scorer = MeanBiasScorer(target="pass/run_ratio", pred_column="pred")
+        assert scorer.name == "mean_bias_scorer_pass_run_ratio"
+
+    def test_name_override(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            granularity=["team_id"],
+            _name_override="custom_name"
+        )
+        assert scorer.name == "custom_name"
+
+    def test_consistency_across_repeated_calls(self):
+        scorer = MeanBiasScorer(
+            target="yards",
+            pred_column="pred",
+            granularity=["game_id"],
+            compare_to_naive=True
+        )
+        name1 = scorer.name
+        name2 = scorer.name
+        name3 = scorer.name
+        assert name1 == name2 == name3
+
+    def test_different_scorers_different_names(self):
+        scorer1 = MeanBiasScorer(target="points", pred_column="pred")
+        scorer2 = PWMSE(target="points", pred_column="pred", labels=list(range(10)))
+        assert scorer1.name != scorer2.name
+
+    def test_same_config_same_name(self):
+        scorer1 = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            granularity=["team_id"]
+        )
+        scorer2 = MeanBiasScorer(
+            target="points",
+            pred_column="pred_2",  # Different pred column shouldn't affect name
+            granularity=["team_id"]
+        )
+        assert scorer1.name == scorer2.name
+
+    def test_none_granularity_excluded(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            granularity=None
+        )
+        assert "gran:" not in scorer.name
+        assert scorer.name == "mean_bias_scorer_points"
+
+    def test_empty_filters_excluded(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            filters=[]
+        )
+        assert "filters:" not in scorer.name
+        assert scorer.name == "mean_bias_scorer_points"
+
+    def test_none_aggregation_level_excluded(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            aggregation_level=None
+        )
+        assert "agg:" not in scorer.name
+        assert scorer.name == "mean_bias_scorer_points"
+
+    def test_pwmse_with_all_components(self):
+        scorer = PWMSE(
+            target="goals",
+            pred_column="pred",
+            labels=list(range(10)),
+            granularity=["team_id"],
+            compare_to_naive=True,
+            naive_granularity=["season"],
+            aggregation_level=["game_id"],
+            filters=[Filter("minutes", 20, Operator.GREATER_THAN)]
+        )
+        assert scorer.name == "pwmse_goals_gran:team_id_naive:season_agg:game_id_filters:1"
+
+    def test_ordinal_loss_with_granularity(self):
+        scorer = OrdinalLossScorer(
+            target="points",
+            pred_column="pred",
+            classes=list(range(0, 41)),
+            granularity=["game_id"]
+        )
+        assert scorer.name == "ordinal_loss_scorer_points_gran:game_id"
+
+    def test_threshold_event_scorer_with_components(self):
+        scorer = ThresholdEventScorer(
+            dist_column="dist",
+            threshold_column="threshold",
+            outcome_column="outcome",
+            labels=list(range(10)),
+            granularity=["game_id"],
+            compare_to_naive=True
+        )
+        assert scorer.name == "threshold_event_scorer___event___gran:game_id_naive"
+
+    def test_long_aggregation_abbreviated(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            aggregation_level=["a", "b", "c", "d", "e"]
+        )
+        assert scorer.name == "mean_bias_scorer_points_agg:a+b+c+2more"
+
+    def test_long_naive_granularity_abbreviated(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            compare_to_naive=True,
+            naive_granularity=["a", "b", "c", "d"]
+        )
+        assert scorer.name == "mean_bias_scorer_points_naive:a+b+c+1more"
+
+    def test_exactly_three_columns_no_abbreviation(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            granularity=["a", "b", "c"]
+        )
+        assert scorer.name == "mean_bias_scorer_points_gran:a+b+c"
+
+    def test_four_columns_abbreviated(self):
+        scorer = MeanBiasScorer(
+            target="points",
+            pred_column="pred",
+            granularity=["a", "b", "c", "d"]
+        )
+        assert scorer.name == "mean_bias_scorer_points_gran:a+b+c+1more"