hockey-blast-common-lib 0.1.50__py3-none-any.whl → 0.1.53__py3-none-any.whl

hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -16,6 +16,7 @@ from hockey_blast_common_lib.utils import assign_ranks
 from sqlalchemy import func, case, and_
 from collections import defaultdict
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
 
 def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_filter_out, debug_human_id=None, aggregation_window=None):
     human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
@@ -190,33 +191,51 @@ def run_aggregate_goalie_stats():
 
     for org_id in org_ids:
         division_ids = get_all_division_ids_for_org(session, org_id)
-        print(f"Aggregating goalie stats for {len(division_ids)} divisions in org_id {org_id}...")
-        total_divisions = len(division_ids)
-        processed_divisions = 0
-        for division_id in division_ids:
-            aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
-            aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
-            aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
-            processed_divisions += 1
-            if human_id_to_debug is None:
-                print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
-
-        aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
-        aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
-        aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+        org_name = session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
         
-        # Aggregate by level
-    level_ids = session.query(Division.level_id).distinct().all()
-    level_ids = [level_id[0] for level_id in level_ids]
-    total_levels = len(level_ids)
-    processed_levels = 0
-    for level_id in level_ids:
-        if level_id is None:
-            continue
+        if human_id_to_debug is None and division_ids:
+            # Process divisions with progress tracking
+            progress = create_progress_tracker(len(division_ids), f"Processing {len(division_ids)} divisions for {org_name}")
+            for i, division_id in enumerate(division_ids):
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+                progress.update(i + 1)
+        else:
+            # Debug mode or no divisions - process without progress tracking
+            for division_id in division_ids:
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+
+        # Process org-level stats with progress tracking
         if human_id_to_debug is None:
-            print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
-        processed_levels += 1
-        aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            org_progress = create_progress_tracker(3, f"Processing org-level stats for {org_name}")
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            org_progress.update(1)
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+            org_progress.update(2)
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+            org_progress.update(3)
+        else:
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+        
+    # Aggregate by level
+    level_ids = session.query(Division.level_id).distinct().all()
+    level_ids = [level_id[0] for level_id in level_ids if level_id[0] is not None]
+    
+    if human_id_to_debug is None and level_ids:
+        # Process levels with progress tracking
+        level_progress = create_progress_tracker(len(level_ids), f"Processing {len(level_ids)} skill levels")
+        for i, level_id in enumerate(level_ids):
+            aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            level_progress.update(i + 1)
+    else:
+        # Debug mode or no levels - process without progress tracking
+        for level_id in level_ids:
+            aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
 
 if __name__ == "__main__":
     run_aggregate_goalie_stats()

hockey_blast_common_lib/aggregate_h2h_stats.py

