spforge 0.8.25__py3-none-any.whl → 0.8.27__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
@@ -912,10 +914,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 +956,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 +1036,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 +1282,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/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.25.dist-info → spforge-0.8.27.dist-info}/METADATA

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

@@ -51,7 +51,7 @@ 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=TDw0LM-sLn27fprUhOW5csaDqAhzagoVm8SPKipZZmg,61106
 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
@@ -62,7 +62,7 @@ spforge/ratings/team_performance_predictor.py,sha256=ThQOmYQUqKBB46ONYHOMM2arXFH
 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.25.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+spforge-0.8.27.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,20 @@ 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=tpU83Orw1nlus29a0s9vc1pghL-f2rs642viW_6wFgk,83633
 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.25.dist-info/METADATA,sha256=JwBRy1-fD-a4UzeS_DeCv9AoXfbvbI7DghMls363RQ4,20048
-spforge-0.8.25.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-spforge-0.8.25.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
-spforge-0.8.25.dist-info/RECORD,,
+spforge-0.8.27.dist-info/METADATA,sha256=Bl0sOhG9rDGmQpTThxwNPlAKyXeR6dCxWlGmbHH0LN0,20048
+spforge-0.8.27.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+spforge-0.8.27.dist-info/top_level.txt,sha256=6UW2M5a7WKOeaAi900qQmRKNj5-HZzE8-eUD9Y9LTq0,23
+spforge-0.8.27.dist-info/RECORD,,

tests/ratings/test_player_rating_generator.py

@@ -4,7 +4,7 @@ import polars as pl
 import pytest
 
 from spforge import ColumnNames
-from spforge.data_structures import RatingState
+from spforge.data_structures import PlayerRating, RatingState
 from spforge.ratings import PlayerRatingGenerator, RatingKnownFeatures, RatingUnknownFeatures
 
 
@@ -78,6 +78,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
 
 

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)
 # ============================================================================