hockey-blast-common-lib 0.1.62__py3-none-any.whl → 0.1.64__py3-none-any.whl

hockey_blast_common_lib/aggregate_s2s_stats.py

@@ -1,40 +1,65 @@
-import sys, os
+import os
+import sys
 from datetime import datetime
 
 # Add the package directory to the Python path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from hockey_blast_common_lib.models import Game, Goal, Penalty, GameRoster
-from hockey_blast_common_lib.h2h_models import SkaterToSkaterStats, SkaterToSkaterStatsMeta
-from hockey_blast_common_lib.db_connection import create_session
-from sqlalchemy.sql import func
 from sqlalchemy import types
+from sqlalchemy.sql import func
+
+from hockey_blast_common_lib.db_connection import create_session
+from hockey_blast_common_lib.h2h_models import (
+    SkaterToSkaterStats,
+    SkaterToSkaterStatsMeta,
+)
+from hockey_blast_common_lib.models import Game, GameRoster, Goal, Penalty
 
 # Optional: Limit processing to a specific human_id
 LIMIT_HUMAN_ID = None
 
+
 def aggregate_s2s_stats():
     session = create_session("boss")
-    meta = session.query(SkaterToSkaterStatsMeta).order_by(SkaterToSkaterStatsMeta.id.desc()).first()
+    meta = (
+        session.query(SkaterToSkaterStatsMeta)
+        .order_by(SkaterToSkaterStatsMeta.id.desc())
+        .first()
+    )
     s2s_stats_dict = {}  # (skater1_id, skater2_id) -> SkaterToSkaterStats instance
 
-    if meta is None or meta.last_run_timestamp is None or meta.last_processed_game_id is None:
+    if (
+        meta is None
+        or meta.last_run_timestamp is None
+        or meta.last_processed_game_id is None
+    ):
         # Full run: delete all existing stats and process all games
         session.query(SkaterToSkaterStats).delete()
         session.commit()
         games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
-        print("No previous run found, deleted all existing Skater-to-Skater stats, processing all games...")
+        print(
+            "No previous run found, deleted all existing Skater-to-Skater stats, processing all games..."
+        )
     else:
         # Incremental: only process games after last processed
         for stat in session.query(SkaterToSkaterStats).all():
             s2s_stats_dict[(stat.skater1_id, stat.skater2_id)] = stat
-        last_game = session.query(Game).filter(Game.id == meta.last_processed_game_id).first()
+        last_game = (
+            session.query(Game).filter(Game.id == meta.last_processed_game_id).first()
+        )
         if last_game:
             last_dt = datetime.combine(last_game.date, last_game.time)
-            games_query = session.query(Game).filter(
-                func.cast(func.concat(Game.date, ' ', Game.time), types.TIMESTAMP()) > last_dt
-            ).order_by(Game.date, Game.time, Game.id)
-            print(f"Resuming from game after id {meta.last_processed_game_id} ({last_dt})...")
+            games_query = (
+                session.query(Game)
+                .filter(
+                    func.cast(func.concat(Game.date, " ", Game.time), types.TIMESTAMP())
+                    > last_dt
+                )
+                .order_by(Game.date, Game.time, Game.id)
+            )
+            print(
+                f"Resuming from game after id {meta.last_processed_game_id} ({last_dt})..."
+            )
         else:
             games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
             print("Previous game id not found, processing all games...")
@@ -46,16 +71,40 @@ def aggregate_s2s_stats():
 
     for game in games_query:
         # Separate skaters into home and away rosters (exclude goalies)
