hockey-blast-common-lib 0.1.38__py3-none-any.whl → 0.1.40__py3-none-any.whl

hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -15,22 +15,20 @@ 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 sqlalchemy import func, case, and_
 from collections import defaultdict
+from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
 
 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)
 
     # Get the name of the aggregation, for debug purposes
     if aggregation_type == 'org':
-        aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+        if aggregation_id == ALL_ORGS_ID:
+            aggregation_name = "All Orgs"
+            filter_condition = sqlalchemy.true()  # No filter for organization
+        else:
+            aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+            filter_condition = Game.org_id == aggregation_id
         print(f"Aggregating goalie stats for {aggregation_name} with window {aggregation_window}...")
-    elif aggregation_type == 'division':
-        aggregation_name = session.query(Division).filter(Division.id == aggregation_id).first().level
-    elif aggregation_type == 'level':
-        aggregation_name = session.query(Level).filter(Level.id == aggregation_id).first().level_name
-    else:
-        aggregation_name = "Unknown"
-
-    if aggregation_type == 'org':
         if aggregation_window == 'Daily':
             StatsModel = OrgStatsDailyGoalie
         elif aggregation_window == 'Weekly':
@@ -38,7 +36,6 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
         else:
             StatsModel = OrgStatsGoalie
         min_games = MIN_GAMES_FOR_ORG_STATS
-        filter_condition = Game.org_id == aggregation_id
     elif aggregation_type == 'division':
         if aggregation_window == 'Daily':
             StatsModel = DivisionStatsDailyGoalie
@@ -91,18 +88,24 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
         if stat.human_id in human_ids_to_filter:
             continue
         key = (aggregation_id, stat.human_id)
-        if stat.games_played < min_games:
-            continue
-        stats_dict[key] = {
-            'games_played': stat.games_played,
-            'goals_allowed': stat.goals_allowed if stat.goals_allowed is not None else 0,
-            'shots_faced': stat.shots_faced if stat.shots_faced is not None else 0,
-            'goals_allowed_per_game': 0.0,
-            'save_percentage': 0.0,
-            'game_ids': stat.game_ids,
-            'first_game_id': None,
-            'last_game_id': None
-        }
+        if key not in stats_dict:
+            stats_dict[key] = {
+                'games_played': 0,
+                'goals_allowed': 0,
+                'shots_faced': 0,
+                'goals_allowed_per_game': 0.0,
+                'save_percentage': 0.0,
+                'game_ids': [],
+                'first_game_id': None,
+                'last_game_id': None
+            }
+        stats_dict[key]['games_played'] += stat.games_played
+        stats_dict[key]['goals_allowed'] += stat.goals_allowed if stat.goals_allowed is not None else 0
+        stats_dict[key]['shots_faced'] += stat.shots_faced if stat.shots_faced is not None else 0
+        stats_dict[key]['game_ids'].extend(stat.game_ids)
+
+    # Filter out entries with games_played less than min_games
+    stats_dict = {key: value for key, value in stats_dict.items() if value['games_played'] >= min_games}
 
     # Calculate per game stats
     for key, stat in stats_dict.items():

hockey_blast_common_lib/aggregate_human_stats.py

@@ -14,13 +14,19 @@ from hockey_blast_common_lib.options import parse_args, MIN_GAMES_FOR_ORG_STATS,
 from hockey_blast_common_lib.utils import get_fake_human_for_stats, get_org_id_from_alias, get_human_ids_by_names, get_division_ids_for_last_season_in_all_leagues, get_all_division_ids_for_org
 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
 
 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)
 
     if aggregation_type == 'org':
-        aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
-        print(f"Aggregating goalie stats for {aggregation_name} with window {aggregation_window}...")
+        if aggregation_id == ALL_ORGS_ID:
+            aggregation_name = "All Orgs"
+            filter_condition = sqlalchemy.true()  # No filter for organization
+        else:
+            aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+            filter_condition = Game.org_id == aggregation_id
+        print(f"Aggregating human stats for {aggregation_name} with window {aggregation_window}...")
         if aggregation_window == 'Daily':
             StatsModel = OrgStatsDailyHuman
         elif aggregation_window == 'Weekly':
