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

hockey_blast_common_lib/aggregate_skater_stats.py

@@ -16,6 +16,53 @@ from hockey_blast_common_lib.utils import get_start_datetime
 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 calculate_current_point_streak(session, human_id, filter_condition):
+    """
+    Calculate the current point streak for a player.
+    A point streak is consecutive games (from the most recent game backward) where the player had at least one point.
+    Returns a tuple: (streak_length, average_points_during_streak)
+    """
+    # Get all games for this player ordered by date/time descending (most recent first)
+    games = session.query(Game).join(GameRoster, Game.id == GameRoster.game_id).filter(
+        GameRoster.human_id == human_id,
+        ~GameRoster.role.ilike('g'),  # Exclude goalie games
+        filter_condition,
+        Game.status.like('Final%')  # Only final games
+    ).order_by(Game.date.desc(), Game.time.desc()).all()
+    
+    if not games:
+        return 0, 0.0
+    
+    current_streak = 0
+    total_points_in_streak = 0
+    
+    for game in games:
+        # Check if the player had any points in this game
+        goals = session.query(Goal).filter(
+            Goal.game_id == game.id,
+            Goal.goal_scorer_id == human_id
+        ).count()
+        
+        assists = session.query(Goal).filter(
+            Goal.game_id == game.id,
+            ((Goal.assist_1_id == human_id) | (Goal.assist_2_id == human_id))
+        ).count()
+        
+        total_points = goals + assists
+        
+        if total_points > 0:
+            current_streak += 1
+            total_points_in_streak += total_points
+        else:
+            # Streak is broken, stop counting
+            break
+    
+    # Calculate average points during streak
+    avg_points_during_streak = total_points_in_streak / current_streak if current_streak > 0 else 0.0
+    
+    return current_streak, avg_points_during_streak
 
 def aggregate_skater_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)
@@ -57,7 +104,12 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     elif aggregation_type == 'level':
         StatsModel = LevelStatsSkater
         min_games = MIN_GAMES_FOR_LEVEL_STATS
-        filter_condition = Division.level_id == aggregation_id
+        # Get division IDs for this level to avoid cartesian product
+        division_ids = session.query(Division.id).filter(Division.level_id == aggregation_id).all()
+        division_ids = [div_id[0] for div_id in division_ids]
+        if not division_ids:
+            return  # No divisions for this level
+        filter_condition = Game.division_id.in_(division_ids)
         # Add filter to only include games for the last 5 years
         # five_years_ago = datetime.now() - timedelta(days=5*365)
         # level_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP) >= five_years_ago
@@ -86,39 +138,65 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     #     human_filter = [GameRoster.human_id == debug_human_id]
 
     # Aggregate games played for each human in each division, excluding goalies
-    games_played_stats = session.query(
+    games_played_query = session.query(
         GameRoster.human_id,
         func.count(Game.id).label('games_played'),
         func.array_agg(Game.id).label('game_ids')
-    ).join(Game, Game.id == GameRoster.game_id).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(GameRoster.human_id).all()
+    ).join(Game, Game.id == GameRoster.game_id)
+    
+    # Only join Division if not level aggregation (since we filter on Game.division_id directly for levels)
+    if aggregation_type != 'level':
+        games_played_query = games_played_query.join(Division, Game.division_id == Division.id)
+    
+    games_played_stats = games_played_query.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(GameRoster.human_id).all()
 
     # Aggregate goals for each human in each division, excluding goalies
-    goals_stats = session.query(
+    goals_query = session.query(
         Goal.goal_scorer_id.label('human_id'),
         func.count(Goal.id).label('goals'),
         func.array_agg(Goal.game_id).label('goal_game_ids')
-    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.goal_scorer_id == GameRoster.human_id)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.goal_scorer_id).all()
+    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.goal_scorer_id == GameRoster.human_id))
+    
+    if aggregation_type != 'level':
+        goals_query = goals_query.join(Division, Game.division_id == Division.id)
+    
+    goals_stats = goals_query.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.goal_scorer_id).all()
 
     # Aggregate assists for each human in each division, excluding goalies
