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

spforge/feature_generator/_base.py

@@ -176,6 +176,8 @@ class LagGenerator(FeatureGenerator):
         if additional_cols:
             cols.extend(additional_cols)
 
+        cols = list(dict.fromkeys(cols))
+
         if self._df is None:
             self._df = df.select(cols)
         else:

spforge/ratings/_player_rating.py

@@ -330,7 +330,21 @@ class PlayerRatingGenerator(RatingGenerator):
             df = df.drop(cols_to_drop)
         return df
 
+    def _validate_playing_time_columns(self, df: pl.DataFrame) -> None:
+        cn = self.column_names
+        if cn.team_players_playing_time and cn.team_players_playing_time not in df.columns:
+            raise ValueError(
+                f"team_players_playing_time column '{cn.team_players_playing_time}' "
+                f"not found in DataFrame. Available columns: {list(df.columns)}"
+            )
+        if cn.opponent_players_playing_time and cn.opponent_players_playing_time not in df.columns:
+            raise ValueError(
+                f"opponent_players_playing_time column '{cn.opponent_players_playing_time}' "
+                f"not found in DataFrame. Available columns: {list(df.columns)}"
+            )
+
     def _historical_transform(self, df: pl.DataFrame) -> pl.DataFrame:
+        self._validate_playing_time_columns(df)
         df = self._scale_participation_weight_columns(df)
         match_df = self._create_match_df(df)
         ratings = self._calculate_ratings(match_df)
@@ -359,6 +373,7 @@ class PlayerRatingGenerator(RatingGenerator):
         return self._remove_internal_scaled_columns(result)
 
     def _future_transform(self, df: pl.DataFrame) -> pl.DataFrame:
+        self._validate_playing_time_columns(df)
         df = self._scale_participation_weight_columns(df)
         match_df = self._create_match_df(df)
         ratings = self._calculate_future_ratings(match_df)
@@ -466,10 +481,14 @@ class PlayerRatingGenerator(RatingGenerator):
                 pred_off = self._performance_predictor.predict_performance(
                     player_rating=pre_player,
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=team2_def_rating
+                        id=team2,
+                        players=c2.pre_match_player_ratings,
+                        rating_value=team2_def_rating,
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=team1_off_rating
+                        id=team1,
+                        players=c1.pre_match_player_ratings,
+                        rating_value=team1_off_rating,
                     ),
                 )
 
@@ -484,10 +503,14 @@ class PlayerRatingGenerator(RatingGenerator):
                         other=getattr(pre_player, "other", None),
                     ),
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=team2_off_rating
+                        id=team2,
+                        players=c2.pre_match_player_ratings,
+                        rating_value=team2_off_rating,
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=team1_def_rating
+                        id=team1,
+                        players=c1.pre_match_player_ratings,
+                        rating_value=team1_def_rating,
                     ),
                 )
 
@@ -551,10 +574,14 @@ class PlayerRatingGenerator(RatingGenerator):
                 pred_off = self._performance_predictor.predict_performance(
                     player_rating=pre_player,
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=team1_def_rating
+                        id=team1,
+                        players=c1.pre_match_player_ratings,
+                        rating_value=team1_def_rating,
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=team2_off_rating
+                        id=team2,
+                        players=c2.pre_match_player_ratings,
+                        rating_value=team2_off_rating,
                     ),
                 )
 
@@ -569,10 +596,14 @@ class PlayerRatingGenerator(RatingGenerator):
                         other=getattr(pre_player, "other", None),
                     ),
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=team1_off_rating
+                        id=team1,
+                        players=c1.pre_match_player_ratings,
+                        rating_value=team1_off_rating,
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=team2_def_rating
+                        id=team2,
+                        players=c2.pre_match_player_ratings,
+                        rating_value=team2_def_rating,
                     ),
                 )
 
@@ -881,6 +912,12 @@ 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:
+            player_stat_cols.append(cn.team_players_playing_time)
+
+        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))
 
         group_cols = [cn.match_id, cn.team_id, cn.start_date]
@@ -957,10 +994,24 @@ 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
+
             mp = MatchPerformance(
                 performance_value=perf_val,
                 projected_participation_weight=projected_participation_weight,
                 participation_weight=participation_weight,
+                team_players_playing_time=team_playing_time,
+                opponent_players_playing_time=opponent_playing_time,
             )
 
             if player_id in self._player_off_ratings and player_id in self._player_def_ratings:
@@ -1194,10 +1245,23 @@ 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
+
                     mp = MatchPerformance(
                         performance_value=get_perf_value(tp),
                         projected_participation_weight=ppw,
                         participation_weight=pw,
+                        team_players_playing_time=team_playing_time,
+                        opponent_players_playing_time=opponent_playing_time,
                     )
 
                     ensure_new_player(pid, day_number, mp, league, position, pre_list)  # noqa: B023
