spforge 0.8.27__tar.gz → 0.8.30__tar.gz

{spforge-0.8.27/spforge.egg-info → spforge-0.8.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.27
+Version: 0.8.30
 Summary: A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data.
 Author-email: Mathias Holmstrøm <mathiasholmstom@gmail.com>
 License: See LICENSE file

{spforge-0.8.27 → spforge-0.8.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spforge"
-version = "0.8.27"
+version = "0.8.30"
 description = "A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data."
 readme = "README.md"
 requires-python = ">=3.11"

{spforge-0.8.27 → spforge-0.8.30}/spforge/data_structures.py

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

{spforge-0.8.27 → spforge-0.8.30}/spforge/ratings/_player_rating.py

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

{spforge-0.8.27 → spforge-0.8.30}/spforge/ratings/player_performance_predictor.py

@@ -31,6 +31,7 @@ class PlayerPerformancePredictor(ABC):
         pass
 
 
+
 class PlayerRatingNonOpponentPerformancePredictor(PlayerPerformancePredictor):
 
     def __init__(
@@ -38,18 +39,22 @@ class PlayerRatingNonOpponentPerformancePredictor(PlayerPerformancePredictor):
         coef: float = 0.0015,
         last_sample_count: int = 1500,
         min_count_for_historical_average: int = 200,
-        historical_average_value_default: float = 1000,
     ):
         self.coef = coef
         self.last_sample_count = last_sample_count
         self.min_count_for_historical_average = min_count_for_historical_average
-        self.historical_average_value_default = historical_average_value_default
         if self.min_count_for_historical_average < 1:
             raise ValueError("min_count_for_historical_average must be positive")
-        self._prev_entries_ratings = []
+        self._reference_rating: float | None = None
 
     def reset(self):
-        self._prev_entries_ratings = []
+        pass
+
+    def _get_reference_rating(self) -> float:
+        """Get reference rating from rating generator, or default to 1000."""
+        if self._reference_rating is not None:
+            return self._reference_rating
+        return 1000
 
     def predict_performance(
         self,
@@ -57,21 +62,14 @@ class PlayerRatingNonOpponentPerformancePredictor(PlayerPerformancePredictor):
         opponent_team_rating: PreMatchTeamRating,
         team_rating: PreMatchTeamRating,
     ) -> float:
-        start_index = max(0, len(self._prev_entries_ratings) - self.last_sample_count)
-        recent_prev_entries_ratings = self._prev_entries_ratings[start_index:]
-        if len(recent_prev_entries_ratings) > self.min_count_for_historical_average:
-            historical_average_rating = sum(recent_prev_entries_ratings) / len(
-                recent_prev_entries_ratings
-            )
-        else:
-            historical_average_rating = self.historical_average_value_default
+        historical_average_rating = self._get_reference_rating()
+
         net_mean_rating_over_historical_average = (
             player_rating.rating_value - historical_average_rating
         )
 
         value = self.coef * net_mean_rating_over_historical_average
         prediction = (math.exp(value)) / (1 + math.exp(value))
-        self._prev_entries_ratings.append(player_rating.rating_value)
 
         return prediction
 

{spforge-0.8.27 → spforge-0.8.30}/spforge/scorer/_score.py

@@ -267,6 +267,7 @@ class BaseScorer(ABC):
         granularity: list[str] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         """
         :param target: The column name of the target
@@ -277,6 +278,9 @@ class BaseScorer(ABC):
         :param aggregation_level: The columns to group by before calculating the score (e.g., group from game-player to game-team)
         :param aggregation_method: Aggregation methods for pred/target when aggregation_level is set.
         :param granularity: The columns to calculate separate scores for each unique combination (e.g., different scores for each team)
+        :param compare_to_naive: If True, returns naive_score - model_score (improvement over naive baseline)
+        :param naive_granularity: Granularity for computing naive baseline predictions
+        :param _name_override: Override auto-generated name (internal use)
         """
         self.target = target
         self.pred_column = pred_column
@@ -295,6 +299,7 @@ class BaseScorer(ABC):
         self.granularity = granularity
         self.compare_to_naive = compare_to_naive
         self.naive_granularity = naive_granularity
+        self._name_override = _name_override
 
     def _resolve_aggregation_method(self, key: str) -> Any:
         if self.aggregation_method is None:
@@ -359,6 +364,98 @@ class BaseScorer(ABC):
             mask = col_mask if mask is None else (mask & col_mask)
         return df.filter(mask)
 
+    def _get_scorer_id(self) -> str:
+        """Get scorer-specific identifier in snake_case. Override in subclasses if needed."""
+        import re
+        name = self.__class__.__name__
+        # Check if name is all uppercase (acronym like PWMSE)
+        if name.isupper():
+            return name.lower()
+        # Otherwise use regular snake_case conversion
+        return re.sub(r'(?<!^)(?=[A-Z])', '_', name).lower()
+
+    def _format_column_list(self, columns: list[str], max_display: int = 3) -> str:
+        """Format column list with abbreviation for long lists."""
+        if len(columns) <= max_display:
+            return "+".join(columns)
+        shown = "+".join(columns[:max_display])
+        remaining = len(columns) - max_display
+        return f"{shown}+{remaining}more"
+
+    def _sanitize_column_name(self, name: str) -> str:
+        """Replace special characters with underscores."""
+        import re
+        return re.sub(r'[^a-zA-Z0-9_]', '_', name)
+
+    def _count_user_filters(self) -> int:
+        """Count filters excluding auto-added validation filter."""
+        if not self.filters:
+            return 0
+        if self.validation_column is None:
+            return len(self.filters)
+        count = 0
+        for f in self.filters:
+            if not (f.column_name == self.validation_column and
+                    f.operator == Operator.EQUALS and
+                    f.value == 1):
+                count += 1
+        return count
+
+    def _generate_name(self) -> str:
+        """Generate readable name from scorer configuration."""
+        parts = []
+
+        parts.append(self._get_scorer_id())
+
+        parts.append(self._sanitize_column_name(self.target))
+
+        if self.granularity:
+            gran_str = self._format_column_list(self.granularity)
+            parts.append(f"gran:{gran_str}")
+
+        if self.compare_to_naive:
+            if self.naive_granularity:
+                naive_str = self._format_column_list(self.naive_granularity)
+                parts.append(f"naive:{naive_str}")
+            else:
+                parts.append("naive")
+
+        if self.aggregation_level:
+            agg_str = self._format_column_list(self.aggregation_level)
+            parts.append(f"agg:{agg_str}")
+
+        filter_count = self._count_user_filters()
+        if filter_count > 0:
+            parts.append(f"filters:{filter_count}")
+
+        return "_".join(parts)
+
+    @property
+    def name(self) -> str:
+        """
+        Generate a human-readable name for this scorer.
+
+        Returns descriptive name based on scorer configuration including
+        target, granularity, naive comparison, aggregation, and filters.
+        Only includes components that are actually set (non-None/non-empty).
+
+        Format: {scorer_id}_{target}[_gran:{cols}][_naive[:cols]][_agg:{cols}][_filters:{n}]
+
+        Can be overridden by passing _name_override to constructor.
+
+        Examples:
+            >>> scorer = MeanBiasScorer(target="points", pred_column="pred")
+            >>> scorer.name
+            'mean_bias_scorer_points'
+
+            >>> scorer = MeanBiasScorer(target="points", granularity=["team_id"], compare_to_naive=True)
+            >>> scorer.name
+            'mean_bias_scorer_points_gran:team_id_naive'
+        """
+        if hasattr(self, '_name_override') and self._name_override is not None:
+            return self._name_override
+        return self._generate_name()
+
     @abstractmethod
     def score(self, df: IntoFrameT) -> float | dict[tuple, float]:
         """
@@ -385,6 +482,7 @@ class PWMSE(BaseScorer):
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
         evaluation_labels: list[int] | None = None,
+        _name_override: str | None = None,
     ):
         self.pred_column_name = pred_column
         super().__init__(
@@ -397,6 +495,7 @@ class PWMSE(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
         self.labels = labels
         self.evaluation_labels = evaluation_labels
@@ -553,6 +652,7 @@ class MeanBiasScorer(BaseScorer):
         labels: list[int] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         """
         :param pred_column: The column name of the predictions
@@ -563,6 +663,7 @@ class MeanBiasScorer(BaseScorer):
         :param granularity: The columns to calculate separate scores for each unique combination (e.g., different scores for each team)
         :param filters: The filters to apply before calculating
         :param labels: The labels corresponding to each index in probability distributions (e.g., [-5, -4, ..., 35] for rush yards)
+        :param _name_override: Override auto-generated name (internal use)
         """
 
         self.pred_column_name = pred_column
@@ -577,6 +678,7 @@ class MeanBiasScorer(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
 
     def _mean_bias_score(self, df: IntoFrameT) -> float:
@@ -691,6 +793,7 @@ class SklearnScorer(BaseScorer):
         params: dict[str, Any] = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         """
         :param pred_column: The column name of the predictions
@@ -701,6 +804,7 @@ class SklearnScorer(BaseScorer):
         :param aggregation_level: The columns to group by before calculating the score (e.g., group from game-player to game-team)
         :param granularity: The columns to calculate separate scores for each unique combination (e.g., different scores for each team)
         :param filters: The filters to apply before calculating
+        :param _name_override: Override auto-generated name (internal use)
         """
 
         super().__init__(
@@ -713,11 +817,22 @@ class SklearnScorer(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
         self.pred_column_name = pred_column
         self.scorer_function = scorer_function
         self.params = params or {}
 
+    def _get_scorer_id(self) -> str:
+        """Use the scorer function name."""
+        if hasattr(self.scorer_function, '__name__'):
+            name = self.scorer_function.__name__
+            # Handle lambda functions
+            if name == '<lambda>':
+                return "custom_metric"
+            return name
+        return "custom_metric"
+
     def _pad_probabilities(
         self, y_true: list[Any], probabilities: list[list[float]]
     ) -> tuple[list[list[float]], dict[str, Any]]:
@@ -827,6 +942,7 @@ class ProbabilisticMeanBias(BaseScorer):
         filters: list[Filter] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
 
         self.pred_column_name = pred_column
@@ -841,6 +957,7 @@ class ProbabilisticMeanBias(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
 
     def _aggregate_pandas_series(
@@ -1064,6 +1181,7 @@ class OrdinalLossScorer(BaseScorer):
         labels: list[int] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         self.pred_column_name = pred_column
         super().__init__(
@@ -1076,6 +1194,7 @@ class OrdinalLossScorer(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
         self.classes = classes
 
@@ -1263,6 +1382,7 @@ class ThresholdEventScorer(BaseScorer):
         filters: list["Filter"] | None = None,
         compare_to_naive: bool = False,
         naive_granularity: list[str] | None = None,
+        _name_override: str | None = None,
     ):
         self.pred_column_name = dist_column
         super().__init__(
@@ -1275,6 +1395,7 @@ class ThresholdEventScorer(BaseScorer):
             validation_column=validation_column,
             compare_to_naive=compare_to_naive,
             naive_granularity=naive_granularity,
+            _name_override=_name_override,
         )
 
         self.dist_column = dist_column

{spforge-0.8.27 → spforge-0.8.30/spforge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spforge
-Version: 0.8.27
+Version: 0.8.30
 Summary: A flexible framework for generating features, ratings, and building machine learning or other models for training and inference on sports data.
 Author-email: Mathias Holmstrøm <mathiasholmstom@gmail.com>
 License: See LICENSE file

{spforge-0.8.27 → spforge-0.8.30}/spforge.egg-info/SOURCES.txt

@@ -109,6 +109,7 @@ tests/ratings/test_team_rating_generator.py
 tests/ratings/test_utils_scaled_weights.py
 tests/scorer/test_score.py
 tests/scorer/test_score_aggregation_granularity.py
+tests/scorer/test_scorer_name.py
 tests/transformers/test_estimator_transformer_context.py
 tests/transformers/test_net_over_predicted.py
 tests/transformers/test_other_transformer.py