@@ -28,7 +34,6 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
         else:
             StatsModel = OrgStatsHuman
         min_games = MIN_GAMES_FOR_ORG_STATS
-        filter_condition = Game.org_id == aggregation_id
     elif aggregation_type == 'division':
         if aggregation_window == 'Daily':
             StatsModel = DivisionStatsDailyHuman
@@ -108,25 +113,29 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
         if stat.human_id in human_ids_to_filter:
             continue
         key = (aggregation_id, stat.human_id)
-        stats_dict[key] = {
-            'games_total': stat.games_skater,
-            'games_skater': stat.games_skater,
-            'games_goalie': 0,
-            'games_referee': 0,
-            'games_scorekeeper': 0,
-            'skater_game_ids': stat.skater_game_ids,
-            'goalie_game_ids': [],
-            'referee_game_ids': [],
-            'scorekeeper_game_ids': [],
-            'first_game_id_skater': None,
-            'last_game_id_skater': None,
-            'first_game_id_goalie': None,
-            'last_game_id_goalie': None,
-            'first_game_id_referee': None,
-            'last_game_id_referee': None,
-            'first_game_id_scorekeeper': None,
-            'last_game_id_scorekeeper': None
-        }
+        if key not in stats_dict:
+            stats_dict[key] = {
+                'games_total': 0,
+                'games_skater': 0,
+                'games_goalie': 0,
+                'games_referee': 0,
+                'games_scorekeeper': 0,
+                'skater_game_ids': [],
+                'goalie_game_ids': [],
+                'referee_game_ids': [],
+                'scorekeeper_game_ids': [],
+                'first_game_id_skater': None,
+                'last_game_id_skater': None,
+                'first_game_id_goalie': None,
+                'last_game_id_goalie': None,
+                'first_game_id_referee': None,
+                'last_game_id_referee': None,
+                'first_game_id_scorekeeper': None,
+                'last_game_id_scorekeeper': None
+            }
+        stats_dict[key]['games_total'] += stat.games_skater
+        stats_dict[key]['games_skater'] += stat.games_skater
+        stats_dict[key]['skater_game_ids'].extend(stat.skater_game_ids)
 
     for stat in goalie_stats:
         if stat.human_id in human_ids_to_filter:
@@ -134,13 +143,13 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
         key = (aggregation_id, stat.human_id)
         if key not in stats_dict:
             stats_dict[key] = {
-                'games_total': stat.games_goalie,
+                'games_total': 0,
                 'games_skater': 0,
-                'games_goalie': stat.games_goalie,
+                'games_goalie': 0,
                 'games_referee': 0,
                 'games_scorekeeper': 0,
                 'skater_game_ids': [],
-                'goalie_game_ids': stat.goalie_game_ids,
+                'goalie_game_ids': [],
                 'referee_game_ids': [],
                 'scorekeeper_game_ids': [],
                 'first_game_id_skater': None,
@@ -152,10 +161,9 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
                 'first_game_id_scorekeeper': None,
                 'last_game_id_scorekeeper': None
             }
-        else:
-            stats_dict[key]['games_goalie'] += stat.games_goalie
-            stats_dict[key]['games_total'] += stat.games_goalie
-            stats_dict[key]['goalie_game_ids'] += stat.goalie_game_ids
+        stats_dict[key]['games_total'] += stat.games_goalie
+        stats_dict[key]['games_goalie'] += stat.games_goalie
+        stats_dict[key]['goalie_game_ids'].extend(stat.goalie_game_ids)
 
     for stat in referee_stats:
         if stat.human_id in human_ids_to_filter:
@@ -163,14 +171,14 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
         key = (aggregation_id, stat.human_id)
         if key not in stats_dict:
             stats_dict[key] = {
-                'games_total': stat.games_referee,
+                'games_total': 0,
                 'games_skater': 0,
                 'games_goalie': 0,
-                'games_referee': stat.games_referee,
+                'games_referee': 0,
                 'games_scorekeeper': 0,
                 'skater_game_ids': [],
                 'goalie_game_ids': [],
-                'referee_game_ids': stat.referee_game_ids,
+                'referee_game_ids': [],
                 'scorekeeper_game_ids': [],
                 'first_game_id_skater': None,
                 'last_game_id_skater': None,
@@ -181,10 +189,9 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
                 'first_game_id_scorekeeper': None,
                 'last_game_id_scorekeeper': None
             }
-        else:
-            stats_dict[key]['games_referee'] += stat.games_referee
-            stats_dict[key]['games_total'] += stat.games_referee
-            stats_dict[key]['referee_game_ids'] += stat.referee_game_ids
+        stats_dict[key]['games_total'] += stat.games_referee
+        stats_dict[key]['games_referee'] += stat.games_referee
+        stats_dict[key]['referee_game_ids'].extend(stat.referee_game_ids)
 
     for stat in referee_stats_2:
         if stat.human_id in human_ids_to_filter:
@@ -192,14 +199,14 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
         key = (aggregation_id, stat.human_id)
         if key not in stats_dict:
             stats_dict[key] = {
-                'games_total': stat.games_referee,
+                'games_total': 0,
                 'games_skater': 0,
                 'games_goalie': 0,
-                'games_referee': stat.games_referee,
+                'games_referee': 0,
                 'games_scorekeeper': 0,
                 'skater_game_ids': [],
                 'goalie_game_ids': [],
-                'referee_game_ids': stat.referee_game_ids,
+                'referee_game_ids': [],
                 'scorekeeper_game_ids': [],
                 'first_game_id_skater': None,
                 'last_game_id_skater': None,
@@ -210,10 +217,9 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
                 'first_game_id_scorekeeper': None,
                 'last_game_id_scorekeeper': None
             }
-        else:
-            stats_dict[key]['games_referee'] += stat.games_referee
-            stats_dict[key]['games_total'] += stat.games_referee
-            stats_dict[key]['referee_game_ids'] += stat.referee_game_ids
+        stats_dict[key]['games_total'] += stat.games_referee
+        stats_dict[key]['games_referee'] += stat.games_referee
+        stats_dict[key]['referee_game_ids'].extend(stat.referee_game_ids)
 
     for stat in scorekeeper_stats:
         if stat.human_id in human_ids_to_filter:
@@ -221,15 +227,15 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
         key = (aggregation_id, stat.human_id)
         if key not in stats_dict:
             stats_dict[key] = {
-                'games_total': stat.games_scorekeeper,
+                'games_total': 0,
                 'games_skater': 0,
                 'games_goalie': 0,
                 'games_referee': 0,
-                'games_scorekeeper': stat.games_scorekeeper,
+                'games_scorekeeper': 0,
                 'skater_game_ids': [],
                 'goalie_game_ids': [],
                 'referee_game_ids': [],
-                'scorekeeper_game_ids': stat.scorekeeper_game_ids,
+                'scorekeeper_game_ids': [],
                 'first_game_id_skater': None,
                 'last_game_id_skater': None,
                 'first_game_id_goalie': None,
@@ -239,10 +245,9 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
                 'first_game_id_scorekeeper': None,
                 'last_game_id_scorekeeper': None
             }
-        else:
-            stats_dict[key]['games_scorekeeper'] += stat.games_scorekeeper
-            stats_dict[key]['games_total'] += stat.games_scorekeeper
-            stats_dict[key]['scorekeeper_game_ids'] += stat.scorekeeper_game_ids
+        stats_dict[key]['games_total'] += stat.games_scorekeeper
+        stats_dict[key]['games_scorekeeper'] += stat.games_scorekeeper
+        stats_dict[key]['scorekeeper_game_ids'].extend(stat.scorekeeper_game_ids)
 
     # Ensure all keys have valid human_id values
     stats_dict = {key: value for key, value in stats_dict.items() if key[1] is not None}