-        home_skaters = [entry.human_id for entry in session.query(GameRoster).filter(GameRoster.game_id == game.id, GameRoster.team_id == game.home_team_id, ~GameRoster.role.ilike('g')).all()]
-        away_skaters = [entry.human_id for entry in session.query(GameRoster).filter(GameRoster.game_id == game.id, GameRoster.team_id == game.visitor_team_id, ~GameRoster.role.ilike('g')).all()]
-
-        if LIMIT_HUMAN_ID is not None and LIMIT_HUMAN_ID not in home_skaters + away_skaters:
+        home_skaters = [
+            entry.human_id
+            for entry in session.query(GameRoster)
+            .filter(
+                GameRoster.game_id == game.id,
+                GameRoster.team_id == game.home_team_id,
+                ~GameRoster.role.ilike("g"),
+            )
+            .all()
+        ]
+        away_skaters = [
+            entry.human_id
+            for entry in session.query(GameRoster)
+            .filter(
+                GameRoster.game_id == game.id,
+                GameRoster.team_id == game.visitor_team_id,
+                ~GameRoster.role.ilike("g"),
+            )
+            .all()
+        ]
+
+        if (
+            LIMIT_HUMAN_ID is not None
+            and LIMIT_HUMAN_ID not in home_skaters + away_skaters
+        ):
             continue
 
         # Create pairs of skaters from different rosters
         for h_skater in home_skaters:
             for a_skater in away_skaters:
-                if LIMIT_HUMAN_ID is not None and LIMIT_HUMAN_ID not in [h_skater, a_skater]:
+                if LIMIT_HUMAN_ID is not None and LIMIT_HUMAN_ID not in [
+                    h_skater,
+                    a_skater,
+                ]:
                     continue
 
                 s1, s2 = sorted([h_skater, a_skater])
@@ -74,7 +123,7 @@ def aggregate_s2s_stats():
                         skater1_assists_against_skater2=0,
                         skater2_assists_against_skater1=0,
                         skater1_penalties_against_skater2=0,
-                        skater2_penalties_against_skater1=0
+                        skater2_penalties_against_skater1=0,
                     )
                     s2s_stats_dict[key] = s2s
 
@@ -100,7 +149,9 @@ def aggregate_s2s_stats():
                         s2s.skater2_assists_against_skater1 += 1
 
                 # Penalties
-                penalties_stats = session.query(Penalty).filter(Penalty.game_id == game.id).all()
+                penalties_stats = (
+                    session.query(Penalty).filter(Penalty.game_id == game.id).all()
+                )
                 for penalty in penalties_stats:
                     if penalty.penalized_player_id == s1:
                         s2s.skater1_penalties_against_skater2 += 1
@@ -110,7 +161,10 @@ def aggregate_s2s_stats():
         latest_game_id = game.id
         processed += 1
         if processed % 10 == 0 or processed == total_games:
-            print(f"\rProcessed {processed}/{total_games} games ({(processed/total_games)*100:.2f}%)", end="")
+            print(
+                f"\rProcessed {processed}/{total_games} games ({(processed/total_games)*100:.2f}%)",
+                end="",
+            )
             sys.stdout.flush()
 
     # Commit all stats at once
@@ -121,13 +175,13 @@ def aggregate_s2s_stats():
 
     # Save/update meta
     meta = SkaterToSkaterStatsMeta(
-        last_run_timestamp=datetime.utcnow(),
-        last_processed_game_id=latest_game_id
+        last_run_timestamp=datetime.utcnow(), last_processed_game_id=latest_game_id
     )
     session.add(meta)
     session.commit()
     print("Skater-to-Skater aggregation complete.")
 
+
 # --- Helper functions for win/loss/tie ---
 def _is_win(game, skater_id, team_id):
     if team_id == game.home_team_id:
@@ -136,8 +190,14 @@ def _is_win(game, skater_id, team_id):
         return (game.visitor_final_score or 0) > (game.home_final_score or 0)
     return False
 
+
 def _is_tie(game):
-    return (game.home_final_score is not None and game.visitor_final_score is not None and game.home_final_score == game.visitor_final_score)
+    return (
+        game.home_final_score is not None
+        and game.visitor_final_score is not None
+        and game.home_final_score == game.visitor_final_score
+    )
+
 
 if __name__ == "__main__":