-    assists_stats = session.query(
+    assists_query = session.query(
         Goal.assist_1_id.label('human_id'),
         func.count(Goal.id).label('assists'),
         func.array_agg(Goal.game_id).label('assist_game_ids')
-    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.assist_1_id == GameRoster.human_id)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.assist_1_id).all()
-
-    assists_stats_2 = session.query(
+    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.assist_1_id == GameRoster.human_id))
+    
+    if aggregation_type != 'level':
+        assists_query = assists_query.join(Division, Game.division_id == Division.id)
+    
+    assists_stats = assists_query.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.assist_1_id).all()
+
+    assists_query_2 = session.query(
         Goal.assist_2_id.label('human_id'),
         func.count(Goal.id).label('assists'),
         func.array_agg(Goal.game_id).label('assist_2_game_ids')
-    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.assist_2_id == GameRoster.human_id)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.assist_2_id).all()
+    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.assist_2_id == GameRoster.human_id))
+    
+    if aggregation_type != 'level':
+        assists_query_2 = assists_query_2.join(Division, Game.division_id == Division.id)
+    
+    assists_stats_2 = assists_query_2.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.assist_2_id).all()
 
     # Aggregate penalties for each human in each division, excluding goalies
-    penalties_stats = session.query(
+    penalties_query = session.query(
         Penalty.penalized_player_id.label('human_id'),
         func.count(Penalty.id).label('penalties'),
         func.sum(case((Penalty.penalty_minutes == 'GM', 1), else_=0)).label('gm_penalties'),  # New aggregation for GM penalties
         func.array_agg(Penalty.game_id).label('penalty_game_ids')
-    ).join(Game, Game.id == Penalty.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Penalty.penalized_player_id == GameRoster.human_id)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Penalty.penalized_player_id).all()
+    ).join(Game, Game.id == Penalty.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Penalty.penalized_player_id == GameRoster.human_id))
+    
+    if aggregation_type != 'level':
+        penalties_query = penalties_query.join(Division, Game.division_id == Division.id)
+    
+    penalties_stats = penalties_query.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Penalty.penalized_player_id).all()
 
     # Combine the results
     stats_dict = {}
@@ -139,6 +217,8 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
                 'assists_per_game': 0.0,
                 'penalties_per_game': 0.0,
                 'gm_penalties_per_game': 0.0,  # Initialize GM penalties per game
+                'current_point_streak': 0,  # Initialize current point streak
+                'current_point_streak_avg_points': 0.0,  # Initialize current point streak average points
                 'game_ids': [],
                 'first_game_id': None,
                 'last_game_id': None
@@ -194,6 +274,14 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             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 current point streak (only for all-time stats)
+    if aggregation_window is None:
+        for key, stat in stats_dict.items():
+            aggregation_id, human_id = key
+            streak_length, avg_points = calculate_current_point_streak(session, human_id, filter_condition)
+            stat['current_point_streak'] = streak_length
+            stat['current_point_streak_avg_points'] = avg_points
+
     # Calculate total_in_rank
     total_in_rank = len(stats_dict)
 
@@ -214,6 +302,9 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     assign_ranks(stats_dict, 'assists_per_game')
     assign_ranks(stats_dict, 'penalties_per_game')
     assign_ranks(stats_dict, 'gm_penalties_per_game')  # Assign ranks for GM penalties per game
+    if aggregation_window is None:  # Only assign current_point_streak ranks for all-time stats
+        assign_ranks(stats_dict, 'current_point_streak')
+        assign_ranks(stats_dict, 'current_point_streak_avg_points')
 
     # Debug output for specific human
     if debug_human_id:
@@ -262,6 +353,10 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             penalties_per_game_rank=stat['penalties_per_game_rank'],
             gm_penalties_per_game_rank=stat['gm_penalties_per_game_rank'],  # Include GM penalties per game rank
             total_in_rank=total_in_rank,
+            current_point_streak=stat.get('current_point_streak', 0),
+            current_point_streak_rank=stat.get('current_point_streak_rank', 0),
+            current_point_streak_avg_points=stat.get('current_point_streak_avg_points', 0.0),
+            current_point_streak_avg_points_rank=stat.get('current_point_streak_avg_points_rank', 0),
             first_game_id=stat['first_game_id'],
             last_game_id=stat['last_game_id']
         )