@@ -417,7 +422,7 @@ 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 org_ids:
+    for org_id in [-1]:#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)
@@ -435,17 +440,17 @@ def run_aggregate_human_stats():
         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]
-    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_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_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_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

@@ -14,12 +14,18 @@ from hockey_blast_common_lib.options import parse_args, MIN_GAMES_FOR_ORG_STATS,
 from hockey_blast_common_lib.utils import get_org_id_from_alias, get_human_ids_by_names, get_division_ids_for_last_season_in_all_leagues, get_all_division_ids_for_org
 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
 
 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)
 
     if aggregation_type == 'org':
-        aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+        if aggregation_id == ALL_ORGS_ID:
+            aggregation_name = "All Orgs"
+            filter_condition = sqlalchemy.true()  # No filter for organization
+        else:
+            aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+            filter_condition = Game.org_id == aggregation_id
         print(f"Aggregating referee stats for {aggregation_name} with window {aggregation_window}...")
         if aggregation_window == 'Daily':
             StatsModel = OrgStatsDailyReferee
@@ -28,7 +34,6 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
         else:
             StatsModel = OrgStatsReferee
         min_games = MIN_GAMES_FOR_ORG_STATS
-        filter_condition = Game.org_id == aggregation_id
     elif aggregation_type == 'division':
         if aggregation_window == 'Daily':
             StatsModel = DivisionStatsDailyReferee
@@ -89,16 +94,19 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
         if stat.human_id in human_ids_to_filter:
             continue
         key = (aggregation_id, stat.human_id)
-        stats_dict[key] = {
-            'games_reffed': stat.games_reffed,
-            'penalties_given': 0,
-            'gm_given': 0,
-            'penalties_per_game': 0.0,
-            'gm_per_game': 0.0,
-            'game_ids': stat.game_ids,
-            'first_game_id': None,
-            'last_game_id': None
-        }
+        if key not in stats_dict:
+            stats_dict[key] = {
+                'games_reffed': 0,
+                'penalties_given': 0,
+                'gm_given': 0,
+                'penalties_per_game': 0.0,
+                'gm_per_game': 0.0,
+                'game_ids': [],
+                'first_game_id': None,
+                'last_game_id': None
+            }
+        stats_dict[key]['games_reffed'] += stat.games_reffed
+        stats_dict[key]['game_ids'].extend(stat.game_ids)
 
     for stat in games_reffed_stats_2:
         if stat.human_id in human_ids_to_filter:
@@ -106,18 +114,20 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
         key = (aggregation_id, stat.human_id)
         if key not in stats_dict:
             stats_dict[key] = {
-                'games_reffed': stat.games_reffed,
+                'games_reffed': 0,
                 'penalties_given': 0,
                 'gm_given': 0,
                 'penalties_per_game': 0.0,
                 'gm_per_game': 0.0,
-                'game_ids': stat.game_ids,
+                'game_ids': [],
                 'first_game_id': None,
                 'last_game_id': None
             }
-        else:
-            stats_dict[key]['games_reffed'] += stat.games_reffed
-            stats_dict[key]['game_ids'].extend(stat.game_ids)
+        stats_dict[key]['games_reffed'] += stat.games_reffed
+        stats_dict[key]['game_ids'].extend(stat.game_ids)
+
+    # Filter out entries with games_reffed less than min_games
+    stats_dict = {key: value for key, value in stats_dict.items() if value['games_reffed'] >= min_games}
 
     for stat in penalties_given_stats:
         if stat.referee_1_id and stat.referee_1_id not in human_ids_to_filter:
@@ -143,9 +153,6 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
     # Ensure all keys have valid human_id values
     stats_dict = {key: value for key, value in stats_dict.items() if key[1] is not None}
 