@@ -0,0 +1,231 @@
+import sys, os
+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, GameRoster, Goal, Penalty
+from hockey_blast_common_lib.h2h_models import H2HStats, H2HStatsMeta
+from hockey_blast_common_lib.db_connection import create_session
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
+from sqlalchemy.sql import func
+from sqlalchemy import types
+
+# Max games to process (set to None to process all)
+MAX_GAMES_TO_PROCESS = None  # Set to None to process all games
+
+def aggregate_h2h_stats():
+    session = create_session("boss")
+    meta = None #session.query(H2HStatsMeta).order_by(H2HStatsMeta.id.desc()).first()
+    h2h_stats_dict = {}  # (h1, h2) -> H2HStats instance
+    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(H2HStats).delete()
+        session.commit()
+        games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
+        print("No previous run found, deleted all existing H2H stats, processing all games...")
+    else:
+        # Incremental: only process games after last processed
+        # Load all existing stats into memory
+        for stat in session.query(H2HStats).all():
+            h2h_stats_dict[(stat.human1_id, stat.human2_id)] = stat
+        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})...")
+        else:
+            games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
+            print("Previous game id not found, processing all games...")
+
+    total_games = games_query.count()
+    print(f"Total games to process: {total_games}")
+    
+    # Create progress tracker
+    progress = create_progress_tracker(total_games, "Processing H2H stats")
+    processed = 0
+    latest_game_id = None
+    for game in games_query:
+        if MAX_GAMES_TO_PROCESS is not None and processed >= MAX_GAMES_TO_PROCESS:
+            break
+        # --- Gather all relevant data for this game ---
+        # Get all GameRoster entries for this game
+        rosters = session.query(GameRoster).filter(GameRoster.game_id == game.id).all()
+        # Map: team_id -> set of human_ids (players)
+        team_to_players = {}
+        human_roles = {}  # human_id -> set of roles in this game
+        for roster in rosters:
+            team_to_players.setdefault(roster.team_id, set()).add(roster.human_id)
+            human_roles.setdefault(roster.human_id, set()).add(roster.role)
+        # Get all human_ids in this game
+        all_humans = set(human_roles.keys())
+        # Add goalies from Game table (home/visitor)
+        if game.home_goalie_id:
+            all_humans.add(game.home_goalie_id)
+            human_roles.setdefault(game.home_goalie_id, set()).add('G')
+        if game.visitor_goalie_id:
+            all_humans.add(game.visitor_goalie_id)
+            human_roles.setdefault(game.visitor_goalie_id, set()).add('G')
+        # Add referees from Game table (NOT from roster!)
+        if game.referee_1_id:
+            all_humans.add(game.referee_1_id)
+            human_roles.setdefault(game.referee_1_id, set()).add('R')
+        if game.referee_2_id:
+            all_humans.add(game.referee_2_id)
+            human_roles.setdefault(game.referee_2_id, set()).add('R')
+        # --- Build all pairs of humans in this game ---
+        all_humans = list(all_humans)
+        for i in range(len(all_humans)):
+            for j in range(i+1, len(all_humans)):
+                h1, h2 = sorted([all_humans[i], all_humans[j]])
+                key = (h1, h2)
+                h2h = h2h_stats_dict.get(key)
+                if not h2h:
+                    h2h = H2HStats(
+                        human1_id=h1,
+                        human2_id=h2,
+                        first_game_id=game.id,
+                        last_game_id=game.id,
+                        games_together=0,
+                        games_against=0,
+                        games_tied_together=0,
+                        games_tied_against=0,
+                        wins_together=0,
+                        losses_together=0,
+                        h1_wins_vs_h2=0,
+                        h2_wins_vs_h1=0,
+                        games_h1_goalie=0,
+                        games_h2_goalie=0,
+                        games_h1_ref=0,
+                        games_h2_ref=0,
+                        games_both_referees=0,
+                        goals_h1_when_together=0,
+                        goals_h2_when_together=0,
+                        assists_h1_when_together=0,
+                        assists_h2_when_together=0,
+                        penalties_h1_when_together=0,
+                        penalties_h2_when_together=0,
+                        gm_penalties_h1_when_together=0,
+                        gm_penalties_h2_when_together=0,
+                        h1_goalie_h2_scorer_goals=0,
+                        h2_goalie_h1_scorer_goals=0,
+                        shots_faced_h1_goalie_vs_h2=0,
+                        shots_faced_h2_goalie_vs_h1=0,
+                        goals_allowed_h1_goalie_vs_h2=0,
+                        goals_allowed_h2_goalie_vs_h1=0,
+                        save_percentage_h1_goalie_vs_h2=0.0,
+                        save_percentage_h2_goalie_vs_h1=0.0,
+                        h1_ref_h2_player_games=0,
+                        h2_ref_h1_player_games=0,
+                        h1_ref_penalties_on_h2=0,
+                        h2_ref_penalties_on_h1=0,
+                        h1_ref_gm_penalties_on_h2=0,
+                        h2_ref_gm_penalties_on_h1=0,
+                        penalties_given_both_refs=0,
+                        gm_penalties_given_both_refs=0,
+                        h1_shootout_attempts_vs_h2_goalie=0,
+                        h1_shootout_goals_vs_h2_goalie=0,
+                        h2_shootout_attempts_vs_h1_goalie=0,
+                        h2_shootout_goals_vs_h1_goalie=0
+                    )
+                    h2h_stats_dict[key] = h2h
+                # Update first/last game ids
+                if game.id < h2h.first_game_id:
+                    h2h.first_game_id = game.id
+                if game.id > h2h.last_game_id:
+                    h2h.last_game_id = game.id
+                # --- Determine roles and teams ---
+                h1_roles = human_roles.get(h1, set())
+                h2_roles = human_roles.get(h2, set())
+                h1_team = None
+                h2_team = None
+                for team_id, players in team_to_players.items():
+                    if h1 in players:
+                        h1_team = team_id
+                    if h2 in players:
+                        h2_team = team_id
+                # --- General stats ---
+                h2h.games_together += 1  # Both present in this game
+                if h1_team and h2_team:
+                    if h1_team == h2_team:
+                        h2h.wins_together += int(_is_win(game, h1_team))
+                        h2h.losses_together += int(_is_loss(game, h1_team))
+                        if _is_tie(game):
+                            h2h.games_tied_together += 1
+                    else:
+                        h2h.games_against += 1
+                        if _is_win(game, h1_team):
+                            h2h.h1_wins_vs_h2 += 1
+                        if _is_win(game, h2_team):
+                            h2h.h2_wins_vs_h1 += 1
+                        if _is_tie(game):
+                            h2h.games_tied_against += 1
+                # --- Role-specific stats ---
+                if 'G' in h1_roles:
+                    h2h.games_h1_goalie += 1
+                if 'G' in h2_roles:
+                    h2h.games_h2_goalie += 1
+                if 'R' in h1_roles:
+                    h2h.games_h1_ref += 1
+                if 'R' in h2_roles:
+                    h2h.games_h2_ref += 1
+                if 'R' in h1_roles and 'R' in h2_roles:
+                    h2h.games_both_referees += 1
+                # --- Goals, assists, penalties ---
+                # Goals
+                goals = session.query(Goal).filter(Goal.game_id == game.id).all()
+                for goal in goals:
+                    if goal.goal_scorer_id == h1 and (goal.assist_1_id == h2 or goal.assist_2_id == h2):
+                        h2h.goals_h1_when_together += 1
+                    if goal.goal_scorer_id == h2 and (goal.assist_1_id == h1 or goal.assist_2_id == h1):
+                        h2h.goals_h2_when_together += 1
+                # Penalties
+                penalties = session.query(Penalty).filter(Penalty.game_id == game.id).all()
+                for pen in penalties:
+                    if pen.penalized_player_id == h1:
+                        h2h.penalties_h1_when_together += 1
+                        if pen.penalty_minutes and 'GM' in pen.penalty_minutes:
+                            h2h.gm_penalties_h1_when_together += 1
+                    if pen.penalized_player_id == h2:
+                        h2h.penalties_h2_when_together += 1
+                        if pen.penalty_minutes and 'GM' in pen.penalty_minutes:
+                            h2h.gm_penalties_h2_when_together += 1
+                # --- TODO: Add more detailed logic for goalie/skater, referee/player, shootouts, etc. ---
+        latest_game_id = game.id
+        processed += 1
+        progress.update(processed)
+    # Commit all stats at once
+    session.query(H2HStats).delete()
+    session.add_all(list(h2h_stats_dict.values()))
+    session.commit()
+    # Save/update meta
+    meta = H2HStatsMeta(
+        last_run_timestamp=datetime.utcnow(),
+        last_processed_game_id=latest_game_id
+    )
+    session.add(meta)
+    session.commit()
+    print("H2H aggregation complete.")
+
+# --- Helper functions for win/loss/tie ---
+def _is_win(game, team_id):
+    if team_id == game.home_team_id:
+        return (game.home_final_score or 0) > (game.visitor_final_score or 0)
+    if team_id == game.visitor_team_id:
+        return (game.visitor_final_score or 0) > (game.home_final_score or 0)
+    return False
+
+def _is_loss(game, team_id):
+    if team_id == game.home_team_id:
+        return (game.home_final_score or 0) < (game.visitor_final_score or 0)
+    if team_id == game.visitor_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)
+
+if __name__ == "__main__":
+    aggregate_h2h_stats()