@@ -281,33 +376,51 @@ def run_aggregate_skater_stats():
 
     for org_id in org_ids:
         division_ids = get_all_division_ids_for_org(session, org_id)
-        print(f"Aggregating skater 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_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
-            aggregate_skater_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_skater_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_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
-        aggregate_skater_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_skater_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}"
+        
+        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_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+                aggregate_skater_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_skater_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_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+                aggregate_skater_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_skater_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:
+            org_progress = create_progress_tracker(3, f"Processing org-level stats for {org_name}")
+            aggregate_skater_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_skater_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_skater_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_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            aggregate_skater_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_skater_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]
-    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:
-            print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
-        processed_levels += 1
-        aggregate_skater_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+    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_skater_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_skater_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_skater_stats()

hockey_blast_common_lib/assign_skater_skill.py

@@ -6,43 +6,53 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from hockey_blast_common_lib.models import Human, Level
 from hockey_blast_common_lib.stats_models import LevelStatsSkater
 from hockey_blast_common_lib.db_connection import create_session
-from sqlalchemy.sql import func
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
 
-def calculate_skater_skill_value(session, human_id, level_stats):
-    max_skill_value = 0
+def calculate_skater_skill_value(session, level_stats):
+    min_skill_value = float('inf')  # Start with infinity since we want the minimum
 
     for stat in level_stats:
         level = session.query(Level).filter(Level.id == stat.level_id).first()
         if not level or level.skill_value < 0:
             continue
         level_skill_value = level.skill_value
-        ppg_ratio = stat.points_per_game_rank / stat.total_in_rank
-        games_played_ratio = stat.games_played_rank / stat.total_in_rank
-
-        # Take the maximum of the two ratios
-        skill_value = level_skill_value * max(ppg_ratio, games_played_ratio)
-        max_skill_value = max(max_skill_value, skill_value)
-
-    return max_skill_value
+        
+        # Fix critical bug: Invert rank ratios so better players (lower ranks) get higher skill values
+        # Rank 1 (best) should get factor close to 1.0, worst rank should get factor close to 0.0
+        if stat.total_in_rank > 1:
+            ppg_skill_factor = 1 - (stat.points_per_game_rank - 1) / (stat.total_in_rank - 1)
+        else:
+            ppg_skill_factor = 1.0  # Only one player in level
+        
+        # Apply skill adjustment: range from 0.8 to 1.2 of level base skill
+        # Since lower skill_value is better: Best player gets 0.8x (closer to better levels), worst gets 1.2x
+        skill_adjustment = 1.2 - 0.4 * ppg_skill_factor
+        skill_value = level_skill_value * skill_adjustment
+        
+        # Take the minimum skill value across all levels the player has played in (lower is better)
+        min_skill_value = min(min_skill_value, skill_value)
+
+    return min_skill_value if min_skill_value != float('inf') else 0
 
 def assign_skater_skill_values():
     session = create_session("boss")
 
     humans = session.query(Human).all()
     total_humans = len(humans)
-    processed_humans = 0
+    
+    # Create progress tracker
+    progress = create_progress_tracker(total_humans, "Assigning skater skill values")
 
-    for human in humans:
+    for i, human in enumerate(humans):
         level_stats = session.query(LevelStatsSkater).filter(LevelStatsSkater.human_id == human.id).all()
         if level_stats:
-            skater_skill_value = calculate_skater_skill_value(session, human.id, level_stats)
+            skater_skill_value = calculate_skater_skill_value(session, level_stats)
             human.skater_skill_value = skater_skill_value
             session.commit()
 
-        processed_humans += 1
-        print(f"\rProcessed {processed_humans}/{total_humans} humans ({(processed_humans/total_humans)*100:.2f}%)", end="")
+        progress.update(i + 1)
 
-    print("\nSkater skill values have been assigned to all humans.")
+    print("Skater skill values have been assigned to all humans.")
 
 if __name__ == "__main__":
     assign_skater_skill_values()

