hockey-blast-common-lib 0.1.62__tar.gz → 0.1.63__tar.gz

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hockey-blast-common-lib
-Version: 0.1.62
+Version: 0.1.63
 Summary: Common library for shared functionality and DB models
 Author: Pavel Kletskov
 Author-email: kletskov@gmail.com

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -78,23 +78,19 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, debug_huma
 
 
     # Aggregate games played, goals allowed, and shots faced for each goalie using GoalieSaves table
-    # games_participated: Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
-    # games_with_stats: Count only FINAL, FINAL_SO (for per-game averages)
+    # Filter games by status upfront for performance (avoid CASE statements)
+    # Only count games with these statuses: FINAL, FINAL_SO, FORFEIT, NOEVENTS
     query = session.query(
         GoalieSaves.goalie_id.label('human_id'),
-        func.count(GoalieSaves.game_id).label('games_played'),  # 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.count(GoalieSaves.game_id).label('games_played'),
+        func.count(GoalieSaves.game_id).label('games_participated'),  # Same as games_played after filtering
+        func.count(GoalieSaves.game_id).label('games_with_stats'),  # Same as games_played after filtering
         func.sum(GoalieSaves.goals_allowed).label('goals_allowed'),
         func.sum(GoalieSaves.shots_against).label('shots_faced'),
         func.array_agg(GoalieSaves.game_id).label('game_ids')
-    ).join(Game, GoalieSaves.game_id == Game.id).join(Division, Game.division_id == Division.id).filter(filter_condition)
+    ).join(Game, GoalieSaves.game_id == Game.id).filter(
+        Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS, FORFEIT_STATUS, NOEVENTS_STATUS])
+    ).join(Division, Game.division_id == Division.id).filter(filter_condition)
 
     # Filter for specific human_id if provided
     if debug_human_id:

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/hockey_blast_common_lib/aggregate_human_stats.py

@@ -61,7 +61,7 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, human_id_fi
 
     # 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%')) | (Game.status == 'NOEVENTS')).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)
@@ -75,8 +75,8 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, human_id_fi
     if human_id_filter:
         human_filter = [GameRoster.human_id == human_id_filter]
 
-    # Filter games by status
-    game_status_filter = Game.status.like('Final%')
+    # Filter games by status - include both Final and NOEVENTS games
+    game_status_filter = (Game.status.like('Final%')) | (Game.status == 'NOEVENTS')
 
     # Aggregate skater games played
     skater_stats = session.query(

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/hockey_blast_common_lib/aggregate_referee_stats.py

@@ -80,33 +80,24 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, aggregati
     # Aggregate games reffed for each referee
     # games_participated: Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
     # games_with_stats: Count only FINAL, FINAL_SO (for per-game averages)
+    # Filter by game status upfront for performance
+    status_filter = Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS, FORFEIT_STATUS, NOEVENTS_STATUS])
+
     games_reffed_stats = session.query(
         Game.referee_1_id.label('human_id'),
-        func.count(Game.id).label('games_reffed'),  # 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.count(Game.id).label('games_reffed'),
+        func.count(Game.id).label('games_participated'),  # Same as games_reffed after filtering
+        func.count(Game.id).label('games_with_stats'),  # Same as games_reffed after filtering
         func.array_agg(Game.id).label('game_ids')
-    ).filter(filter_condition).group_by(Game.referee_1_id).all()
+    ).filter(filter_condition, status_filter).group_by(Game.referee_1_id).all()
 
     games_reffed_stats_2 = session.query(
         Game.referee_2_id.label('human_id'),
-        func.count(Game.id).label('games_reffed'),  # 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.count(Game.id).label('games_reffed'),
+        func.count(Game.id).label('games_participated'),  # Same as games_reffed after filtering
+        func.count(Game.id).label('games_with_stats'),  # Same as games_reffed after filtering
         func.array_agg(Game.id).label('game_ids')
-    ).filter(filter_condition).group_by(Game.referee_2_id).all()
+    ).filter(filter_condition, status_filter).group_by(Game.referee_2_id).all()
 
     # Aggregate penalties given for each referee
     penalties_given_stats = session.query(

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/hockey_blast_common_lib/aggregate_scorekeeper_stats.py

@@ -97,17 +97,12 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, aggre
     # 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)
+    # 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'),  # 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.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'),
@@ -115,7 +110,9 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, aggre
         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)
+    ).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()

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/hockey_blast_common_lib/aggregate_skater_stats.py