-    # Filter out referees with less than min_games
-    stats_dict = {key: value for key, value in stats_dict.items() if value['games_reffed'] >= min_games}
-
     # Populate first_game_id and last_game_id
     for key, stat in stats_dict.items():
         all_game_ids = stat['game_ids']

hockey_blast_common_lib/aggregate_skater_stats.py

@@ -15,16 +15,21 @@ from hockey_blast_common_lib.utils import get_org_id_from_alias, get_human_ids_b
 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
 
 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)
 
     # Get the name of the aggregation, for debug purposes
     if aggregation_type == 'org':
-        aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+        if aggregation_id == ALL_ORGS_ID:
+            aggregation_name = "All Orgs"
+            filter_condition = sqlalchemy.true()  # No filter for organization
+        else:
+            aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+            filter_condition = Game.org_id == aggregation_id
         print(f"Aggregating skater stats for {aggregation_name} with window {aggregation_window}...")
 
-        aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
     elif aggregation_type == 'division':
         aggregation_name = session.query(Division).filter(Division.id == aggregation_id).first().level
     elif aggregation_type == 'level':
@@ -40,7 +45,6 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         else:
             StatsModel = OrgStatsSkater
         min_games = MIN_GAMES_FOR_ORG_STATS
-        filter_condition = Game.org_id == aggregation_id
     elif aggregation_type == 'division':
         if aggregation_window == 'Daily':
             StatsModel = DivisionStatsDailySkater
@@ -80,42 +84,38 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
 
     # Aggregate games played for each human in each division, excluding goalies
     games_played_stats = session.query(
-        Game.org_id,
         GameRoster.human_id,
         func.count(Game.id).label('games_played'),
         func.array_agg(Game.id).label('game_ids')
-    ).join(GameRoster, Game.id == GameRoster.game_id).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, GameRoster.human_id).all()
+    ).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()
 
     # Aggregate goals for each human in each division, excluding goalies
     goals_stats = session.query(
-        Game.org_id,
         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(Game.org_id, 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)).join(Division, Game.division_id == Division.id).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(
-        Game.org_id,
         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(Game.org_id, Goal.assist_1_id).all()
+    ).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(
-        Game.org_id,
         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(Game.org_id, 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)).join(Division, Game.division_id == Division.id).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(
-        Game.org_id,
         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(Game.org_id, 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)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Penalty.penalized_player_id).all()
 
     # Combine the results
     stats_dict = {}
@@ -123,22 +123,27 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         if stat.human_id in human_ids_to_filter:
             continue
         key = (aggregation_id, stat.human_id)
-        if stat.games_played < min_games:
-            continue
-        stats_dict[key] = {
-            'games_played': stat.games_played,
-            'goals': 0,
-            'assists': 0,
-            'penalties': 0,
-            'points': 0,  # Initialize points
-            'goals_per_game': 0.0,
-            'points_per_game': 0.0,
-            'assists_per_game': 0.0,
-            'penalties_per_game': 0.0,
-            'game_ids': stat.game_ids,
-            'first_game_id': None,
-            'last_game_id': None
-        }
+        if key not in stats_dict:
+            stats_dict[key] = {
+                'games_played': 0,
+                'goals': 0,
+                'assists': 0,
+                'penalties': 0,
+                'gm_penalties': 0,  # Initialize GM penalties
+                'points': 0,  # Initialize points
+                'goals_per_game': 0.0,
+                'points_per_game': 0.0,
+                'assists_per_game': 0.0,
+                'penalties_per_game': 0.0,
+                'game_ids': [],
+                'first_game_id': None,
+                'last_game_id': None
+            }
+        stats_dict[key]['games_played'] += stat.games_played
+        stats_dict[key]['game_ids'].extend(stat.game_ids)
+
+    # Filter out entries with games_played less than min_games
+    stats_dict = {key: value for key, value in stats_dict.items() if value['games_played'] >= min_games}
 
     for stat in goals_stats:
         key = (aggregation_id, stat.human_id)