hockey_blast_common_lib/h2h_models.py

@@ -0,0 +1,107 @@
+from hockey_blast_common_lib.models import db
+
+class H2HStats(db.Model):
+    __tablename__ = 'h2h_stats'
+    id = db.Column(db.Integer, primary_key=True)
+    human1_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    human2_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    # Always store with human1_id < human2_id for uniqueness
+    __table_args__ = (
+        db.UniqueConstraint('human1_id', 'human2_id', name='_h2h_human_pair_uc'),
+        db.Index('ix_h2h_human_pair', 'human1_id', 'human2_id'),  # Composite index for fast lookup
+    )
+
+    # General
+    games_together = db.Column(db.Integer, default=0, nullable=False)  # Games where both played (any role, any team)
+    games_against = db.Column(db.Integer, default=0, nullable=False)   # Games where both played on opposing teams
+    games_tied_together = db.Column(db.Integer, default=0, nullable=False)
+    games_tied_against = db.Column(db.Integer, default=0, nullable=False)   # Games against each other that ended in a tie
+    wins_together = db.Column(db.Integer, default=0, nullable=False)   # Games both played on same team and won
+    losses_together = db.Column(db.Integer, default=0, nullable=False) # Games both played on same team and lost
+    h1_wins_vs_h2 = db.Column(db.Integer, default=0, nullable=False)   # Games h1's team won vs h2's team
+    h2_wins_vs_h1 = db.Column(db.Integer, default=0, nullable=False)   # Games h2's team won vs h1's team
+
+    # Role-specific counts
+    games_h1_goalie = db.Column(db.Integer, default=0, nullable=False)  # Games where h1 was a goalie and h2 played
+    games_h2_goalie = db.Column(db.Integer, default=0, nullable=False)  # Games where h2 was a goalie and h1 played
+    games_h1_ref = db.Column(db.Integer, default=0, nullable=False)     # Games where h1 was a referee and h2 played
+    games_h2_ref = db.Column(db.Integer, default=0, nullable=False)     # Games where h2 was a referee and h1 played
+    games_both_referees = db.Column(db.Integer, default=0, nullable=False) # Games where both were referees
+
+    # Goals/Assists/Penalties (when both played)
+    goals_h1_when_together = db.Column(db.Integer, default=0, nullable=False)    # Goals by h1 when both played
+    goals_h2_when_together = db.Column(db.Integer, default=0, nullable=False)    # Goals by h2 when both played
+    assists_h1_when_together = db.Column(db.Integer, default=0, nullable=False)  # Assists by h1 when both played
+    assists_h2_when_together = db.Column(db.Integer, default=0, nullable=False)  # Assists by h2 when both played
+    penalties_h1_when_together = db.Column(db.Integer, default=0, nullable=False) # Penalties on h1 when both played
+    penalties_h2_when_together = db.Column(db.Integer, default=0, nullable=False) # Penalties on h2 when both played
+    gm_penalties_h1_when_together = db.Column(db.Integer, default=0, nullable=False) # GM penalties on h1 when both played
+    gm_penalties_h2_when_together = db.Column(db.Integer, default=0, nullable=False) # GM penalties on h2 when both played
+
+    # Goalie/Skater head-to-head (when one is goalie, other is skater on opposing team)
+    h1_goalie_h2_scorer_goals = db.Column(db.Integer, default=0, nullable=False) # Goals scored by h2 against h1 as goalie
+    h2_goalie_h1_scorer_goals = db.Column(db.Integer, default=0, nullable=False) # Goals scored by h1 against h2 as goalie
+    shots_faced_h1_goalie_vs_h2 = db.Column(db.Integer, default=0, nullable=False) # Shots faced by h1 as goalie vs h2 as skater
+    shots_faced_h2_goalie_vs_h1 = db.Column(db.Integer, default=0, nullable=False) # Shots faced by h2 as goalie vs h1 as skater
+    goals_allowed_h1_goalie_vs_h2 = db.Column(db.Integer, default=0, nullable=False) # Goals allowed by h1 as goalie vs h2 as skater
+    goals_allowed_h2_goalie_vs_h1 = db.Column(db.Integer, default=0, nullable=False) # Goals allowed by h2 as goalie vs h1 as skater
+    save_percentage_h1_goalie_vs_h2 = db.Column(db.Float, default=0.0, nullable=False) # Save % by h1 as goalie vs h2 as skater
+    save_percentage_h2_goalie_vs_h1 = db.Column(db.Float, default=0.0, nullable=False) # Save % by h2 as goalie vs h1 as skater
+
+    # Referee/Player
+    h1_ref_h2_player_games = db.Column(db.Integer, default=0, nullable=False)    # Games h1 was referee, h2 was player
+    h2_ref_h1_player_games = db.Column(db.Integer, default=0, nullable=False)    # Games h2 was referee, h1 was player
+    h1_ref_penalties_on_h2 = db.Column(db.Integer, default=0, nullable=False)    # Penalties given by h1 (as ref) to h2
+    h2_ref_penalties_on_h1 = db.Column(db.Integer, default=0, nullable=False)    # Penalties given by h2 (as ref) to h1
+    h1_ref_gm_penalties_on_h2 = db.Column(db.Integer, default=0, nullable=False) # GM penalties given by h1 (as ref) to h2
+    h2_ref_gm_penalties_on_h1 = db.Column(db.Integer, default=0, nullable=False) # GM penalties given by h2 (as ref) to h1
+
+    # Both referees (when both are referees in the same game)
+    penalties_given_both_refs = db.Column(db.Integer, default=0, nullable=False)     # Total penalties given by both
+    gm_penalties_given_both_refs = db.Column(db.Integer, default=0, nullable=False)  # Total GM penalties given by both
+
+    # Shootouts
+    h1_shootout_attempts_vs_h2_goalie = db.Column(db.Integer, default=0, nullable=False) # h1 shootout attempts vs h2 as goalie
+    h1_shootout_goals_vs_h2_goalie = db.Column(db.Integer, default=0, nullable=False)    # h1 shootout goals vs h2 as goalie
+    h2_shootout_attempts_vs_h1_goalie = db.Column(db.Integer, default=0, nullable=False) # h2 shootout attempts vs h1 as goalie
+    h2_shootout_goals_vs_h1_goalie = db.Column(db.Integer, default=0, nullable=False)    # h2 shootout goals vs h1 as goalie
+
+    # First and last game IDs where both were present
+    first_game_id = db.Column(db.Integer, nullable=False)  # Game.id of the first game where both were present
+    last_game_id = db.Column(db.Integer, nullable=False)   # Game.id of the most recent game where both were present
+
+class H2HStatsMeta(db.Model):
+    __tablename__ = 'h2h_stats_meta'
+    id = db.Column(db.Integer, primary_key=True)
+    last_run_timestamp = db.Column(db.DateTime, nullable=True)  # When the h2h stats were last updated
+    last_processed_game_id = db.Column(db.Integer, nullable=True)  # Game.id of the latest processed game
+
+class SkaterToSkaterStats(db.Model):
+    __tablename__ = 'skater_to_skater_stats'
+    id = db.Column(db.Integer, primary_key=True)
+    skater1_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    skater2_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    __table_args__ = (
+        db.UniqueConstraint('skater1_id', 'skater2_id', name='_s2s_skater_pair_uc'),
+        db.Index('ix_s2s_skater_pair', 'skater1_id', 'skater2_id'),
+    )
+
+    # General stats
+    games_against = db.Column(db.Integer, default=0, nullable=False)
+    games_tied_against = db.Column(db.Integer, default=0, nullable=False)
+    skater1_wins_vs_skater2 = db.Column(db.Integer, default=0, nullable=False)
+    skater2_wins_vs_skater1 = db.Column(db.Integer, default=0, nullable=False)
+
+    # Cumulative stats
+    skater1_goals_against_skater2 = db.Column(db.Integer, default=0, nullable=False)
+    skater2_goals_against_skater1 = db.Column(db.Integer, default=0, nullable=False)
+    skater1_assists_against_skater2 = db.Column(db.Integer, default=0, nullable=False)
+    skater2_assists_against_skater1 = db.Column(db.Integer, default=0, nullable=False)
+    skater1_penalties_against_skater2 = db.Column(db.Integer, default=0, nullable=False)
+    skater2_penalties_against_skater1 = db.Column(db.Integer, default=0, nullable=False)
+
+class SkaterToSkaterStatsMeta(db.Model):
+    __tablename__ = 'skater_to_skater_stats_meta'
+    id = db.Column(db.Integer, primary_key=True)
+    last_run_timestamp = db.Column(db.DateTime, nullable=True)
+    last_processed_game_id = db.Column(db.Integer, nullable=True)