hockey_blast_common_lib/aggregate_human_stats.py

@@ -15,6 +15,7 @@ from hockey_blast_common_lib.utils import get_fake_human_for_stats, get_org_id_f
 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.progress_utils import create_progress_tracker
 
 def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_filter_out, human_id_filter=None, aggregation_window=None):
     human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
@@ -425,35 +426,53 @@ def run_aggregate_human_stats():
     org_ids = session.query(Organization.id).all()
     org_ids = [org_id[0] for org_id in org_ids]
 
-    for org_id in [-1]:#org_ids:
+    for org_id in org_ids:
         division_ids = get_all_division_ids_for_org(session, org_id)
-        print(f"Aggregating human stats for {len(division_ids)} divisions in org_id {org_id}...")
-        total_divisions = len(division_ids)
-        processed_divisions = 0
-        for division_id in division_ids:
-            aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
-            aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
-            aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
-            processed_divisions += 1
-            if human_id_to_debug is None:
-                print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
-        print("")
-        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
-        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
-        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+        org_name = session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
         
-        # Aggregate by level
-    level_ids = session.query(Division.level_id).distinct().all()
-    level_ids = [level_id[0] for level_id in level_ids]
-    total_levels = len(level_ids)
-    processed_levels = 0
-    for level_id in level_ids:
-        if level_id is None:
-            continue
+        if human_id_to_debug is None and division_ids:
+            # Process divisions with progress tracking
+            progress = create_progress_tracker(len(division_ids), f"Processing {len(division_ids)} divisions for {org_name}")
+            for i, division_id in enumerate(division_ids):
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+                progress.update(i + 1)
+        else:
+            # Debug mode or no divisions - process without progress tracking
+            for division_id in division_ids:
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+
+        # Process org-level stats with progress tracking
         if human_id_to_debug is None:
-            print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
-        processed_levels += 1
-        aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            org_progress = create_progress_tracker(3, f"Processing org-level stats for {org_name}")
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            org_progress.update(1)
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+            org_progress.update(2)
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+            org_progress.update(3)
+        else:
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+        
+    # Aggregate by level
+    level_ids = session.query(Division.level_id).distinct().all()
+    level_ids = [level_id[0] for level_id in level_ids if level_id[0] is not None]
+    
+    if human_id_to_debug is None and level_ids:
+        # Process levels with progress tracking
+        level_progress = create_progress_tracker(len(level_ids), f"Processing {len(level_ids)} skill levels")
+        for i, level_id in enumerate(level_ids):
+            aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            level_progress.update(i + 1)
+    else:
+        # Debug mode or no levels - process without progress tracking
+        for level_id in level_ids:
+            aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
 
 if __name__ == "__main__":
     run_aggregate_human_stats()

hockey_blast_common_lib/aggregate_referee_stats.py

@@ -15,6 +15,7 @@ from hockey_blast_common_lib.utils import get_org_id_from_alias, get_human_ids_b
 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.progress_utils import create_progress_tracker
 
 def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_filter_out, aggregation_window=None):
     human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
@@ -214,33 +215,51 @@ def run_aggregate_referee_stats():
 
     for org_id in org_ids:
         division_ids = get_all_division_ids_for_org(session, org_id)
-        print(f"Aggregating referee stats for {len(division_ids)} divisions in org_id {org_id}...")
-        total_divisions = len(division_ids)
-        processed_divisions = 0
-        for division_id in division_ids:
-            aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names)
-            aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
-            aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
-            processed_divisions += 1
-            if human_id_to_debug is None:
-                print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
-
-        aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names)
-        aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
-        aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+        org_name = session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
         
-        # Aggregate by level
-    level_ids = session.query(Division.level_id).distinct().all()
-    level_ids = [level_id[0] for level_id in level_ids]
-    total_levels = len(level_ids)
-    processed_levels = 0
-    for level_id in level_ids:
-        if level_id is None:
-            continue
+        if human_id_to_debug is None and division_ids:
+            # Process divisions with progress tracking
+            progress = create_progress_tracker(len(division_ids), f"Processing {len(division_ids)} divisions for {org_name}")
+            for i, division_id in enumerate(division_ids):
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names)
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+                progress.update(i + 1)
+        else:
+            # Debug mode or no divisions - process without progress tracking
+            for division_id in division_ids:
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names)
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+
+        # Process org-level stats with progress tracking
         if human_id_to_debug is None:
-            print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
-        processed_levels += 1
-        aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names)
+            org_progress = create_progress_tracker(3, f"Processing org-level stats for {org_name}")
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names)
+            org_progress.update(1)
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+            org_progress.update(2)
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+            org_progress.update(3)
+        else:
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names)
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+        
+    # Aggregate by level
+    level_ids = session.query(Division.level_id).distinct().all()
+    level_ids = [level_id[0] for level_id in level_ids if level_id[0] is not None]
+    
+    if human_id_to_debug is None and level_ids:
+        # Process levels with progress tracking
+        level_progress = create_progress_tracker(len(level_ids), f"Processing {len(level_ids)} skill levels")
+        for i, level_id in enumerate(level_ids):
+            aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names)
+            level_progress.update(i + 1)
+    else:
+        # Debug mode or no levels - process without progress tracking
+        for level_id in level_ids:
+            aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names)
 
 if __name__ == "__main__":
     run_aggregate_referee_stats()

hockey_blast_common_lib/aggregate_s2s_stats.py

@@ -0,0 +1,143 @@
+import sys, os
+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
+
+# 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()
+    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:
+        # 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...")
+    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()
+        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})...")
+        else:
+            games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
+            print("Previous game id not found, processing all games...")
+
+    total_games = games_query.count()
+    print(f"Total games to process: {total_games}")
+    processed = 0
+    latest_game_id = None
+
+    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:
+            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]:
+                    continue
+
+                s1, s2 = sorted([h_skater, a_skater])
+                key = (s1, s2)
+                s2s = s2s_stats_dict.get(key)
+                if not s2s:
+                    s2s = SkaterToSkaterStats(
+                        skater1_id=s1,
+                        skater2_id=s2,
+                        games_against=0,
+                        games_tied_against=0,
+                        skater1_wins_vs_skater2=0,
+                        skater2_wins_vs_skater1=0,
+                        skater1_goals_against_skater2=0,
+                        skater2_goals_against_skater1=0,
+                        skater1_assists_against_skater2=0,
+                        skater2_assists_against_skater1=0,
+                        skater1_penalties_against_skater2=0,
+                        skater2_penalties_against_skater1=0
+                    )
+                    s2s_stats_dict[key] = s2s
+
+                # Update stats
+                s2s.games_against += 1
+                if _is_tie(game):
+                    s2s.games_tied_against += 1
+                elif _is_win(game, s1, game.home_team_id):
+                    s2s.skater1_wins_vs_skater2 += 1
+                elif _is_win(game, s2, game.visitor_team_id):
+                    s2s.skater2_wins_vs_skater1 += 1
+
+                # Goals and assists
+                goals_stats = session.query(Goal).filter(Goal.game_id == game.id).all()
+                for goal in goals_stats:
+                    if goal.goal_scorer_id == s1:
+                        s2s.skater1_goals_against_skater2 += 1
+                    if goal.goal_scorer_id == s2:
+                        s2s.skater2_goals_against_skater1 += 1
+                    if goal.assist_1_id == s1 or goal.assist_2_id == s1:
+                        s2s.skater1_assists_against_skater2 += 1
+                    if goal.assist_1_id == s2 or goal.assist_2_id == s2:
+                        s2s.skater2_assists_against_skater1 += 1
+
+                # Penalties
+                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
+                    if penalty.penalized_player_id == s2:
+                        s2s.skater2_penalties_against_skater1 += 1
+
+        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="")
+            sys.stdout.flush()
+
+    # Commit all stats at once
+    session.query(SkaterToSkaterStats).delete()
+    session.add_all(list(s2s_stats_dict.values()))
+    session.commit()
+    print(f"\rProcessed {processed}/{total_games} games (100.00%)")
+
+    # Save/update meta
+    meta = SkaterToSkaterStatsMeta(
+        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:
+        return (game.home_final_score or 0) > (game.visitor_final_score or 0)
+    if team_id == game.visitor_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)
+
+if __name__ == "__main__":
+    aggregate_s2s_stats()