@@ -162,6 +167,7 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         key = (aggregation_id, stat.human_id)
         if key in stats_dict:
             stats_dict[key]['penalties'] += stat.penalties
+            stats_dict[key]['gm_penalties'] += stat.gm_penalties  # Update GM penalties
 
     # Calculate per game stats
     for key, stat in stats_dict.items():
@@ -197,6 +203,7 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     assign_ranks(stats_dict, 'assists')
     assign_ranks(stats_dict, 'points')
     assign_ranks(stats_dict, 'penalties')
+    assign_ranks(stats_dict, 'gm_penalties')  # Assign ranks for GM penalties
     assign_ranks(stats_dict, 'goals_per_game')
     assign_ranks(stats_dict, 'points_per_game')
     assign_ranks(stats_dict, 'assists_per_game')
@@ -230,6 +237,7 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             assists=stat['assists'],
             points=stat['goals'] + stat['assists'],
             penalties=stat['penalties'],
+            gm_penalties=stat['gm_penalties'],  # Include GM penalties
             goals_per_game=goals_per_game,
             points_per_game=points_per_game,
             assists_per_game=assists_per_game,
@@ -239,6 +247,7 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             assists_rank=stat['assists_rank'],
             points_rank=stat['points_rank'],
             penalties_rank=stat['penalties_rank'],
+            gm_penalties_rank=stat['gm_penalties_rank'],  # Include GM penalties rank
             goals_per_game_rank=stat['goals_per_game_rank'],
             points_per_game_rank=stat['points_per_game_rank'],
             assists_per_game_rank=stat['assists_per_game_rank'],
@@ -278,7 +287,7 @@ def run_aggregate_skater_stats():
         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
+    # 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)

hockey_blast_common_lib/stats_models.py

@@ -62,6 +62,8 @@ class BaseStatsSkater(db.Model):
     points_rank = db.Column(db.Integer, default=0)
     penalties = db.Column(db.Integer, default=0)
     penalties_rank = db.Column(db.Integer, default=0)
+    gm_penalties = db.Column(db.Integer, default=0)  # New field for GM penalties
+    gm_penalties_rank = db.Column(db.Integer, default=0)  # New field for GM penalties rank
     goals_per_game = db.Column(db.Float, default=0.0)
     goals_per_game_rank = db.Column(db.Integer, default=0)
     points_per_game = db.Column(db.Float, default=0.0)

hockey_blast_common_lib/stats_utils.py

@@ -0,0 +1,6 @@
+def assign_ranks(stats_dict, field, reverse_rank=False):
+    sorted_stats = sorted(stats_dict.items(), key=lambda x: x[1][field], reverse=not reverse_rank)
+    for rank, (key, stat) in enumerate(sorted_stats, start=1):
+        stats_dict[key][f'{field}_rank'] = rank
+
+ALL_ORGS_ID = -1

{hockey_blast_common_lib-0.1.38.dist-info → hockey_blast_common_lib-0.1.40.dist-info}/METADATA

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

{hockey_blast_common_lib-0.1.38.dist-info → hockey_blast_common_lib-0.1.40.dist-info}/RECORD

@@ -1,23 +1,23 @@
 hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hockey_blast_common_lib/aggregate_all_stats.py,sha256=MUjT23mdOMfCTx-kRSY-LGrLHZ9HNlR6OMqv5KLdzR4,1056
-hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=xDjCYaGLXh5UgkhoUvWKcsnv__QmbCzqLvYNHREFyFY,11937
-hockey_blast_common_lib/aggregate_human_stats.py,sha256=di3h_nQjgMaNnGDPW6LQavnrYOxnZDMohNZEh3ixYNM,23700
-hockey_blast_common_lib/aggregate_referee_stats.py,sha256=ATKBId0Hhzy0FVGmAFDTMgRftYNBDOOA9Z2yPhFA06U,11546
-hockey_blast_common_lib/aggregate_skater_stats.py,sha256=LY6temy5zzqJ85ENymt9nEfpKHqL8Isk_kozfWqHNFI,15803
+hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=FcYL40NP0-sPY7UI7F8Ny_RaPKz3mfkmhQnPVbeRtOc,12178
+hockey_blast_common_lib/aggregate_human_stats.py,sha256=6cDoiJ0xZ3aQ4wjEAP_Jgu2aNEicnuU-a22BncSFtRo,23920
+hockey_blast_common_lib/aggregate_referee_stats.py,sha256=FszWLTygddDQNcUgbmevQ-eGPrW8Y0nXpRvUluPRKnU,11920
+hockey_blast_common_lib/aggregate_skater_stats.py,sha256=JK_JnmsNHecpMOng3pV_cf03tjIsUS-uGt0G9MPCrbM,16547
 hockey_blast_common_lib/assign_skater_skill.py,sha256=p-0fbodGpM8BCjKHDpxNb7BH2FcIlBsJwON844KNrUY,1817
 hockey_blast_common_lib/db_connection.py,sha256=HvPxDvOj7j5H85RfslGvHVNevfg7mKCd0syJ6NX21mU,1890
 hockey_blast_common_lib/dump_sample_db.sh,sha256=MHPA-Ciod7wsvAlMbRtXFiyajgnEqU1xR59sJQ9UWR0,738
-hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=x3pQv7C8awQ49e--mvHnV3d2tgVwIFw-22IjChS9s-M,1033688
+hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=uU1QOjEWNMji7TP5YhILFKZptRoR-1HcjBBw7mX4kI4,51
 hockey_blast_common_lib/models.py,sha256=xne38KwdBDcWvzdLyU6toozqkuatB9wiQhyiQ4xvAgU,16413
 hockey_blast_common_lib/options.py,sha256=6na8fo-5A2RBPpd_h-7dsqetOLSLoNEJg1QMYgl4jNs,792
 hockey_blast_common_lib/restore_sample_db.sh,sha256=u2zKazC6vNMULkpYzI64nlneCWaGUtDHPBAU-gWgRbw,1861
 hockey_blast_common_lib/skills_in_divisions.py,sha256=m-UEwMwn1KM7wOYvDstgsOEeH57M9V6yrkBoghzGYKE,7005
 hockey_blast_common_lib/skills_propagation.py,sha256=x6yy7fJ6IX3YiHqiP_v7-p_S2Expb8JJ-mWuajEFBdY,16388
-hockey_blast_common_lib/stats_models.py,sha256=qvkt-XRFb4ZW7yBj7vltedzUS_YwWagm_efMRcsioSA,25120
-hockey_blast_common_lib/stats_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hockey_blast_common_lib/stats_models.py,sha256=__BtG0LtSZ2yWHU_fCh7-RVyjO0EhDNMctOW2cAzjnk,25294
+hockey_blast_common_lib/stats_utils.py,sha256=DXsPO4jw8XsdRUN46TGF_IiBAfz3GCIVBswCGp5ELDk,284
 hockey_blast_common_lib/utils.py,sha256=Sy5Pk40Tk3gsMrhMsUMlBD7i7jiVZmWLUBc94qI3zOA,5235
 hockey_blast_common_lib/wsgi.py,sha256=7LGUzioigviJp-EUhSEaQcd4jBae0mxbkyBscQfZhlc,730
-hockey_blast_common_lib-0.1.38.dist-info/METADATA,sha256=rS0X72ris2E-2ZuJTQo5wAsiPZvzmlHtrAljqq2SDUY,318
-hockey_blast_common_lib-0.1.38.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.38.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.38.dist-info/RECORD,,
+hockey_blast_common_lib-0.1.40.dist-info/METADATA,sha256=c1tQbNlrUW8MNh2f0Z7MVmwolW4HMgmGvH6v7YHicaI,318
+hockey_blast_common_lib-0.1.40.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.40.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.40.dist-info/RECORD,,