hockey_blast_common_lib/models.py

@@ -351,6 +351,7 @@ class RequestLog(db.Model):
     path = db.Column(db.String, nullable=False)
     timestamp = db.Column(db.DateTime, nullable=False)
     cgi_params = db.Column(db.String, nullable=True)
+    response_time_ms = db.Column(db.Float, nullable=True)  # Response time in milliseconds
 
 # # MANUAL AMENDS HAPPEN HERE :)
 # from db_connection import create_session

hockey_blast_common_lib/progress_utils.py

@@ -0,0 +1,91 @@
+import time
+from datetime import datetime, timedelta
+
+class ProgressTracker:
+    """
+    Reusable progress tracker with ETA calculation for stats aggregation processes.
+    """
+    
+    def __init__(self, total_items, description="Processing"):
+        self.total_items = total_items
+        self.description = description
+        self.start_time = time.time()
+        self.processed_items = 0
+        self.last_update_time = self.start_time
+        
+    def update(self, processed_count=None):
+        """
+        Update progress. If processed_count is None, increment by 1.
+        """
+        if processed_count is not None:
+            self.processed_items = processed_count
+        else:
+            self.processed_items += 1
+            
+        current_time = time.time()
+        
+        # Only update display if at least 0.1 seconds have passed (to avoid spamming)
+        if current_time - self.last_update_time >= 0.1 or self.processed_items == self.total_items:
+            self._display_progress()
+            self.last_update_time = current_time
+            
+    def _display_progress(self):
+        """
+        Display progress with percentage, ETA, and elapsed time.
+        """
+        current_time = time.time()
+        elapsed_time = current_time - self.start_time
+        
+        if self.processed_items == 0:
+            percentage = 0.0
+            eta_str = "calculating..."
+        else:
+            percentage = (self.processed_items / self.total_items) * 100
+            
+            # Calculate ETA
+            if self.processed_items == self.total_items:
+                eta_str = "completed!"
+            else:
+                avg_time_per_item = elapsed_time / self.processed_items
+                remaining_items = self.total_items - self.processed_items
+                eta_seconds = avg_time_per_item * remaining_items
+                eta_str = self._format_time(eta_seconds)
+        
+        elapsed_str = self._format_time(elapsed_time)
+        
+        progress_msg = f"\r{self.description}: {self.processed_items}/{self.total_items} ({percentage:.1f}%) | "
+        progress_msg += f"Elapsed: {elapsed_str} | ETA: {eta_str}"
+        
+        print(progress_msg, end="", flush=True)
+        
+        # Add newline when complete
+        if self.processed_items == self.total_items:
+            print()  # Newline to finish the progress line
+    
+    def _format_time(self, seconds):
+        """
+        Format seconds into a human-readable string.
+        """
+        if seconds < 60:
+            return f"{seconds:.1f}s"
+        elif seconds < 3600:
+            minutes = int(seconds // 60)
+            secs = int(seconds % 60)
+            return f"{minutes}m {secs}s"
+        else:
+            hours = int(seconds // 3600)
+            minutes = int((seconds % 3600) // 60)
+            return f"{hours}h {minutes}m"
+    
+    def finish(self):
+        """
+        Mark progress as complete and add final newline.
+        """
+        self.processed_items = self.total_items
+        self._display_progress()
+
+def create_progress_tracker(total_items, description="Processing"):
+    """
+    Factory function to create a progress tracker.
+    """
+    return ProgressTracker(total_items, description)