@@ -29,45 +29,54 @@ 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)
+
+    Optimized to use CASE statements for conditional aggregation in a single query.
     """
-    # 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(
+    # Get all games with their point totals in ONE query using CASE for conditional counting
+    game_points = session.query(
+        Game.id,
+        Game.date,
+        Game.time,
+        func.sum(case((Goal.goal_scorer_id == human_id, 1), else_=0)).label('goals'),
+        func.sum(case(
+            ((Goal.assist_1_id == human_id) | (Goal.assist_2_id == human_id), 1),
+            else_=0
+        )).label('assists')
+    ).join(
+        GameRoster, Game.id == GameRoster.game_id
+    ).outerjoin(
+        Goal, Game.id == Goal.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:
+        (Game.status.like('Final%')) | (Game.status == 'NOEVENTS')  # Include Final and NOEVENTS games
+    ).group_by(
+        Game.id, Game.date, Game.time
+    ).order_by(
+        Game.date.desc(), Game.time.desc()
+    ).all()
+
+    if not game_points:
         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
-        
+
+    # Iterate through games from most recent to oldest
+    for game in game_points:
+        total_points = (game.goals or 0) + (game.assists or 0)
+
         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, debug_human_id=None, aggregation_window=None):
@@ -129,7 +138,7 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, debug_huma
 
     # 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%')) | (Game.status == 'NOEVENTS')).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)
@@ -144,21 +153,17 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, debug_huma
     #     human_filter = [GameRoster.human_id == debug_human_id]
 
     # Aggregate games played for each human in each division, excluding goalies
-    # games_participated: Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
-    # games_with_stats: Count only FINAL, FINAL_SO (for per-game averages)
+    # Filter games by status upfront for performance (avoid CASE statements on 200K+ rows)
+    # Only count games with these statuses: FINAL, FINAL_SO, FORFEIT, NOEVENTS
     games_played_query = session.query(
         GameRoster.human_id,
-        func.count(Game.id).label('games_played'),  # 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.count(Game.id).label('games_played'),
+        func.count(Game.id).label('games_participated'),  # Same as games_played after filtering
+        func.count(Game.id).label('games_with_stats'),  # Same as games_played after filtering
         func.array_agg(Game.id).label('game_ids')
-    ).join(Game, Game.id == GameRoster.game_id)
+    ).join(Game, Game.id == GameRoster.game_id).filter(
+        Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS, FORFEIT_STATUS, NOEVENTS_STATUS])
+    )
 
     # Only join Division if not level aggregation (since we filter on Game.division_id directly for levels)
     if aggregation_type != 'level':
@@ -286,21 +291,48 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, debug_huma
     stats_dict = {key: value for key, value in stats_dict.items() if key[1] is not None}
 
     # Populate first_game_id and last_game_id
-    for key, stat in stats_dict.items():
-        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
+    # Only show progress for "All Orgs" with no window (all-time stats) - the slowest case
+    total_players = len(stats_dict)
+    if aggregation_type == 'org' and aggregation_id == ALL_ORGS_ID and aggregation_window is None and total_players > 1000:
+        progress = create_progress_tracker(total_players, f"Processing {total_players} players for {aggregation_name}")
+        for idx, (key, stat) in enumerate(stats_dict.items()):
+            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
+            if (idx + 1) % 100 == 0 or (idx + 1) == total_players:  # Update every 100 players
+                progress.update(idx + 1)
+    else:
+        # No progress tracking for all other cases
+        for key, stat in stats_dict.items():
+            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
 
     # 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
+        total_players = len(stats_dict)
+        # Show progress for All Orgs - this is the slowest part
+        if aggregation_type == 'org' and aggregation_id == ALL_ORGS_ID and total_players > 1000:
+            progress = create_progress_tracker(total_players, f"Calculating point streaks for {total_players} players")
+            for idx, (key, stat) in enumerate(stats_dict.items()):
+                agg_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
+                if (idx + 1) % 100 == 0 or (idx + 1) == total_players:
+                    progress.update(idx + 1)
+        else:
+            for key, stat in stats_dict.items():
+                agg_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)

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/hockey_blast_common_lib/models.py

@@ -99,6 +99,7 @@ class Goal(db.Model):
     sequence_number = db.Column(db.Integer)
     __table_args__ = (
         db.UniqueConstraint('game_id', 'scoring_team_id', 'sequence_number', name='_goal_team_sequence_uc'),
+        db.UniqueConstraint('game_id', 'period', 'time', 'goal_scorer_id', 'scoring_team_id', name='uq_goals_no_duplicates'),
     )
 
 class Human(db.Model):

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/hockey_blast_common_lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hockey-blast-common-lib
-Version: 0.1.62
+Version: 0.1.63
 Summary: Common library for shared functionality and DB models
 Author: Pavel Kletskov
 Author-email: kletskov@gmail.com

{hockey_blast_common_lib-0.1.62 → hockey_blast_common_lib-0.1.63}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='hockey-blast-common-lib',  # The name of your package
-    version='0.1.62',
+    version='0.1.63',
     description='Common library for shared functionality and DB models',
     author='Pavel Kletskov',
     author_email='kletskov@gmail.com',