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

spforge/autopipeline.py

@@ -195,6 +195,40 @@ def lgbm_in_root(root) -> bool:
     return any(_is_lightgbm_estimator(obj) for obj in _walk_objects(root))
 
 
+def _get_importance_estimator(estimator) -> tuple[Any, str] | None:
+    """Recursively find innermost estimator with feature_importances_ or coef_."""
+    if hasattr(estimator, "feature_importances_"):
+        inner = _get_importance_estimator_inner(estimator)
+        if inner is not None:
+            return inner
+        return (estimator, "feature_importances_")
+
+    if hasattr(estimator, "coef_"):
+        inner = _get_importance_estimator_inner(estimator)
+        if inner is not None:
+            return inner
+        return (estimator, "coef_")
+
+    return _get_importance_estimator_inner(estimator)
+
+
+def _get_importance_estimator_inner(estimator) -> tuple[Any, str] | None:
+    """Check wrapped estimators for importance attributes."""
+    # Check estimator_ (sklearn fitted wrapper convention)
+    if hasattr(estimator, "estimator_") and estimator.estimator_ is not None:
+        result = _get_importance_estimator(estimator.estimator_)
+        if result is not None:
+            return result
+
+    # Check _est (GroupByEstimator convention)
+    if hasattr(estimator, "_est") and estimator._est is not None:
+        result = _get_importance_estimator(estimator._est)
+        if result is not None:
+            return result
+
+    return None
+
+
 class AutoPipeline(BaseEstimator):
     def __init__(
         self,
@@ -202,6 +236,7 @@ class AutoPipeline(BaseEstimator):
         estimator_features: list[str],
         predictor_transformers: list[PredictorTransformer] | None = None,
         granularity: list[str] | None = None,
+        aggregation_weight: str | None = None,
         filters: list[Filter] | None = None,
         scale_features: bool = False,
         categorical_handling: CategoricalHandling = "auto",
@@ -216,6 +251,7 @@ class AutoPipeline(BaseEstimator):
         self.estimator_features = estimator_features
         self.feature_names = estimator_features  # Internal compat
         self.granularity = granularity or []
+        self.aggregation_weight = aggregation_weight
         self.predictor_transformers = predictor_transformers
         self.estimator = estimator
         self.filters = filters or []
@@ -230,6 +266,7 @@ class AutoPipeline(BaseEstimator):
         self.numeric_features = numeric_features
         self.remainder = remainder
         self._cat_feats = []
+        self._filter_feature_names: list[str] = []
 
         # Auto-compute context features
         self.context_feature_names = self._compute_context_features()
@@ -242,11 +279,12 @@ class AutoPipeline(BaseEstimator):
         self._resolved_categorical_handling: CategoricalHandling | None = None
 
     def _compute_context_features(self) -> list[str]:
-        """Auto-compute context features from estimator, granularity, and filters.
+        """Auto-compute context features from estimator and granularity.
 
         Note: Context from predictor_transformers is tracked separately in
         context_predictor_transformer_feature_names and is dropped before
-        the final estimator.
+        the final estimator. Filter columns are tracked separately and are
+        dropped before the final estimator.
         """
         from spforge.transformers._base import PredictorTransformer
 
@@ -290,9 +328,15 @@ class AutoPipeline(BaseEstimator):
         # Add granularity columns
         context.extend(self.granularity)
 
+        # Add aggregation weight column
+        if self.aggregation_weight:
+            context.append(self.aggregation_weight)
+
         # Add filter columns
+        self._filter_feature_names = []
         for f in self.filters:
-            context.append(f.column_name)
+            if f.column_name not in self._filter_feature_names:
+                self._filter_feature_names.append(f.column_name)
 
         # Dedupe while preserving order, excluding estimator_features
         seen = set()
@@ -454,7 +498,11 @@ class AutoPipeline(BaseEstimator):
         pre = PreprocessorToDataFrame(pre_raw)
 
         est = (
-            GroupByEstimator(self.estimator, granularity=[f"{c}" for c in self.granularity])
+            GroupByEstimator(
+                self.estimator,
+                granularity=[f"{c}" for c in self.granularity],
+                aggregation_weight=self.aggregation_weight,
+            )
             if do_groupby
             else self.estimator
         )
@@ -506,8 +554,10 @@ class AutoPipeline(BaseEstimator):
             prev_transformer_feats_out.extend(feats_out)
 
         # Use FunctionTransformer with global function for serializability
+        drop_filter_cols = set(self._filter_feature_names)
+        drop_cols = drop_ctx_set | drop_filter_cols
         final = FunctionTransformer(
-            _drop_columns_transformer, validate=False, kw_args={"drop_cols": drop_ctx_set}
+            _drop_columns_transformer, validate=False, kw_args={"drop_cols": drop_cols}
         )
         steps.append(("final", final))
 
@@ -538,6 +588,7 @@ class AutoPipeline(BaseEstimator):
                 self.feature_names
                 + self.context_feature_names
                 + self.context_predictor_transformer_feature_names
+                + self._filter_feature_names
                 + self.granularity
             )
         )
@@ -626,4 +677,117 @@ class AutoPipeline(BaseEstimator):
             if ctx not in all_features:
                 all_features.append(ctx)
 
+        # Add filter columns (needed for fit-time filtering)
+        for col in self._filter_feature_names:
+            if col not in all_features:
+                all_features.append(col)
+
         return all_features
+
+    def _get_estimator_feature_names(self) -> list[str]:
+        """Get feature names as seen by the final estimator after all transformations."""
+        pre_out = list(self.sklearn_pipeline.named_steps["pre"].get_feature_names_out())
+
+        # Remove context columns dropped by "final" step
+        final_step = self.sklearn_pipeline.named_steps["final"]
+        drop_cols = final_step.kw_args.get("drop_cols", set()) if final_step.kw_args else set()
+        features = [f for f in pre_out if f not in drop_cols]
+
+        # Remove granularity columns (dropped by GroupByEstimator)
+        granularity_set = set(self.granularity)
+        features = [f for f in features if f not in granularity_set]
+
+        # Remove context features (used by wrapper estimators, not inner model)
+        context_set = set(self.context_feature_names)
+        features = [f for f in features if f not in context_set]
+
+        # Remove filter columns (used only for fit-time filtering)
+        filter_set = set(self._filter_feature_names)
+        features = [f for f in features if f not in filter_set]
+
+        return features
+
+    def _resolve_importance_feature_names(self, estimator, n_features: int) -> list[str]:
+        names = None
+        if hasattr(estimator, "feature_names_in_") and estimator.feature_names_in_ is not None:
+            names = list(estimator.feature_names_in_)
+        elif hasattr(estimator, "feature_name_") and estimator.feature_name_ is not None:
+            names = list(estimator.feature_name_)
+        elif hasattr(estimator, "feature_names_") and estimator.feature_names_ is not None:
+            names = list(estimator.feature_names_)
+        if names is None:
+            names = self._get_estimator_feature_names()
+        if len(names) != n_features:
+            raise ValueError(
+                f"Feature names length ({len(names)}) does not match importances length ({n_features})."
+            )
+        return names
+
+    @property
+    def feature_importances_(self) -> pd.DataFrame:
+        """Get feature importances from the fitted estimator.
+
+        Returns a DataFrame with columns ["feature", "importance"] sorted by
+        absolute importance descending. Works with tree-based models
+        (feature_importances_) and linear models (coef_).
+        """
+        if self.sklearn_pipeline is None:
+            raise RuntimeError("Pipeline not fitted. Call fit() first.")
+
+        est = self.sklearn_pipeline.named_steps["est"]
+        result = _get_importance_estimator(est)
+
+        if result is None:
+            raise RuntimeError(
+                "Estimator does not support feature importances. "
+                "Requires feature_importances_ or coef_ attribute."
+            )
+
+        inner_est, attr_name = result
+        raw = getattr(inner_est, attr_name)
+
+        if attr_name == "coef_":
+            # Linear models: use absolute value of coefficients
+            if raw.ndim == 2:
+                # Multi-class: average absolute values across classes
+                importances = np.abs(raw).mean(axis=0)
+            else:
+                importances = np.abs(raw)
+        else:
+            importances = raw
+
+        feature_names = self._get_estimator_feature_names()
+
+        df = pd.DataFrame({"feature": feature_names, "importance": importances})
+        df = df.sort_values("importance", ascending=False, key=abs).reset_index(drop=True)
+        return df
+
+    @property
+    def feature_importance_names(self) -> dict[str, float]:
+        """Map deepest estimator feature names to importances."""
+        if self.sklearn_pipeline is None:
+            raise RuntimeError("Pipeline not fitted. Call fit() first.")
+
+        est = self.sklearn_pipeline.named_steps["est"]
+        result = _get_importance_estimator(est)
+
+        if result is None:
+            raise RuntimeError(
+                "Estimator does not support feature importances. "
+                "Requires feature_importances_ or coef_ attribute."
+            )
+
+        inner_est, attr_name = result
+        raw = getattr(inner_est, attr_name)
+
+        if attr_name == "coef_":
+            if raw.ndim == 2:
+                importances = np.abs(raw).mean(axis=0)
+            else:
+                importances = np.abs(raw)
+        else:
+            importances = raw
+
+        importances = np.asarray(importances)
+        feature_names = self._resolve_importance_feature_names(inner_est, len(importances))
+        return dict(zip(feature_names, importances.tolist()))

spforge/estimator/_group_by_estimator.py

@@ -10,10 +10,16 @@ from spforge.transformers._other_transformer import GroupByReducer
 
 
 class GroupByEstimator(BaseEstimator):
-    def __init__(self, estimator: Any, granularity: list[str] | None = None):
+    def __init__(
+        self,
+        estimator: Any,
+        granularity: list[str] | None = None,
+        aggregation_weight: str | None = None,
+    ):
         self.estimator = estimator
         self.granularity = granularity or []
-        self._reducer = GroupByReducer(self.granularity)
+        self.aggregation_weight = aggregation_weight
+        self._reducer = GroupByReducer(self.granularity, aggregation_weight=aggregation_weight)
         self._est = None
 
     def __sklearn_is_fitted__(self):
@@ -22,7 +28,9 @@ class GroupByEstimator(BaseEstimator):
     @nw.narwhalify
     def fit(self, X: IntoFrameT, y: Any, sample_weight: np.ndarray | None = None):
         X = X.to_pandas()
-        self._reducer = GroupByReducer(self.granularity)
+        # Backwards compatibility: old pickled objects may not have aggregation_weight
+        agg_weight = getattr(self, "aggregation_weight", None)
+        self._reducer = GroupByReducer(self.granularity, aggregation_weight=agg_weight)
         X_red = nw.from_native(self._reducer.fit_transform(X))
         y_red, sw_red = self._reducer.reduce_y(X, y, sample_weight=sample_weight)
 

spforge/performance_transformers/_performance_manager.py

@@ -250,8 +250,6 @@ class PerformanceWeightsManager(PerformanceManager):
                 )
             )
 
-        sum_weight = sum([w.weight for w in self.weights])
-
         for column_weight in self.weights:
             weight_col = f"weight__{column_weight.name}"
             feature_col = column_weight.name
@@ -261,14 +259,14 @@ class PerformanceWeightsManager(PerformanceManager):
                 df = df.with_columns(
                     (
                         nw.col(tmp_out_performance_colum_name)
-                        + (nw.col(weight_col) / sum_weight * (1 - nw.col(feature_name)))
+                        + (nw.col(weight_col) * (1 - nw.col(feature_name)))
                     ).alias(tmp_out_performance_colum_name)
                 )
             else:
                 df = df.with_columns(
                     (
                         nw.col(tmp_out_performance_colum_name)
-                        + (nw.col(weight_col) / sum_weight * nw.col(feature_name))
+                        + (nw.col(weight_col) * nw.col(feature_name))
                     ).alias(tmp_out_performance_colum_name)
                 )
 

spforge/ratings/_player_rating.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 
 import copy
 import math
+import logging
 from typing import Any, Literal
 
 import narwhals.stable.v2 as nw
@@ -15,6 +16,7 @@ from spforge.data_structures import (
     MatchPerformance,
     MatchPlayer,
     PlayerRating,
+    PlayerRatingChange,
     PlayerRatingsResult,
     PreMatchPlayerRating,
     PreMatchPlayersCollection,
@@ -33,6 +35,8 @@ from spforge.ratings.utils import (
 from spforge.feature_generator._utils import to_polars
 
 PLAYER_STATS = "__PLAYER_STATS"
+_SCALED_PW = "__scaled_participation_weight__"
+_SCALED_PPW = "__scaled_projected_participation_weight__"
 
 
 class PlayerRatingGenerator(RatingGenerator):
@@ -75,12 +79,13 @@ class PlayerRatingGenerator(RatingGenerator):
         start_min_count_for_percentiles: int = 50,
         start_team_rating_subtract: float = 80,
         start_team_weight: float = 0,
-        start_max_days_ago_league_entities: int = 120,
+        start_max_days_ago_league_entities: int = 600,
         start_min_match_count_team_rating: int = 2,
         start_harcoded_start_rating: float | None = None,
         column_names: ColumnNames | None = None,
         output_suffix: str | None = None,
         scale_participation_weights: bool = False,
+        auto_scale_participation_weights: bool = True,
         **kwargs: Any,
     ):
         super().__init__(
@@ -164,6 +169,7 @@ class PlayerRatingGenerator(RatingGenerator):
 
         self.use_off_def_split = bool(use_off_def_split)
         self.scale_participation_weights = bool(scale_participation_weights)
+        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
 
@@ -189,9 +195,39 @@ class PlayerRatingGenerator(RatingGenerator):
         column_names: ColumnNames | None = None,
     ) -> DataFrame | IntoFrameT:
         self.column_names = column_names if column_names else self.column_names
+        self._maybe_enable_participation_weight_scaling(df)
         self._set_participation_weight_max(df)
         return super().fit_transform(df, column_names)
 
+    def _maybe_enable_participation_weight_scaling(self, df: DataFrame) -> None:
+        if self.scale_participation_weights or not self.auto_scale_participation_weights:
+            return
+        cn = self.column_names
+        if not cn:
+            return
+
+        pl_df = df.to_native() if df.implementation.is_polars() else df.to_polars().to_native()
+
+        def _out_of_bounds(col_name: str | None) -> bool:
+            if not col_name or col_name not in df.columns:
+                return False
+            col = pl_df[col_name]
+            min_val = col.min()
+            max_val = col.max()
+            if min_val is None or max_val is None:
+                return False
+            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
+        ):
+            self.scale_participation_weights = True
+            logging.warning(
+                "Auto-scaling participation weights because values exceed [0, 1]. "
+                "Set scale_participation_weights=True explicitly to silence this warning."
+            )
+
     def _ensure_player_off(self, player_id: str) -> PlayerRating:
         if player_id not in self._player_off_ratings:
             # create with start generator later; initialize to 0 now; overwritten when needed
@@ -240,6 +276,7 @@ class PlayerRatingGenerator(RatingGenerator):
             self._projected_participation_weight_max = self._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:
             return df
         if self._participation_weight_max is None or self._participation_weight_max <= 0:
@@ -254,7 +291,7 @@ class PlayerRatingGenerator(RatingGenerator):
             df = df.with_columns(
                 (pl.col(cn.participation_weight) / denom)
                 .clip(0.0, 1.0)
-                .alias(cn.participation_weight)
+                .alias(_SCALED_PW)
             )
 
         if (
@@ -267,16 +304,38 @@ class PlayerRatingGenerator(RatingGenerator):
             df = df.with_columns(
                 (pl.col(cn.projected_participation_weight) / denom)
                 .clip(0.0, 1.0)
-                .alias(cn.projected_participation_weight)
+                .alias(_SCALED_PPW)
             )
 
         return df
 
+    def _get_participation_weight_col(self) -> str:
+        """Get the column name to use for participation weight (scaled if available)."""
+        cn = self.column_names
+        if self.scale_participation_weights and cn and cn.participation_weight:
+            return _SCALED_PW
+        return cn.participation_weight if cn else ""
+
+    def _get_projected_participation_weight_col(self) -> str:
+        """Get the column name to use for projected participation weight (scaled if available)."""
+        cn = self.column_names
+        if self.scale_participation_weights and cn and cn.projected_participation_weight:
+            return _SCALED_PPW
+        return cn.projected_participation_weight if cn else ""
+
+    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]
+        if cols_to_drop:
+            df = df.drop(cols_to_drop)
+        return df
+
     def _historical_transform(self, df: pl.DataFrame) -> pl.DataFrame:
         df = self._scale_participation_weight_columns(df)
         match_df = self._create_match_df(df)
         ratings = self._calculate_ratings(match_df)
 
+        # Keep scaled columns for now - they're needed by _add_rating_features
         cols = [
             c
             for c in df.columns
@@ -296,13 +355,15 @@ class PlayerRatingGenerator(RatingGenerator):
             on=[self.column_names.player_id, self.column_names.match_id, self.column_names.team_id],
         )
 
-        return self._add_rating_features(df)
+        result = self._add_rating_features(df)
+        return self._remove_internal_scaled_columns(result)
 
     def _future_transform(self, df: pl.DataFrame) -> pl.DataFrame:
         df = self._scale_participation_weight_columns(df)
         match_df = self._create_match_df(df)
         ratings = self._calculate_future_ratings(match_df)
 
+        # Keep scaled columns for now - they're needed by _add_rating_features
         cols = [
             c
             for c in df.columns
@@ -327,7 +388,8 @@ class PlayerRatingGenerator(RatingGenerator):
             how="left",
         )
 
-        return self._add_rating_features(df_with_ratings)
+        result = self._add_rating_features(df_with_ratings)
+        return self._remove_internal_scaled_columns(result)
 
     def _calculate_ratings(self, match_df: pl.DataFrame) -> pl.DataFrame:
         cn = self.column_names
@@ -381,9 +443,9 @@ class PlayerRatingGenerator(RatingGenerator):
             team1_off_rating, team1_def_rating = self._team_off_def_rating_from_collection(c1)
             team2_off_rating, team2_def_rating = self._team_off_def_rating_from_collection(c2)
 
-            player_updates: list[tuple[str, str, float, float, float, float, float, float, int]] = (
-                []
-            )
+            player_updates: list[
+                tuple[str, str, float, float, float, float, float, float, int, str | None]
+            ] = []
 
             for pre_player in c1.pre_match_player_ratings:
                 pid = pre_player.id
@@ -459,6 +521,7 @@ class PlayerRatingGenerator(RatingGenerator):
                         float(off_change),
                         float(def_change),
                         day_number,
+                        pre_player.league,
                     )
                 )
 
@@ -536,6 +599,7 @@ class PlayerRatingGenerator(RatingGenerator):
                         float(off_change),
                         float(def_change),
                         day_number,
+                        pre_player.league,
                     )
                 )
 
@@ -550,6 +614,7 @@ class PlayerRatingGenerator(RatingGenerator):
                 _off_change,
                 _def_change,
                 _dn,
+                _league,
             ) in player_updates:
                 out[cn.player_id].append(pid)
                 out[cn.match_id].append(match_id)
@@ -566,15 +631,18 @@ class PlayerRatingGenerator(RatingGenerator):
             for (
                 pid,
                 team_id,
-                _off_pre,
+                off_pre,
                 _def_pre,
                 _pred_off,
                 _pred_def,
                 off_change,
                 def_change,
                 dn,
+                league,
             ) in player_updates:
-                pending_team_updates.append((pid, team_id, off_change, def_change, dn))
+                pending_team_updates.append(
+                    (pid, team_id, off_pre, off_change, def_change, dn, league)
+                )
 
             if last_update_id is None:
                 last_update_id = update_id
@@ -584,9 +652,11 @@ class PlayerRatingGenerator(RatingGenerator):
 
         return pl.DataFrame(out, strict=False)
 
-    def _apply_player_updates(self, updates: list[tuple[str, str, float, float, int]]) -> None:
+    def _apply_player_updates(
+        self, updates: list[tuple[str, str, float, float, float, int, str | None]]
+    ) -> None:
 
-        for player_id, team_id, off_change, def_change, day_number in updates:
+        for player_id, team_id, pre_rating, off_change, def_change, day_number, league in updates:
             off_state = self._player_off_ratings[player_id]
             off_state.confidence_sum = self._calculate_post_match_confidence_sum(
                 entity_rating=off_state,
@@ -609,6 +679,19 @@ class PlayerRatingGenerator(RatingGenerator):
             def_state.last_match_day_number = int(day_number)
             def_state.most_recent_team_id = team_id
 
+            self.start_rating_generator.update_players_to_leagues(
+                PlayerRatingChange(
+                    id=player_id,
+                    day_number=day_number,
+                    league=league,
+                    participation_weight=1.0,
+                    predicted_performance=0.0,
+                    performance=0.0,
+                    pre_match_rating_value=pre_rating,
+                    rating_change_value=off_change,
+                )
+            )
+
     def _add_rating_features(self, df: pl.DataFrame) -> pl.DataFrame:
         cols_to_add = set((self._features_out or []) + (self.non_predictor_features_out or []))
 
@@ -763,9 +846,13 @@ class PlayerRatingGenerator(RatingGenerator):
 
         if cn.participation_weight and cn.participation_weight in df.columns:
             player_stat_cols.append(cn.participation_weight)
+        if _SCALED_PW in df.columns:
+            player_stat_cols.append(_SCALED_PW)
 
         if cn.projected_participation_weight and cn.projected_participation_weight in df.columns:
             player_stat_cols.append(cn.projected_participation_weight)
+        if _SCALED_PPW in df.columns:
+            player_stat_cols.append(_SCALED_PPW)
 
         if cn.position and cn.position in df.columns:
             player_stat_cols.append(cn.position)
@@ -821,14 +908,23 @@ class PlayerRatingGenerator(RatingGenerator):
             position = team_player.get(cn.position)
             player_league = team_player.get(cn.league, None)
 
-            participation_weight = (
-                team_player.get(cn.participation_weight, 1.0) if cn.participation_weight else 1.0
-            )
-            projected_participation_weight = (
-                team_player.get(cn.projected_participation_weight, participation_weight)
-                if cn.projected_participation_weight
-                else participation_weight
-            )
+            # Use scaled participation weight if available, otherwise use original
+            if _SCALED_PW in team_player:
+                participation_weight = team_player.get(_SCALED_PW, 1.0)
+            elif cn.participation_weight:
+                participation_weight = team_player.get(cn.participation_weight, 1.0)
+            else:
+                participation_weight = 1.0
+
+            # Use scaled projected participation weight if available, otherwise use original
+            if _SCALED_PPW in team_player:
+                projected_participation_weight = team_player.get(_SCALED_PPW, participation_weight)
+            elif cn.projected_participation_weight:
+                projected_participation_weight = team_player.get(
+                    cn.projected_participation_weight, participation_weight
+                )
+            else:
+                projected_participation_weight = participation_weight
             projected_participation_weights.append(projected_participation_weight)
 
             perf_val = (
@@ -1054,14 +1150,21 @@ class PlayerRatingGenerator(RatingGenerator):
                     position = tp.get(cn.position)
                     league = tp.get(cn.league, None)
 
-                    pw = (
-                        tp.get(cn.participation_weight, 1.0) if cn.participation_weight else 1.0
-                    )
-                    ppw = (
-                        tp.get(cn.projected_participation_weight, pw)
-                        if cn.projected_participation_weight
-                        else pw
-                    )
+                    # Use scaled participation weight if available, otherwise use original
+                    if _SCALED_PW in tp:
+                        pw = tp.get(_SCALED_PW, 1.0)
+                    elif cn.participation_weight:
+                        pw = tp.get(cn.participation_weight, 1.0)
+                    else:
+                        pw = 1.0
+
+                    # Use scaled projected participation weight if available, otherwise use original
+                    if _SCALED_PPW in tp:
+                        ppw = tp.get(_SCALED_PPW, pw)
+                    elif cn.projected_participation_weight:
+                        ppw = tp.get(cn.projected_participation_weight, pw)
+                    else:
+                        ppw = pw
                     proj_w.append(float(ppw))
 
                     mp = MatchPerformance(

spforge/ratings/start_rating_generator.py

@@ -28,7 +28,7 @@ class StartRatingGenerator:
         min_count_for_percentiles: int = 50,
         team_rating_subtract: float = 80,
         team_weight: float = 0,
-        max_days_ago_league_entities: int = 120,
+        max_days_ago_league_entities: int = 600,
         min_match_count_team_rating: int = 2,
         harcoded_start_rating: float | None = None,
     ):

spforge/ratings/team_start_rating_generator.py

@@ -24,7 +24,7 @@ class TeamStartRatingGenerator:
         league_ratings: dict[str, float] | None = None,
         league_quantile: float = 0.2,
         min_count_for_percentiles: int = 50,
-        max_days_ago_league_entities: int = 120,
+        max_days_ago_league_entities: int = 600,
         min_match_count_team_rating: int = 2,
         harcoded_start_rating: float | None = None,
     ):