@@ -1250,10 +1314,10 @@ class PlayerRatingGenerator(RatingGenerator):
                 pred_off = self._performance_predictor.predict_performance(
                     player_rating=pre,
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=t2_def_rating
+                        id=team2, players=t2_pre, rating_value=t2_def_rating
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=t1_off_rating
+                        id=team1, players=t1_pre, rating_value=t1_off_rating
                     ),
                 )
 
@@ -1267,10 +1331,10 @@ class PlayerRatingGenerator(RatingGenerator):
                         position=pre.position,
                     ),
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=t2_off_rating
+                        id=team2, players=t2_pre, rating_value=t2_off_rating
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=t1_def_rating
+                        id=team1, players=t1_pre, rating_value=t1_def_rating
                     ),
                 )
 
@@ -1295,10 +1359,10 @@ class PlayerRatingGenerator(RatingGenerator):
                 pred_off = self._performance_predictor.predict_performance(
                     player_rating=pre,
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=t1_def_rating
+                        id=team1, players=t1_pre, rating_value=t1_def_rating
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=t2_off_rating
+                        id=team2, players=t2_pre, rating_value=t2_off_rating
                     ),
                 )
 
@@ -1312,10 +1376,10 @@ class PlayerRatingGenerator(RatingGenerator):
                         position=pre.position,
                     ),
                     opponent_team_rating=PreMatchTeamRating(
-                        id=team1, players=[], rating_value=t1_off_rating
+                        id=team1, players=t1_pre, rating_value=t1_off_rating
                     ),
                     team_rating=PreMatchTeamRating(
-                        id=team2, players=[], rating_value=t2_def_rating
+                        id=team2, players=t2_pre, rating_value=t2_def_rating
                     ),
                 )
 

spforge/ratings/player_performance_predictor.py

@@ -133,7 +133,7 @@ class RatingPlayerDifferencePerformancePredictor(PlayerPerformancePredictor):
             team_rating_value = team_rating.rating_value
 
         if player_rating.match_performance.opponent_players_playing_time and isinstance(
-            player_rating.match_performance.team_players_playing_time, dict
+            player_rating.match_performance.opponent_players_playing_time, dict
         ):
             weight_opp_rating = 0
             sum_playing_time = 0

spforge/scorer/_score.py

@@ -263,6 +263,7 @@ class BaseScorer(ABC):
         validation_column: str | None,
         filters: list[Filter] | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