-    aggregate_s2s_stats()
+    aggregate_s2s_stats()

hockey_blast_common_lib/aggregate_scorekeeper_stats.py

@@ -1,21 +1,30 @@
-import sys, os
+import os
+import sys
 
 # Add the package directory to the Python path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
-from datetime import datetime, timedelta
+
 import sqlalchemy
+from sqlalchemy.sql import func
 
-from hockey_blast_common_lib.models import Game, ScorekeeperSaveQuality
-from hockey_blast_common_lib.stats_models import OrgStatsScorekeeper, OrgStatsWeeklyScorekeeper, OrgStatsDailyScorekeeper
 from hockey_blast_common_lib.db_connection import create_session
-from sqlalchemy.sql import func, case
-from hockey_blast_common_lib.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS
-from hockey_blast_common_lib.utils import get_org_id_from_alias, get_non_human_ids
-from hockey_blast_common_lib.utils import assign_ranks
-from hockey_blast_common_lib.utils import get_start_datetime
-from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
+from hockey_blast_common_lib.models import Game, ScorekeeperSaveQuality
+from hockey_blast_common_lib.options import (
+    MIN_GAMES_FOR_ORG_STATS,
+)
 from hockey_blast_common_lib.progress_utils import create_progress_tracker
+from hockey_blast_common_lib.stats_models import (
+    OrgStatsDailyScorekeeper,
+    OrgStatsScorekeeper,
+    OrgStatsWeeklyScorekeeper,
+)
+from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
+from hockey_blast_common_lib.utils import (
+    assign_ranks,
+    get_non_human_ids,
+    get_start_datetime,
+)
 
 # Import status constants for game filtering
 FINAL_STATUS = "Final"
@@ -23,7 +32,10 @@ FINAL_SO_STATUS = "Final(SO)"
 FORFEIT_STATUS = "FORFEIT"
 NOEVENTS_STATUS = "NOEVENTS"
 
-def calculate_quality_score(avg_max_saves_5sec, avg_max_saves_20sec, peak_max_saves_5sec, peak_max_saves_20sec):
+
+def calculate_quality_score(
+    avg_max_saves_5sec, avg_max_saves_20sec, peak_max_saves_5sec, peak_max_saves_20sec
+):
     """
     Calculate a quality score based on excessive clicking patterns.
     Lower scores are better (less problematic clicking).
@@ -43,35 +55,40 @@ def calculate_quality_score(avg_max_saves_5sec, avg_max_saves_20sec, peak_max_sa
         return 0.0
 
     # Weight factors (can be tuned based on analysis)
-    avg_5sec_weight = 2.0    # Average clicking in 5sec windows
-    avg_20sec_weight = 1.0   # Average clicking in 20sec windows
-    peak_5sec_weight = 5.0   # Peak 5sec incidents are heavily penalized
+    avg_5sec_weight = 2.0  # Average clicking in 5sec windows
+    avg_20sec_weight = 1.0  # Average clicking in 20sec windows
+    peak_5sec_weight = 5.0  # Peak 5sec incidents are heavily penalized
     peak_20sec_weight = 3.0  # Peak 20sec incidents are moderately penalized
 
     score = (
-        (avg_max_saves_5sec * avg_5sec_weight) +
-        (avg_max_saves_20sec * avg_20sec_weight) +
-        (peak_max_saves_5sec * peak_5sec_weight) +
-        (peak_max_saves_20sec * peak_20sec_weight)
+        (avg_max_saves_5sec * avg_5sec_weight)
+        + (avg_max_saves_20sec * avg_20sec_weight)
+        + (peak_max_saves_5sec * peak_5sec_weight)
+        + (peak_max_saves_20sec * peak_20sec_weight)
     )
 
     return round(score, 2)
 
-def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, aggregation_window=None):
+
+def aggregate_scorekeeper_stats(
+    session, aggregation_type, aggregation_id, aggregation_window=None
+):
     # Only process scorekeeper stats for ALL_ORGS_ID - skip individual organizations
     # This prevents redundant processing when upstream logic calls with all organization IDs
-    if aggregation_type == 'org' and aggregation_id != ALL_ORGS_ID:
+    if aggregation_type == "org" and aggregation_id != ALL_ORGS_ID:
         return  # Do nothing for individual organization IDs
 
     human_ids_to_filter = get_non_human_ids(session)
 
-    if aggregation_type == 'org':
+    if aggregation_type == "org":
         aggregation_name = "All Orgs"
         filter_condition = sqlalchemy.true()  # No filter for organization
-        print(f"Aggregating scorekeeper stats for {aggregation_name} with window {aggregation_window}...")
-        if aggregation_window == 'Daily':
+        print(
+            f"Aggregating scorekeeper stats for {aggregation_name} with window {aggregation_window}..."
+        )
+        if aggregation_window == "Daily":
             StatsModel = OrgStatsDailyScorekeeper
-        elif aggregation_window == 'Weekly':
+        elif aggregation_window == "Weekly":
             StatsModel = OrgStatsWeeklyScorekeeper
         else:
             StatsModel = OrgStatsScorekeeper
@@ -80,45 +97,74 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, aggre
         raise ValueError("Invalid aggregation type")
 
     # Delete existing items from the stats table
-    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
+    session.query(StatsModel).filter(
+        StatsModel.aggregation_id == aggregation_id
+    ).delete()
     session.commit()
 
     # Apply aggregation window filter
     if aggregation_window:
-        last_game_datetime_str = session.query(func.max(func.concat(Game.date, ' ', Game.time))).filter(filter_condition, Game.status.like('Final%')).scalar()
+        last_game_datetime_str = (
+            session.query(func.max(func.concat(Game.date, " ", Game.time)))
+            .filter(filter_condition, Game.status.like("Final%"))
+            .scalar()
+        )
         start_datetime = get_start_datetime(last_game_datetime_str, aggregation_window)
         if start_datetime:
-            game_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP).between(start_datetime, last_game_datetime_str)
+            game_window_filter = func.cast(
+                func.concat(Game.date, " ", Game.time), sqlalchemy.types.TIMESTAMP
+            ).between(start_datetime, last_game_datetime_str)
             filter_condition = filter_condition & game_window_filter
         else:
             return
 
-
     # Aggregate scorekeeper quality data for each human
     # games_participated: Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
     # games_with_stats: Count only FINAL, FINAL_SO (for per-game averages)
-    scorekeeper_quality_stats = session.query(
-        ScorekeeperSaveQuality.scorekeeper_id.label('human_id'),
-        func.count(ScorekeeperSaveQuality.game_id).label('games_recorded'),  # DEPRECATED - will be replaced by games_participated
-        func.sum(case(
-            (Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS, FORFEIT_STATUS, NOEVENTS_STATUS]), 1),
-            else_=0
-        )).label('games_participated'),
-        func.sum(case(
-            (Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS]), 1),
-            else_=0
-        )).label('games_with_stats'),
-        func.sum(ScorekeeperSaveQuality.total_saves_recorded).label('total_saves_recorded'),
-        func.avg(ScorekeeperSaveQuality.total_saves_recorded).label('avg_saves_per_game'),
-        func.avg(ScorekeeperSaveQuality.max_saves_per_5sec).label('avg_max_saves_per_5sec'),
-        func.avg(ScorekeeperSaveQuality.max_saves_per_20sec).label('avg_max_saves_per_20sec'),
-        func.max(ScorekeeperSaveQuality.max_saves_per_5sec).label('peak_max_saves_per_5sec'),
-        func.max(ScorekeeperSaveQuality.max_saves_per_20sec).label('peak_max_saves_per_20sec'),
-        func.array_agg(ScorekeeperSaveQuality.game_id).label('game_ids')
-    ).join(Game, Game.id == ScorekeeperSaveQuality.game_id)
-
-
-    scorekeeper_quality_stats = scorekeeper_quality_stats.filter(filter_condition).group_by(ScorekeeperSaveQuality.scorekeeper_id).all()
+    # Filter by game status upfront for performance
+    scorekeeper_quality_stats = (
+        session.query(
+            ScorekeeperSaveQuality.scorekeeper_id.label("human_id"),
+            func.count(ScorekeeperSaveQuality.game_id).label("games_recorded"),
+            func.count(ScorekeeperSaveQuality.game_id).label(
+                "games_participated"
+            ),  # Same as games_recorded after filtering
+            func.count(ScorekeeperSaveQuality.game_id).label(
+                "games_with_stats"
+            ),  # Same as games_recorded after filtering
+            func.sum(ScorekeeperSaveQuality.total_saves_recorded).label(
+                "total_saves_recorded"
+            ),
+            func.avg(ScorekeeperSaveQuality.total_saves_recorded).label(
+                "avg_saves_per_game"
+            ),
+            func.avg(ScorekeeperSaveQuality.max_saves_per_5sec).label(
+                "avg_max_saves_per_5sec"
+            ),
+            func.avg(ScorekeeperSaveQuality.max_saves_per_20sec).label(
+                "avg_max_saves_per_20sec"
+            ),
+            func.max(ScorekeeperSaveQuality.max_saves_per_5sec).label(
+                "peak_max_saves_per_5sec"
+            ),
+            func.max(ScorekeeperSaveQuality.max_saves_per_20sec).label(
+                "peak_max_saves_per_20sec"
+            ),
+            func.array_agg(ScorekeeperSaveQuality.game_id).label("game_ids"),
+        )
+        .join(Game, Game.id == ScorekeeperSaveQuality.game_id)
+        .filter(
+            Game.status.in_(
+                [FINAL_STATUS, FINAL_SO_STATUS, FORFEIT_STATUS, NOEVENTS_STATUS]
+            )
+        )
+    )
+
+    scorekeeper_quality_stats = (
+        scorekeeper_quality_stats.filter(filter_condition)
+        .group_by(ScorekeeperSaveQuality.scorekeeper_id)
+        .all()
+    )
 
     # Combine the results
     stats_dict = {}
@@ -132,55 +178,79 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, aggre
             stat.avg_max_saves_per_5sec or 0.0,
             stat.avg_max_saves_per_20sec or 0.0,
             stat.peak_max_saves_per_5sec or 0,
-            stat.peak_max_saves_per_20sec or 0
+            stat.peak_max_saves_per_20sec or 0,
         )
 
         stats_dict[key] = {
-            'games_recorded': stat.games_recorded,  # DEPRECATED - for backward compatibility
-            'games_participated': stat.games_participated,  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
-            'games_with_stats': stat.games_with_stats,  # Games with full stats: FINAL, FINAL_SO only
-            'sog_given': stat.total_saves_recorded,  # Legacy field name mapping
-            'sog_per_game': stat.avg_saves_per_game or 0.0,  # Legacy field name mapping
-            'total_saves_recorded': stat.total_saves_recorded,
-            'avg_saves_per_game': stat.avg_saves_per_game or 0.0,
-            'avg_max_saves_per_5sec': stat.avg_max_saves_per_5sec or 0.0,
-            'avg_max_saves_per_20sec': stat.avg_max_saves_per_20sec or 0.0,
-            'peak_max_saves_per_5sec': stat.peak_max_saves_per_5sec or 0,
-            'peak_max_saves_per_20sec': stat.peak_max_saves_per_20sec or 0,
-            'quality_score': quality_score,
-            'game_ids': stat.game_ids,
-            'first_game_id': None,
-            'last_game_id': None
+            "games_recorded": stat.games_recorded,  # DEPRECATED - for backward compatibility
+            "games_participated": stat.games_participated,  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+            "games_with_stats": stat.games_with_stats,  # Games with full stats: FINAL, FINAL_SO only
+            "sog_given": stat.total_saves_recorded,  # Legacy field name mapping
+            "sog_per_game": stat.avg_saves_per_game or 0.0,  # Legacy field name mapping
+            "total_saves_recorded": stat.total_saves_recorded,
+            "avg_saves_per_game": stat.avg_saves_per_game or 0.0,
+            "avg_max_saves_per_5sec": stat.avg_max_saves_per_5sec or 0.0,
+            "avg_max_saves_per_20sec": stat.avg_max_saves_per_20sec or 0.0,
+            "peak_max_saves_per_5sec": stat.peak_max_saves_per_5sec or 0,
+            "peak_max_saves_per_20sec": stat.peak_max_saves_per_20sec or 0,
+            "quality_score": quality_score,
+            "game_ids": stat.game_ids,
+            "first_game_id": None,
+            "last_game_id": None,
         }
 
     # Filter out entries with games_recorded less than min_games
-    stats_dict = {key: value for key, value in stats_dict.items() if value['games_recorded'] >= min_games}
+    stats_dict = {
+        key: value
+        for key, value in stats_dict.items()
+        if value["games_recorded"] >= min_games
+    }
 
     # Populate first_game_id and last_game_id
     for key, stat in stats_dict.items():
-        all_game_ids = stat['game_ids']
+        all_game_ids = stat["game_ids"]
         if all_game_ids:
-            first_game = session.query(Game).filter(Game.id.in_(all_game_ids)).order_by(Game.date, Game.time).first()
-            last_game = session.query(Game).filter(Game.id.in_(all_game_ids)).order_by(Game.date.desc(), Game.time.desc()).first()
-            stat['first_game_id'] = first_game.id if first_game else None
-            stat['last_game_id'] = last_game.id if last_game else None
+            first_game = (
+                session.query(Game)
+                .filter(Game.id.in_(all_game_ids))
+                .order_by(Game.date, Game.time)
+                .first()
+            )
+            last_game = (
+                session.query(Game)
+                .filter(Game.id.in_(all_game_ids))
+                .order_by(Game.date.desc(), Game.time.desc())
+                .first()
+            )
+            stat["first_game_id"] = first_game.id if first_game else None
+            stat["last_game_id"] = last_game.id if last_game else None
 
     # Calculate total_in_rank
     total_in_rank = len(stats_dict)
 
     # Assign ranks - note: for quality metrics, lower values are better (reverse_rank=True for avg and peak clicking)
-    assign_ranks(stats_dict, 'games_recorded')
-    assign_ranks(stats_dict, 'games_participated')  # Rank by total participation
-    assign_ranks(stats_dict, 'games_with_stats')  # Rank by games with full stats
-    assign_ranks(stats_dict, 'sog_given')  # Legacy field
-    assign_ranks(stats_dict, 'sog_per_game')  # Legacy field
-    assign_ranks(stats_dict, 'total_saves_recorded')
-    assign_ranks(stats_dict, 'avg_saves_per_game')
-    assign_ranks(stats_dict, 'avg_max_saves_per_5sec', reverse_rank=True)  # Lower is better (less clicking)
-    assign_ranks(stats_dict, 'avg_max_saves_per_20sec', reverse_rank=True)  # Lower is better
-    assign_ranks(stats_dict, 'peak_max_saves_per_5sec', reverse_rank=True)  # Lower is better
-    assign_ranks(stats_dict, 'peak_max_saves_per_20sec', reverse_rank=True)  # Lower is better
-    assign_ranks(stats_dict, 'quality_score', reverse_rank=True)  # Lower is better (less problematic)
+    assign_ranks(stats_dict, "games_recorded")
+    assign_ranks(stats_dict, "games_participated")  # Rank by total participation
+    assign_ranks(stats_dict, "games_with_stats")  # Rank by games with full stats
+    assign_ranks(stats_dict, "sog_given")  # Legacy field
+    assign_ranks(stats_dict, "sog_per_game")  # Legacy field
+    assign_ranks(stats_dict, "total_saves_recorded")
+    assign_ranks(stats_dict, "avg_saves_per_game")
+    assign_ranks(
+        stats_dict, "avg_max_saves_per_5sec", reverse_rank=True
+    )  # Lower is better (less clicking)
+    assign_ranks(
+        stats_dict, "avg_max_saves_per_20sec", reverse_rank=True
+    )  # Lower is better
+    assign_ranks(
+        stats_dict, "peak_max_saves_per_5sec", reverse_rank=True
+    )  # Lower is better
+    assign_ranks(
+        stats_dict, "peak_max_saves_per_20sec", reverse_rank=True
+    )  # Lower is better
+    assign_ranks(
+        stats_dict, "quality_score", reverse_rank=True
+    )  # Lower is better (less problematic)
 
     # Insert aggregated stats into the appropriate table with progress output
     batch_size = 1000
@@ -189,33 +259,39 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, aggre
         scorekeeper_stat = StatsModel(
             aggregation_id=aggregation_id,
             human_id=human_id,
-            games_recorded=stat['games_recorded'],  # DEPRECATED - for backward compatibility
-            games_participated=stat['games_participated'],  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
-            games_participated_rank=stat['games_participated_rank'],
-            games_with_stats=stat['games_with_stats'],  # Games with full stats: FINAL, FINAL_SO only
-            games_with_stats_rank=stat['games_with_stats_rank'],
-            sog_given=stat['sog_given'],  # Legacy field mapping
-            sog_per_game=stat['sog_per_game'],  # Legacy field mapping
-            total_saves_recorded=stat['total_saves_recorded'],
-            total_saves_recorded_rank=stat['total_saves_recorded_rank'],
-            avg_saves_per_game=stat['avg_saves_per_game'],
-            avg_saves_per_game_rank=stat['avg_saves_per_game_rank'],
-            avg_max_saves_per_5sec=stat['avg_max_saves_per_5sec'],
-            avg_max_saves_per_5sec_rank=stat['avg_max_saves_per_5sec_rank'],
-            avg_max_saves_per_20sec=stat['avg_max_saves_per_20sec'],
-            avg_max_saves_per_20sec_rank=stat['avg_max_saves_per_20sec_rank'],
-            peak_max_saves_per_5sec=stat['peak_max_saves_per_5sec'],
-            peak_max_saves_per_5sec_rank=stat['peak_max_saves_per_5sec_rank'],
-            peak_max_saves_per_20sec=stat['peak_max_saves_per_20sec'],
-            peak_max_saves_per_20sec_rank=stat['peak_max_saves_per_20sec_rank'],
-            quality_score=stat['quality_score'],
-            quality_score_rank=stat['quality_score_rank'],
-            games_recorded_rank=stat['games_recorded_rank'],
-            sog_given_rank=stat['sog_given_rank'],  # Legacy field
-            sog_per_game_rank=stat['sog_per_game_rank'],  # Legacy field
+            games_recorded=stat[
+                "games_recorded"
+            ],  # DEPRECATED - for backward compatibility
+            games_participated=stat[
+                "games_participated"
+            ],  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+            games_participated_rank=stat["games_participated_rank"],
+            games_with_stats=stat[
+                "games_with_stats"
+            ],  # Games with full stats: FINAL, FINAL_SO only
+            games_with_stats_rank=stat["games_with_stats_rank"],
+            sog_given=stat["sog_given"],  # Legacy field mapping
+            sog_per_game=stat["sog_per_game"],  # Legacy field mapping
+            total_saves_recorded=stat["total_saves_recorded"],
+            total_saves_recorded_rank=stat["total_saves_recorded_rank"],
+            avg_saves_per_game=stat["avg_saves_per_game"],
+            avg_saves_per_game_rank=stat["avg_saves_per_game_rank"],
+            avg_max_saves_per_5sec=stat["avg_max_saves_per_5sec"],
+            avg_max_saves_per_5sec_rank=stat["avg_max_saves_per_5sec_rank"],
+            avg_max_saves_per_20sec=stat["avg_max_saves_per_20sec"],
+            avg_max_saves_per_20sec_rank=stat["avg_max_saves_per_20sec_rank"],
+            peak_max_saves_per_5sec=stat["peak_max_saves_per_5sec"],
+            peak_max_saves_per_5sec_rank=stat["peak_max_saves_per_5sec_rank"],
+            peak_max_saves_per_20sec=stat["peak_max_saves_per_20sec"],
+            peak_max_saves_per_20sec_rank=stat["peak_max_saves_per_20sec_rank"],
+            quality_score=stat["quality_score"],
+            quality_score_rank=stat["quality_score_rank"],
+            games_recorded_rank=stat["games_recorded_rank"],
+            sog_given_rank=stat["sog_given_rank"],  # Legacy field
+            sog_per_game_rank=stat["sog_per_game_rank"],  # Legacy field
             total_in_rank=total_in_rank,
-            first_game_id=stat['first_game_id'],
-            last_game_id=stat['last_game_id']
+            first_game_id=stat["first_game_id"],
+            last_game_id=stat["last_game_id"],
         )
         session.add(scorekeeper_stat)
         # Commit in batches
@@ -223,6 +299,7 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, aggre
             session.commit()
     session.commit()
 
+
 def run_aggregate_scorekeeper_stats():
     session = create_session("boss")
     human_id_to_debug = None
@@ -230,6 +307,7 @@ def run_aggregate_scorekeeper_stats():
     # Get all org_id present in the Organization table (following goalie stats pattern)
     # Individual org calls will be skipped by early exit, only ALL_ORGS_ID will process
     from hockey_blast_common_lib.models import Organization
+
     org_ids = session.query(Organization.id).all()
     org_ids = [org_id[0] for org_id in org_ids]
 
@@ -238,18 +316,52 @@ def run_aggregate_scorekeeper_stats():
 
     for org_id in org_ids:
         if human_id_to_debug is None:
-            org_name = "All Organizations" if org_id == ALL_ORGS_ID else session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
-            org_progress = create_progress_tracker(3, f"Processing scorekeeper stats for {org_name}")
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id)
+            org_name = (
+                "All Organizations"
+                if org_id == ALL_ORGS_ID
+                else session.query(Organization.organization_name)
+                .filter(Organization.id == org_id)
+                .scalar()
+                or f"org_id {org_id}"
+            )
+            org_progress = create_progress_tracker(
+                3, f"Processing scorekeeper stats for {org_name}"
+            )
+            aggregate_scorekeeper_stats(
+                session, aggregation_type="org", aggregation_id=org_id
+            )
             org_progress.update(1)
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Weekly')
+            aggregate_scorekeeper_stats(
+                session,
+                aggregation_type="org",
+                aggregation_id=org_id,
+                aggregation_window="Weekly",
+            )
             org_progress.update(2)
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Daily')
+            aggregate_scorekeeper_stats(
+                session,
+                aggregation_type="org",
+                aggregation_id=org_id,
+                aggregation_window="Daily",
+            )
             org_progress.update(3)
         else:
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id)
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Weekly')
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Daily')
+            aggregate_scorekeeper_stats(
+                session, aggregation_type="org", aggregation_id=org_id
+            )
+            aggregate_scorekeeper_stats(
+                session,
+                aggregation_type="org",
+                aggregation_id=org_id,
+                aggregation_window="Weekly",
+            )
+            aggregate_scorekeeper_stats(
+                session,
+                aggregation_type="org",
+                aggregation_id=org_id,
+                aggregation_window="Daily",
+            )
+
 
 if __name__ == "__main__":
-    run_aggregate_scorekeeper_stats()
+    run_aggregate_scorekeeper_stats()