@@ -274,6 +275,7 @@ class BaseScorer(ABC):
             If set, the scorer will be calculated only once the values of the validation column are equal to 1
         :param filters: The filters to apply before calculating
         :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)
         """
         self.target = target
@@ -289,28 +291,59 @@ class BaseScorer(ABC):
                 )
             )
         self.aggregation_level = aggregation_level
+        self.aggregation_method = aggregation_method
         self.granularity = granularity
         self.compare_to_naive = compare_to_naive
         self.naive_granularity = naive_granularity
 
+    def _resolve_aggregation_method(self, key: str) -> Any:
+        if self.aggregation_method is None:
+            return "sum"
+        method = self.aggregation_method.get(key)
+        if method is None:
+            return "sum"
+        return method
+
+    def _build_aggregation_expr(self, df: IntoFrameT, col: str, method: Any) -> Any:
+        if isinstance(method, tuple):
+            if len(method) != 2 or method[0] != "weighted_mean":
+                raise ValueError(f"Unsupported aggregation method for {col}: {method}")
+            weight_col = method[1]
+            if weight_col not in df.columns:
+                raise ValueError(
+                    f"Aggregation weight column '{weight_col}' not found in dataframe columns."
+                )
+            weighted_sum = (nw.col(col) * nw.col(weight_col)).sum()
+            weight_total = nw.col(weight_col).sum()
+            return (weighted_sum / weight_total).alias(col)
+
+        if method == "sum":
+            return nw.col(col).sum().alias(col)
+        if method == "mean":
+            return nw.col(col).mean().alias(col)
+        if method == "first":
+            return nw.col(col).first().alias(col)
+        raise ValueError(f"Unsupported aggregation method for {col}: {method}")
+
     def _apply_aggregation_level(self, df: IntoFrameT) -> IntoFrameT:
         """Apply aggregation_level grouping if set"""
         if self.aggregation_level:
-            # Determine aggregation method based on column types
-            # For numeric columns, use sum; for others, use first or mean
-            agg_exprs = []
-            for col in [self.pred_column, self.target]:
-                # Try to determine if numeric
-                try:
-                    # Use sum for aggregation
-                    agg_exprs.append(nw.col(col).sum().alias(col))
-                except Exception:
-                    # Fallback to mean or first
-                    agg_exprs.append(nw.col(col).mean().alias(col))
-
+            pred_method = self._resolve_aggregation_method("pred")
+            target_method = self._resolve_aggregation_method("target")
+            agg_exprs = [
+                self._build_aggregation_expr(df, self.pred_column, pred_method),
+                self._build_aggregation_expr(df, self.target, target_method),
+            ]
             df = df.group_by(self.aggregation_level).agg(agg_exprs)
         return df
 
+    @narwhals.narwhalify
+    def aggregate(self, df: IntoFrameT) -> IntoFrameT:
+        df = apply_filters(df, self.filters)
+        if not hasattr(df, "to_native"):
+            df = nw.from_native(df)
+        return self._apply_aggregation_level(df)
+
     def _get_granularity_groups(self, df: IntoFrameT) -> list[tuple]:
         """Get list of granularity tuples from dataframe"""
         if not self.granularity:
@@ -345,6 +378,7 @@ class PWMSE(BaseScorer):
         target: str,
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         labels: list[int] | None = None,
@@ -357,6 +391,7 @@ class PWMSE(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -454,12 +489,7 @@ class PWMSE(BaseScorer):
 
                 pass
             else:
-                df = df.group_by(self.aggregation_level).agg(
-                    [
-                        nw.col(self.pred_column).mean().alias(self.pred_column),
-                        nw.col(self.target).mean().alias(self.target),
-                    ]
-                )
+                df = self._apply_aggregation_level(df)
 
         if self.granularity:
             results = {}
@@ -517,6 +547,7 @@ class MeanBiasScorer(BaseScorer):
         target: str,
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         labels: list[int] | None = None,
@@ -540,6 +571,7 @@ class MeanBiasScorer(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -582,12 +614,7 @@ class MeanBiasScorer(BaseScorer):
 
         # Apply aggregation_level if set
         if self.aggregation_level:
-            df = df.group_by(self.aggregation_level).agg(
-                [
-                    nw.col(self.pred_column_name).sum().alias(self.pred_column_name),
-                    nw.col(self.target).sum().alias(self.target),
-                ]
-            )
+            df = self._apply_aggregation_level(df)
             # After group_by, ensure df is still a Narwhals DataFrame
             if not hasattr(df, "to_native"):
                 df = nw.from_native(df)
@@ -658,6 +685,7 @@ class SklearnScorer(BaseScorer):
         target: str,
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         params: dict[str, Any] = None,
@@ -679,6 +707,7 @@ class SklearnScorer(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -756,12 +785,7 @@ class SklearnScorer(BaseScorer):
             )
 
         if self.aggregation_level:
-            df = df.group_by(self.aggregation_level).agg(
-                [
-                    nw.col(self.pred_column_name).sum().alias(self.pred_column_name),
-                    nw.col(self.target).sum().alias(self.target),
-                ]
-            )
+            df = self._apply_aggregation_level(df)
             if not hasattr(df, "to_native"):
                 df = nw.from_native(df)
 
@@ -798,6 +822,7 @@ class ProbabilisticMeanBias(BaseScorer):
         class_column_name: str = "classes",
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         compare_to_naive: bool = False,
@@ -810,6 +835,7 @@ class ProbabilisticMeanBias(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -817,6 +843,49 @@ class ProbabilisticMeanBias(BaseScorer):
             naive_granularity=naive_granularity,
         )
 
+    def _aggregate_pandas_series(
+        self, df: pd.DataFrame, col: str, method: Any
+    ) -> pd.Series:
+        grouped = df.groupby(self.aggregation_level, dropna=False)
+        if isinstance(method, tuple):
+            if len(method) != 2 or method[0] != "weighted_mean":
+                raise ValueError(f"Unsupported aggregation method for {col}: {method}")
+            weight_col = method[1]
+            if weight_col not in df.columns:
+                raise ValueError(
+                    f"Aggregation weight column '{weight_col}' not found in dataframe columns."
+                )
+            return grouped.apply(
+                lambda g: (g[col] * g[weight_col]).sum() / g[weight_col].sum()
+            )
+
+        if method == "sum":
+            return grouped[col].sum()
+        if method == "mean":
+            return grouped[col].mean()
+        if method == "first":
+            return grouped[col].first()
+        raise ValueError(f"Unsupported aggregation method for {col}: {method}")
+
+    def _aggregate_pandas(self, df: pd.DataFrame) -> pd.DataFrame:
+        if not self.aggregation_level:
+            return df
+        pred_method = self._resolve_aggregation_method("pred")
+        target_method = self._resolve_aggregation_method("target")
+        agg_df = pd.DataFrame(
+            {
+                self.pred_column: self._aggregate_pandas_series(
+                    df, self.pred_column, pred_method
+                ),
+                self.target: self._aggregate_pandas_series(df, self.target, target_method),
+                self.class_column_name: df.groupby(self.aggregation_level, dropna=False)[
+                    self.class_column_name
+                ].first(),
+            }
+        )
+        agg_df.reset_index(inplace=True)
+        return agg_df
+
     def _calculate_score_for_group(self, df: pd.DataFrame) -> float:
         """Calculate score for a single group (used for granularity)"""
         df = df.copy()
@@ -948,13 +1017,7 @@ class ProbabilisticMeanBias(BaseScorer):
 
         # Apply aggregation_level if set
         if self.aggregation_level:
-            df = (
-                df.groupby(self.aggregation_level)
-                .agg(
-                    {self.pred_column: "mean", self.target: "mean", self.class_column_name: "first"}
-                )
-                .reset_index()
-            )
+            df = self._aggregate_pandas(df)
 
         # If granularity is set, calculate separate scores per group
         if self.granularity:
@@ -995,6 +1058,7 @@ class OrdinalLossScorer(BaseScorer):
         classes: list[int],
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list[Filter] | None = None,
         labels: list[int] | None = None,
@@ -1006,6 +1070,7 @@ class OrdinalLossScorer(BaseScorer):
             target=target,
             pred_column=pred_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -1102,14 +1167,10 @@ class OrdinalLossScorer(BaseScorer):
         if not hasattr(df, "to_native"):
             df = nw.from_native(df)
 
-        df_native = df.to_native()
-        df_pl = pl.DataFrame(df_native) if isinstance(df_native, pd.DataFrame) else df_native
-
         # Filter out null and NaN targets
-        before = len(df_pl)
-        target_col = pl.col(self.target)
-        df_pl = df_pl.filter(target_col.is_not_null() & target_col.is_not_nan())
-        after = len(df_pl)
+        before = len(df)
+        df = _filter_nulls_and_nans(df, self.target)
+        after = len(df)
         if before != after:
             _logger.info(
                 "OrdinalLossScorer: Dropped %d rows with NaN target (%d → %d)",
@@ -1119,12 +1180,12 @@ class OrdinalLossScorer(BaseScorer):
             )
 
         if self.aggregation_level:
-            df_pl = df_pl.group_by(self.aggregation_level).agg(
-                [
-                    pl.col(self.pred_column).mean().alias(self.pred_column),
-                    pl.col(self.target).mean().alias(self.target),
-                ]
-            )
+            df = self._apply_aggregation_level(df)
+
+        df_native = df.to_native()
+        df_pl = pl.DataFrame(df_native) if isinstance(df_native, pd.DataFrame) else df_native
+        if df_pl.is_empty():
+            return {} if self.granularity else 0.0
 
         if self.granularity:
             results = {}
@@ -1197,6 +1258,7 @@ class ThresholdEventScorer(BaseScorer):
         threshold_rounding: str = "ceil",
         validation_column: str | None = None,
         aggregation_level: list[str] | None = None,
+        aggregation_method: dict[str, Any] | None = None,
         granularity: list[str] | None = None,
         filters: list["Filter"] | None = None,
         compare_to_naive: bool = False,
@@ -1207,6 +1269,7 @@ class ThresholdEventScorer(BaseScorer):
             target=self._EVENT_COL,
             pred_column=dist_column,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=filters,
             validation_column=validation_column,
@@ -1227,6 +1290,7 @@ class ThresholdEventScorer(BaseScorer):
             target=self._EVENT_COL,
             pred_column=self._P_EVENT_COL,
             aggregation_level=aggregation_level,
+            aggregation_method=aggregation_method,
             granularity=granularity,
             filters=None,
             validation_column=validation_column,

{spforge-0.8.23.dist-info → spforge-0.8.26.dist-info}/METADATA

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

@@ -34,7 +34,7 @@ spforge/estimator/_group_by_estimator.py,sha256=o-xv_PJJyWBaKv5Eo4EPbOvb9i0CuebZ
 spforge/estimator/_ordinal_classifier.py,sha256=j_dfVHeX-6eZgPwwsYbkbP6bPrKH2a5S-N8vfP5hneA,1993
 spforge/estimator/_sklearn_enhancer_estimator.py,sha256=DZ-UlmeazXPd6uEnlbVv79syZ5FPa64voUyKArtjjUs,4664
 spforge/feature_generator/__init__.py,sha256=wfLfUkC_lLOCpy7NgDytK-l3HUAuhikuQXdKCgSGbuA,556
-spforge/feature_generator/_base.py,sha256=8_RtsnMvc1JOwAeUmnA-WP_Za3HvlBU4jZkg0yI0M-8,16299
+spforge/feature_generator/_base.py,sha256=eL0P4RRqSFaekko_RxtHKs5UXSCxdR3CG57Yvo7ryBo,16341
 spforge/feature_generator/_lag.py,sha256=Qe34y_iQ90GKlIDfXiYahRobAZB8J-BE1MCrfSPuCSY,6821
 spforge/feature_generator/_net_over_predicted.py,sha256=nngVzgLLxgOj8d9avSJCXaC_jNVOl33pWpQJB9RAKTU,2092
 spforge/feature_generator/_regressor_feature_generator.py,sha256=CM8fPbbX5A_wgT5AT0zbs3YBgsZIVKE74C9vS6V6Q4U,5043
@@ -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=zhTI6isbNXYy9xAyMt_6nlOktsk6TukDVWV7vS7G4qg,57190
+spforge/ratings/_player_rating.py,sha256=zltf4utwzKQxkTA8DAPZ4LWRDlwGxoiKFaiPIo4sdNw,60323
 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=cMxzQuk0nF1MsT_M32g-3mxVdAEbZ-S7TUjEPYdo3Yg,8361
+spforge/ratings/player_performance_predictor.py,sha256=UPzOEbougHT6FcmOiuTa3vEM6q8FZq-SjKb0AqD0JS4,8365
 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=kNuqiK3F5mUEAVD7KjWYY7E_AkRrspR362QBm_jyElg,57623
+spforge/scorer/_score.py,sha256=jZPaKiSpb14Lzec4HWrK3CfpkqPaN33mriHUZosRozM,60566
 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.23.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.26.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
@@ -89,25 +89,25 @@ tests/feature_generator/test_regressor_feature_generator.py,sha256=3Wfw1NbD11p2N
 tests/feature_generator/test_rolling_against_opponent.py,sha256=20kH1INrWy6DV7ASx8xVKuovDoHwK7L0-lAnzv1YQMs,5667
 tests/feature_generator/test_rolling_mean_binary.py,sha256=KuIavJ37Pt8icAb50B23lxdWEPVSHQ7NZHisD1BDpmU,16216
 tests/feature_generator/test_rolling_mean_days.py,sha256=EyOvdJDnmgPfe13uQBOkwo7fAteBQx-tnyuGM4ng2T8,18884
-tests/feature_generator/test_rolling_window.py,sha256=YBJo36OK3ILYeXrH06ylXqviUcCaGYaVQaK5RJzwM7Y,23239
+tests/feature_generator/test_rolling_window.py,sha256=_o9oljcAIZ14iI7e8WFeAsfXxILnyqBffit21HOvII4,24378
 tests/hyperparameter_tuning/test_estimator_tuner.py,sha256=iewME41d6LR2aQ0OtohGFtN_ocJUwTeqvs6L0QDmfG4,4413
 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=51iWgQRBHbb2-IPeajpej9ncGDWI1eUYdWrLXaKd9Ig,72232
+tests/ratings/test_player_rating_generator.py,sha256=Z66LN1-YdUHrS6dszWZf4HeENRyH8oEtu4Nlsh1MpMI,82442
 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=h-hyFOLzwp-92hYVU7CwvlRJ8jhB4DzXCtqgI-zcoqM,13677
+tests/scorer/test_score_aggregation_granularity.py,sha256=O5TRlG9UE4NBpF0tL_ywZKDmkMIorwrxgTegQ75Tr7A,15871
 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.23.dist-info/METADATA,sha256=jlkQ3fEjfwmJ_euPrFO6OlI-hT0LMQN928wz87B1qVU,20048
-spforge-0.8.23.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-spforge-0.8.23.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
-spforge-0.8.23.dist-info/RECORD,,
+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,,

tests/feature_generator/test_rolling_window.py

@@ -684,3 +684,39 @@ def test_rolling_mean_historical_transform_higher_granularity(column_names, use_
         }
     )
     pd.testing.assert_frame_equal(transformed_df, expected_df, check_like=True, check_dtype=False)
+
+
+@pytest.mark.parametrize("df", [pd.DataFrame, pl.DataFrame])
+def test_rolling_window__feature_also_used_as_column_names_field(df):
+    column_names = ColumnNames(
+        match_id="game_id",
+        player_id="player_id",
+        team_id="team_id",
+        start_date="game_date",
+        participation_weight="three_pointers_attempted",
+    )
+    data = df(
+        {
+            "game_id": [1, 1, 2, 2],
+            "player_id": ["a", "b", "a", "b"],
+            "team_id": [1, 2, 1, 2],
+            "game_date": [
+                pd.to_datetime("2023-01-01"),
+                pd.to_datetime("2023-01-01"),
+                pd.to_datetime("2023-01-02"),
+                pd.to_datetime("2023-01-02"),
+            ],
+            "three_pointers_attempted": [5.0, 3.0, 7.0, 4.0],
+        }
+    )
+
+    transformer = RollingWindowTransformer(
+        features=["three_pointers_attempted"],
+        window=20,
+        granularity=["player_id"],
+    )
+
+    transformed_df = transformer.fit_transform(data, column_names=column_names)
+
+    assert transformer.features_out[0] in transformed_df.columns
+    assert len(transformed_df) == len(data)

tests/ratings/test_player_rating_generator.py

@@ -2039,3 +2039,283 @@ def test_fit_transform_when_all_players_have_null_performance_then_no_rating_cha
         f"Before={p1_off_before_m2}, After={p1_off_after_m2}. "
         "Null performance should result in no rating change."
     )
+
+
+# --- team_players_playing_time Tests ---
+
+
+def test_fit_transform_team_players_playing_time_column_not_found_raises_error(base_cn):
+    """Specifying a nonexistent team_players_playing_time column should raise ValueError."""
+    from dataclasses import replace
+
+    cn = replace(base_cn, team_players_playing_time="nonexistent_column")
+
+    df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2"],
+            "tid": ["T1", "T2"],
+            "mid": ["M1", "M1"],
+            "dt": ["2024-01-01", "2024-01-01"],
+            "perf": [0.6, 0.4],
+            "pw": [1.0, 1.0],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+    )
+
+    with pytest.raises(ValueError, match="team_players_playing_time column"):
+        gen.fit_transform(df)
+
+
+def test_fit_transform_opponent_players_playing_time_column_not_found_raises_error(base_cn):
+    """Specifying a nonexistent opponent_players_playing_time column should raise ValueError."""
+    from dataclasses import replace
+
+    cn = replace(base_cn, opponent_players_playing_time="nonexistent_column")
+
+    df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2"],
+            "tid": ["T1", "T2"],
+            "mid": ["M1", "M1"],
+            "dt": ["2024-01-01", "2024-01-01"],
+            "perf": [0.6, 0.4],
+            "pw": [1.0, 1.0],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+    )
+
+    with pytest.raises(ValueError, match="opponent_players_playing_time column"):
+        gen.fit_transform(df)
+
+
+def test_fit_transform_null_playing_time_uses_standard_team_rating(base_cn):
+    """When team_players_playing_time is null for a row, should use standard team rating."""
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        team_players_playing_time="team_pt",
+        opponent_players_playing_time="opp_pt",
+    )
+
+    # First establish ratings with a normal match (no playing time data)
+    df1 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.8, 0.6, 0.4, 0.2],
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            "team_pt": [None, None, None, None],
+            "opp_pt": [None, None, None, None],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+        non_predictor_features_out=[RatingUnknownFeatures.PLAYER_PREDICTED_OFF_PERFORMANCE],
+    )
+
+    result = gen.fit_transform(df1)
+
+    # Should work without error and produce predictions
+    assert len(result) == 4
+    assert "player_predicted_off_performance_perf" in result.columns
+
+    # All predictions should be valid (between 0 and 1)
+    predictions = result["player_predicted_off_performance_perf"].to_list()
+    for pred in predictions:
+        assert 0.0 <= pred <= 1.0
+
+
+def test_fit_transform_weighted_calculation_with_playing_time(base_cn):
+    """Test that playing time weighted calculation produces different predictions."""
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        team_players_playing_time="team_pt",
+        opponent_players_playing_time="opp_pt",
+    )
+
+    # First establish different ratings for players
+    df1 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.9, 0.1, 0.5, 0.5],  # P1 high rating, P2 low rating
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            "team_pt": [None, None, None, None],
+            "opp_pt": [None, None, None, None],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        start_harcoded_start_rating=1000.0,
+        non_predictor_features_out=[RatingUnknownFeatures.PLAYER_PREDICTED_OFF_PERFORMANCE],
+    )
+    gen.fit_transform(df1)
+
+    # Verify P1 and P2 have different ratings now
+    p1_rating = gen._player_off_ratings["P1"].rating_value
+    p2_rating = gen._player_off_ratings["P2"].rating_value
+    assert p1_rating > p2_rating, "Setup: P1 should have higher rating than P2"
+
+    # Second match with playing time data
+    # P3 faces opponent P1 80% of time (high rating), P4 faces P2 80% of time (low rating)
+    # Use consistent schema for all dict entries (all keys present in all rows)
+    df2 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M2", "M2", "M2", "M2"],
+            "dt": ["2024-01-02"] * 4,
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            # Team playing time - who they play WITH on same team
+            "team_pt": [
+                {"P1": 0.0, "P2": 1.0, "P3": 0.5, "P4": 0.5},  # P1 on T1, plays with P2
+                {"P1": 1.0, "P2": 0.0, "P3": 0.5, "P4": 0.5},  # P2 on T1, plays with P1
+                {"P1": 0.5, "P2": 0.5, "P3": 0.0, "P4": 1.0},  # P3 on T2, plays with P4
+                {"P1": 0.5, "P2": 0.5, "P3": 1.0, "P4": 0.0},  # P4 on T2, plays with P3
+            ],
+            # Opponent playing time - who they face on opposing team
+            "opp_pt": [
+                {"P1": 0.0, "P2": 0.0, "P3": 0.5, "P4": 0.5},  # P1 faces T2 opponents evenly
+                {"P1": 0.0, "P2": 0.0, "P3": 0.5, "P4": 0.5},  # P2 faces T2 opponents evenly
+                {"P1": 0.8, "P2": 0.2, "P3": 0.0, "P4": 0.0},  # P3 faces P1 80% of time
+                {"P1": 0.2, "P2": 0.8, "P3": 0.0, "P4": 0.0},  # P4 faces P2 80% of time
+            ],
+        }
+    )
+
+    result = gen.future_transform(df2)
+
+    # Verify we get predictions
+    assert len(result) == 4
+
+    # Get predictions for P3 and P4
+    # P3 faces stronger opponents (mainly P1), P4 faces weaker opponents (mainly P2)
+    # So P3 should have lower predicted performance than P4 (all else equal)
+    p3_pred = result.filter(pl.col("pid") == "P3")["player_predicted_off_performance_perf"][0]
+    p4_pred = result.filter(pl.col("pid") == "P4")["player_predicted_off_performance_perf"][0]
+
+    # P3 faces P1 (high rating) 80% of time, P4 faces P2 (low rating) 80% of time
+    # So P4 should have higher predicted performance
+    assert p4_pred > p3_pred, (
+        f"P4 (facing weak opponents) should have higher prediction than P3 (facing strong opponents). "
+        f"P3 pred={p3_pred:.4f}, P4 pred={p4_pred:.4f}"
+    )
+
+
+def test_future_transform_weighted_calculation_with_playing_time(base_cn):
+    """Test that future_transform correctly uses playing time weights."""
+    from dataclasses import replace
+
+    cn = replace(
+        base_cn,
+        team_players_playing_time="team_pt",
+        opponent_players_playing_time="opp_pt",
+    )
+
+    # First establish ratings
+    df1 = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.9, 0.1, 0.5, 0.5],
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            "team_pt": [None, None, None, None],
+            "opp_pt": [None, None, None, None],
+        }
+    )
+
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=cn,
+        auto_scale_performance=True,
+        start_harcoded_start_rating=1000.0,
+        non_predictor_features_out=[RatingUnknownFeatures.PLAYER_PREDICTED_OFF_PERFORMANCE],
+    )
+    gen.fit_transform(df1)
+
+    # Future match with playing time weights (consistent schema)
+    future_df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M2", "M2", "M2", "M2"],
+            "dt": ["2024-01-02"] * 4,
+            "pw": [1.0, 1.0, 1.0, 1.0],
+            "team_pt": [
+                {"P1": 0.0, "P2": 1.0, "P3": 0.5, "P4": 0.5},  # P1 plays with P2
+                {"P1": 1.0, "P2": 0.0, "P3": 0.5, "P4": 0.5},  # P2 plays with P1
+                {"P1": 0.5, "P2": 0.5, "P3": 0.0, "P4": 1.0},  # P3 plays with P4
+                {"P1": 0.5, "P2": 0.5, "P3": 1.0, "P4": 0.0},  # P4 plays with P3
+            ],
+            "opp_pt": [
+                {"P1": 0.0, "P2": 0.0, "P3": 1.0, "P4": 0.0},  # P1 faces only P3
+                {"P1": 0.0, "P2": 0.0, "P3": 0.0, "P4": 1.0},  # P2 faces only P4
+                {"P1": 1.0, "P2": 0.0, "P3": 0.0, "P4": 0.0},  # P3 faces only P1
+                {"P1": 0.0, "P2": 1.0, "P3": 0.0, "P4": 0.0},  # P4 faces only P2
+            ],
+        }
+    )
+
+    result = gen.future_transform(future_df)
+
+    # Verify predictions are valid
+    assert len(result) == 4
+    predictions = result["player_predicted_off_performance_perf"].to_list()
+    for pred in predictions:
+        assert 0.0 <= pred <= 1.0
+
+
+def test_fit_transform_backward_compatible_without_playing_time_columns(base_cn):
+    """Behavior should be unchanged when team_players_playing_time columns are not specified."""
+    df = pl.DataFrame(
+        {
+            "pid": ["P1", "P2", "P3", "P4"],
+            "tid": ["T1", "T1", "T2", "T2"],
+            "mid": ["M1", "M1", "M1", "M1"],
+            "dt": ["2024-01-01"] * 4,
+            "perf": [0.6, 0.4, 0.7, 0.3],
+            "pw": [1.0, 1.0, 1.0, 1.0],
+        }
+    )
+
+    # Without specifying playing time columns (backward compatible)
+    gen = PlayerRatingGenerator(
+        performance_column="perf",
+        column_names=base_cn,  # No playing time columns specified
+        auto_scale_performance=True,
+        features_out=[RatingKnownFeatures.PLAYER_OFF_RATING],
+    )
+
+    result = gen.fit_transform(df)
+
+    # Should work normally
+    assert len(result) == 4
+    assert "player_off_rating_perf" in result.columns
+
+    # 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

tests/scorer/test_score_aggregation_granularity.py

@@ -21,6 +21,16 @@ def create_dataframe(df_type, data: dict):
     return df_type(data)
 
 
+def to_pandas_df(df):
+    if hasattr(df, "to_native"):
+        df = df.to_native()
+    if isinstance(df, pd.DataFrame):
+        return df
+    if isinstance(df, pl.DataFrame):
+        return df.to_pandas()
+    raise TypeError(f"Unsupported dataframe type: {type(df)}")
+
+
 # ============================================================================
 # Aggregation Level Tests
 # ============================================================================
@@ -104,6 +114,65 @@ def test_pwmse_aggregation_level(df_type):
     assert score >= 0
 
 
+@pytest.mark.parametrize("df_type", [pl.DataFrame, pd.DataFrame])
+def test_aggregate_returns_grouped_frame(df_type):
+    """aggregate returns filtered, grouped dataframe with default sum behavior"""
+    df = create_dataframe(
+        df_type,
+        {
+            "game_id": [1, 1, 1, 1],
+            "player_id": [1, 2, 3, 4],
+            "team_id": [1, 1, 2, 2],
+            "pred": [0.5, 0.6, 0.3, 0.4],
+            "target": [0, 1, 0, 1],
+        },
+    )
+
+    scorer = MeanBiasScorer(
+        pred_column="pred", target="target", aggregation_level=["game_id", "team_id"]
+    )
+    aggregated = to_pandas_df(scorer.aggregate(df))
+
+    assert len(aggregated) == 2
+    team1 = aggregated[aggregated["team_id"] == 1].iloc[0]
+    team2 = aggregated[aggregated["team_id"] == 2].iloc[0]
+    assert abs(team1["pred"] - 1.1) < 1e-10
+    assert abs(team1["target"] - 1.0) < 1e-10
+    assert abs(team2["pred"] - 0.7) < 1e-10
+    assert abs(team2["target"] - 1.0) < 1e-10
+
+
+@pytest.mark.parametrize("df_type", [pl.DataFrame, pd.DataFrame])
+def test_weighted_mean_aggregation_method(df_type):
+    """Weighted mean aggregation uses provided weight column"""
+    df = create_dataframe(
+        df_type,
+        {
+            "game_id": [1, 1, 1],
+            "team_id": [1, 1, 1],
+            "pred": [0.4, 0.6, 0.9],
+            "target": [0.5, 0.7, 0.2],
+            "attempts": [10, 20, 30],
+        },
+    )
+
+    scorer = MeanBiasScorer(
+        pred_column="pred",
+        target="target",
+        aggregation_level=["game_id", "team_id"],
+        aggregation_method={
+            "pred": ("weighted_mean", "attempts"),
+            "target": ("weighted_mean", "attempts"),
+        },
+    )
+
+    score = scorer.score(df)
+    expected_pred = (0.4 * 10 + 0.6 * 20 + 0.9 * 30) / 60
+    expected_target = (0.5 * 10 + 0.7 * 20 + 0.2 * 30) / 60
+    expected = expected_pred - expected_target
+    assert abs(score - expected) < 1e-10
+
+
 # ============================================================================
 # Granularity Tests (Separate Scores Per Group)
 # ============================================================================