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

hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -9,15 +9,21 @@ import sqlalchemy
 from hockey_blast_common_lib.models import Game, Organization, Division, Human, GoalieSaves
 from hockey_blast_common_lib.stats_models import OrgStatsGoalie, DivisionStatsGoalie, OrgStatsWeeklyGoalie, OrgStatsDailyGoalie, DivisionStatsWeeklyGoalie, DivisionStatsDailyGoalie, LevelStatsGoalie
 from hockey_blast_common_lib.db_connection import create_session
-from sqlalchemy.sql import func
-from hockey_blast_common_lib.options import not_human_names, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS
-from hockey_blast_common_lib.utils import get_human_ids_by_names, get_all_division_ids_for_org, get_start_datetime
+from sqlalchemy.sql import func, case
+from hockey_blast_common_lib.options import MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS
+from hockey_blast_common_lib.utils import get_non_human_ids, get_all_division_ids_for_org, get_start_datetime
 from hockey_blast_common_lib.utils import assign_ranks
 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)
+# Import status constants for game filtering
+FINAL_STATUS = "Final"
+FINAL_SO_STATUS = "Final(SO)"
+FORFEIT_STATUS = "FORFEIT"
+NOEVENTS_STATUS = "NOEVENTS"
+
+def aggregate_goalie_stats(session, aggregation_type, aggregation_id, debug_human_id=None, aggregation_window=None):
+    human_ids_to_filter = get_non_human_ids(session)
 
     # Get the name of the aggregation, for debug purposes
     if aggregation_type == 'org':
@@ -72,9 +78,19 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
 
 
     # 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)
     query = session.query(
         GoalieSaves.goalie_id.label('human_id'),
-        func.count(GoalieSaves.game_id).label('games_played'),
+        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.sum(GoalieSaves.goals_allowed).label('goals_allowed'),
         func.sum(GoalieSaves.shots_against).label('shots_faced'),
         func.array_agg(GoalieSaves.game_id).label('game_ids')
@@ -94,7 +110,9 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
         key = (aggregation_id, stat.human_id)
         if key not in stats_dict:
             stats_dict[key] = {
-                'games_played': 0,
+                'games_played': 0,  # DEPRECATED - for backward compatibility
+                'games_participated': 0,  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+                'games_with_stats': 0,  # Games with full stats: FINAL, FINAL_SO only
                 'goals_allowed': 0,
                 'shots_faced': 0,
                 'goals_allowed_per_game': 0.0,
@@ -104,6 +122,8 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
                 'last_game_id': None
             }
         stats_dict[key]['games_played'] += stat.games_played
+        stats_dict[key]['games_participated'] += stat.games_participated
+        stats_dict[key]['games_with_stats'] += stat.games_with_stats
         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)
@@ -111,10 +131,10 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
     # 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
+    # Calculate per game stats (using games_with_stats as denominator for accuracy)
     for key, stat in stats_dict.items():
-        if stat['games_played'] > 0:
-            stat['goals_allowed_per_game'] = stat['goals_allowed'] / stat['games_played']
+        if stat['games_with_stats'] > 0:
+            stat['goals_allowed_per_game'] = stat['goals_allowed'] / stat['games_with_stats']
             stat['save_percentage'] = (stat['shots_faced'] - stat['goals_allowed']) / stat['shots_faced'] if stat['shots_faced'] > 0 else 0.0
 
     # Ensure all keys have valid human_id values
@@ -134,6 +154,8 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
 
     # Assign ranks within each level
     assign_ranks(stats_dict, 'games_played')
+    assign_ranks(stats_dict, 'games_participated')  # Rank by total participation
+    assign_ranks(stats_dict, 'games_with_stats')  # Rank by games with full stats
     assign_ranks(stats_dict, 'goals_allowed', reverse_rank=True)
     assign_ranks(stats_dict, 'shots_faced')
     assign_ranks(stats_dict, 'goals_allowed_per_game', reverse_rank=True)
@@ -159,7 +181,11 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
         goalie_stat = StatsModel(
             aggregation_id=aggregation_id,
             human_id=human_id,
-            games_played=stat['games_played'],
+            games_played=stat['games_played'],  # DEPRECATED - for backward compatibility
+            games_participated=stat['games_participated'],  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+            games_participated_rank=stat['games_participated_rank'],
+            games_with_stats=stat['games_with_stats'],  # Games with full stats: FINAL, FINAL_SO only
+            games_with_stats_rank=stat['games_with_stats_rank'],
             goals_allowed=stat['goals_allowed'],
             shots_faced=stat['shots_faced'],
             goals_allowed_per_game=goals_allowed_per_game,
@@ -195,30 +221,30 @@ def run_aggregate_goalie_stats():
             # 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')
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, debug_human_id=human_id_to_debug)
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, 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')
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, debug_human_id=human_id_to_debug)
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, 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_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, 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')
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, 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')
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, 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_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, debug_human_id=human_id_to_debug)
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, debug_human_id=human_id_to_debug, aggregation_window='Daily')
         
     # Aggregate by level
     level_ids = session.query(Division.level_id).distinct().all()
@@ -228,12 +254,12 @@ def run_aggregate_goalie_stats():
         # 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)
+            aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, 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)
+            aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, debug_human_id=human_id_to_debug)
 
 if __name__ == "__main__":
     run_aggregate_goalie_stats()

hockey_blast_common_lib/aggregate_human_stats.py

@@ -10,15 +10,15 @@ from hockey_blast_common_lib.models import Game, GameRoster, Organization, Divis
 from hockey_blast_common_lib.stats_models import OrgStatsHuman, DivisionStatsHuman, OrgStatsDailyHuman, OrgStatsWeeklyHuman, DivisionStatsDailyHuman, DivisionStatsWeeklyHuman, LevelStatsHuman
 from hockey_blast_common_lib.db_connection import create_session
 from sqlalchemy.sql import func, case
-from hockey_blast_common_lib.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS, not_human_names
-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.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS
+from hockey_blast_common_lib.utils import get_fake_human_for_stats, get_org_id_from_alias, get_non_human_ids, 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
 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)
+def aggregate_human_stats(session, aggregation_type, aggregation_id, human_id_filter=None, aggregation_window=None):
+    human_ids_to_filter = get_non_human_ids(session)
 
     if aggregation_type == 'org':
         if aggregation_id == ALL_ORGS_ID:
@@ -434,30 +434,30 @@ def run_aggregate_human_stats():
             # 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')
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, human_id_filter=human_id_to_debug)
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, 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')
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, human_id_filter=human_id_to_debug)
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, human_id_filter=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_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, 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')
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, 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')
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, 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_human_stats(session, aggregation_type='org', aggregation_id=org_id, human_id_filter=human_id_to_debug)
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, human_id_filter=human_id_to_debug, aggregation_window='Daily')
         
     # Aggregate by level
     level_ids = session.query(Division.level_id).distinct().all()
@@ -467,12 +467,12 @@ def run_aggregate_human_stats():
         # 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)
+            aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, 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)
+            aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, human_id_filter=human_id_to_debug)
 
 if __name__ == "__main__":
     run_aggregate_human_stats()

hockey_blast_common_lib/aggregate_referee_stats.py

@@ -10,15 +10,21 @@ from hockey_blast_common_lib.models import Game, Penalty, Organization, Division
 from hockey_blast_common_lib.stats_models import OrgStatsReferee, DivisionStatsReferee, OrgStatsWeeklyReferee, OrgStatsDailyReferee, DivisionStatsWeeklyReferee, DivisionStatsDailyReferee, LevelStatsReferee
 from hockey_blast_common_lib.db_connection import create_session
 from sqlalchemy.sql import func, case
-from hockey_blast_common_lib.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS, not_human_names
-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.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS
+from hockey_blast_common_lib.utils import get_org_id_from_alias, get_non_human_ids, 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
 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)
+# Import status constants for game filtering
+FINAL_STATUS = "Final"
+FINAL_SO_STATUS = "Final(SO)"
+FORFEIT_STATUS = "FORFEIT"
+NOEVENTS_STATUS = "NOEVENTS"
+
+def aggregate_referee_stats(session, aggregation_type, aggregation_id, aggregation_window=None):
+    human_ids_to_filter = get_non_human_ids(session)
 
     if aggregation_type == 'org':
         if aggregation_id == ALL_ORGS_ID:
@@ -72,15 +78,33 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
 
     filter_condition = filter_condition & (Division.id == Game.division_id)
     # 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)
     games_reffed_stats = session.query(
         Game.referee_1_id.label('human_id'),
-        func.count(Game.id).label('games_reffed'),
+        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.array_agg(Game.id).label('game_ids')
     ).filter(filter_condition).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'),
+        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.array_agg(Game.id).label('game_ids')
     ).filter(filter_condition).group_by(Game.referee_2_id).all()
 
@@ -101,7 +125,9 @@ 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': 0,
+                'games_reffed': 0,  # DEPRECATED - for backward compatibility
+                'games_participated': 0,  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+                'games_with_stats': 0,  # Games with full stats: FINAL, FINAL_SO only
                 'penalties_given': 0,
                 'gm_given': 0,
                 'penalties_per_game': 0.0,
@@ -111,6 +137,8 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
                 'last_game_id': None
             }
         stats_dict[key]['games_reffed'] += stat.games_reffed
+        stats_dict[key]['games_participated'] += stat.games_participated
+        stats_dict[key]['games_with_stats'] += stat.games_with_stats
         stats_dict[key]['game_ids'].extend(stat.game_ids)
 
     for stat in games_reffed_stats_2:
@@ -119,7 +147,9 @@ 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': 0,
+                'games_reffed': 0,  # DEPRECATED - for backward compatibility
+                'games_participated': 0,  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+                'games_with_stats': 0,  # Games with full stats: FINAL, FINAL_SO only
                 'penalties_given': 0,
                 'gm_given': 0,
                 'penalties_per_game': 0.0,
@@ -129,6 +159,8 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
                 'last_game_id': None
             }
         stats_dict[key]['games_reffed'] += stat.games_reffed
+        stats_dict[key]['games_participated'] += stat.games_participated
+        stats_dict[key]['games_with_stats'] += stat.games_with_stats
         stats_dict[key]['game_ids'].extend(stat.game_ids)
 
     # Filter out entries with games_reffed less than min_games
@@ -149,11 +181,11 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
                 stats_dict[key]['gm_given'] += stat.gm_given / 2
                 stats_dict[key]['game_ids'].append(stat.game_id)
 
-    # Calculate per game stats
+    # Calculate per game stats (using games_with_stats as denominator for accuracy)
     for key, stat in stats_dict.items():
-        if stat['games_reffed'] > 0:
-            stat['penalties_per_game'] = stat['penalties_given'] / stat['games_reffed']
-            stat['gm_per_game'] = stat['gm_given'] / stat['games_reffed']
+        if stat['games_with_stats'] > 0:
+            stat['penalties_per_game'] = stat['penalties_given'] / stat['games_with_stats']
+            stat['gm_per_game'] = stat['gm_given'] / stat['games_with_stats']
 
     # 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}
@@ -172,6 +204,8 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
 
     # Assign ranks
     assign_ranks(stats_dict, 'games_reffed')
+    assign_ranks(stats_dict, 'games_participated')  # Rank by total participation
+    assign_ranks(stats_dict, 'games_with_stats')  # Rank by games with full stats
     assign_ranks(stats_dict, 'penalties_given')
     assign_ranks(stats_dict, 'penalties_per_game')
     assign_ranks(stats_dict, 'gm_given')
@@ -185,7 +219,11 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
         referee_stat = StatsModel(
             aggregation_id=aggregation_id,
             human_id=human_id,
-            games_reffed=stat['games_reffed'],
+            games_reffed=stat['games_reffed'],  # DEPRECATED - for backward compatibility
+            games_participated=stat['games_participated'],  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+            games_participated_rank=stat['games_participated_rank'],
+            games_with_stats=stat['games_with_stats'],  # Games with full stats: FINAL, FINAL_SO only
+            games_with_stats_rank=stat['games_with_stats_rank'],
             penalties_given=stat['penalties_given'],
             penalties_per_game=stat['penalties_per_game'],
             gm_given=stat['gm_given'],
@@ -221,30 +259,30 @@ def run_aggregate_referee_stats():
             # 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')
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id)
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, aggregation_window='Weekly')
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, 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')
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id)
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, aggregation_window='Weekly')
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, 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_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)
             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')
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, 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')
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, 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_referee_stats(session, aggregation_type='org', aggregation_id=org_id)
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Weekly')
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Daily')
         
     # Aggregate by level
     level_ids = session.query(Division.level_id).distinct().all()
@@ -254,12 +292,12 @@ def run_aggregate_referee_stats():
         # 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)
+            aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id)
             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)
+            aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id)
 
 if __name__ == "__main__":
     run_aggregate_referee_stats()

hockey_blast_common_lib/aggregate_scorekeeper_stats.py

@@ -10,13 +10,19 @@ from hockey_blast_common_lib.models import Game, ScorekeeperSaveQuality
 from hockey_blast_common_lib.stats_models import OrgStatsScorekeeper, OrgStatsWeeklyScorekeeper, OrgStatsDailyScorekeeper
 from hockey_blast_common_lib.db_connection import create_session
 from sqlalchemy.sql import func, case
-from hockey_blast_common_lib.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, not_human_names
-from hockey_blast_common_lib.utils import get_org_id_from_alias, get_human_ids_by_names
+from hockey_blast_common_lib.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS
+from hockey_blast_common_lib.utils import get_org_id_from_alias, get_non_human_ids
 from hockey_blast_common_lib.utils import assign_ranks
 from hockey_blast_common_lib.utils import get_start_datetime
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
 from hockey_blast_common_lib.progress_utils import create_progress_tracker
 
+# Import status constants for game filtering
+FINAL_STATUS = "Final"
+FINAL_SO_STATUS = "Final(SO)"
+FORFEIT_STATUS = "FORFEIT"
+NOEVENTS_STATUS = "NOEVENTS"
+
 def calculate_quality_score(avg_max_saves_5sec, avg_max_saves_20sec, peak_max_saves_5sec, peak_max_saves_20sec):
     """
     Calculate a quality score based on excessive clicking patterns.
@@ -51,13 +57,13 @@ def calculate_quality_score(avg_max_saves_5sec, avg_max_saves_20sec, peak_max_sa
 
     return round(score, 2)
 
-def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, names_to_filter_out, aggregation_window=None):
+def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, aggregation_window=None):
     # Only process scorekeeper stats for ALL_ORGS_ID - skip individual organizations
     # This prevents redundant processing when upstream logic calls with all organization IDs
     if aggregation_type == 'org' and aggregation_id != ALL_ORGS_ID:
         return  # Do nothing for individual organization IDs
 
-    human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
+    human_ids_to_filter = get_non_human_ids(session)
 
     if aggregation_type == 'org':
         aggregation_name = "All Orgs"
@@ -89,9 +95,19 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, names
 
 
     # Aggregate scorekeeper quality data for each human
+    # games_participated: Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
+    # games_with_stats: Count only FINAL, FINAL_SO (for per-game averages)
     scorekeeper_quality_stats = session.query(
         ScorekeeperSaveQuality.scorekeeper_id.label('human_id'),
-        func.count(ScorekeeperSaveQuality.game_id).label('games_recorded'),
+        func.count(ScorekeeperSaveQuality.game_id).label('games_recorded'),  # DEPRECATED - will be replaced by games_participated
+        func.sum(case(
+            (Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS, FORFEIT_STATUS, NOEVENTS_STATUS]), 1),
+            else_=0
+        )).label('games_participated'),
+        func.sum(case(
+            (Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS]), 1),
+            else_=0
+        )).label('games_with_stats'),
         func.sum(ScorekeeperSaveQuality.total_saves_recorded).label('total_saves_recorded'),
         func.avg(ScorekeeperSaveQuality.total_saves_recorded).label('avg_saves_per_game'),
         func.avg(ScorekeeperSaveQuality.max_saves_per_5sec).label('avg_max_saves_per_5sec'),
@@ -120,7 +136,9 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, names
         )
 
         stats_dict[key] = {
-            'games_recorded': stat.games_recorded,
+            'games_recorded': stat.games_recorded,  # DEPRECATED - for backward compatibility
+            'games_participated': stat.games_participated,  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+            'games_with_stats': stat.games_with_stats,  # Games with full stats: FINAL, FINAL_SO only
             'sog_given': stat.total_saves_recorded,  # Legacy field name mapping
             'sog_per_game': stat.avg_saves_per_game or 0.0,  # Legacy field name mapping
             'total_saves_recorded': stat.total_saves_recorded,
@@ -152,6 +170,8 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, names
 
     # Assign ranks - note: for quality metrics, lower values are better (reverse_rank=True for avg and peak clicking)
     assign_ranks(stats_dict, 'games_recorded')
+    assign_ranks(stats_dict, 'games_participated')  # Rank by total participation
+    assign_ranks(stats_dict, 'games_with_stats')  # Rank by games with full stats
     assign_ranks(stats_dict, 'sog_given')  # Legacy field
     assign_ranks(stats_dict, 'sog_per_game')  # Legacy field
     assign_ranks(stats_dict, 'total_saves_recorded')
@@ -169,7 +189,11 @@ def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, names
         scorekeeper_stat = StatsModel(
             aggregation_id=aggregation_id,
             human_id=human_id,
-            games_recorded=stat['games_recorded'],
+            games_recorded=stat['games_recorded'],  # DEPRECATED - for backward compatibility
+            games_participated=stat['games_participated'],  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+            games_participated_rank=stat['games_participated_rank'],
+            games_with_stats=stat['games_with_stats'],  # Games with full stats: FINAL, FINAL_SO only
+            games_with_stats_rank=stat['games_with_stats_rank'],
             sog_given=stat['sog_given'],  # Legacy field mapping
             sog_per_game=stat['sog_per_game'],  # Legacy field mapping
             total_saves_recorded=stat['total_saves_recorded'],
@@ -216,16 +240,16 @@ def run_aggregate_scorekeeper_stats():
         if human_id_to_debug is None:
             org_name = "All Organizations" if org_id == ALL_ORGS_ID else session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
             org_progress = create_progress_tracker(3, f"Processing scorekeeper stats for {org_name}")
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names)
+            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id)
             org_progress.update(1)
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Weekly')
             org_progress.update(2)
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Daily')
             org_progress.update(3)
         else:
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names)
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
-            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id)
+            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Weekly')
+            aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=org_id, aggregation_window='Daily')
 
 if __name__ == "__main__":
     run_aggregate_scorekeeper_stats()

hockey_blast_common_lib/aggregate_skater_stats.py

@@ -10,14 +10,20 @@ from hockey_blast_common_lib.models import Game, Goal, Penalty, GameRoster, Orga
 from hockey_blast_common_lib.stats_models import OrgStatsSkater, DivisionStatsSkater, OrgStatsWeeklySkater, OrgStatsDailySkater, DivisionStatsWeeklySkater, DivisionStatsDailySkater, LevelStatsSkater
 from hockey_blast_common_lib.db_connection import create_session
 from sqlalchemy.sql import func, case
-from hockey_blast_common_lib.options import not_human_names, parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_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.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS
+from hockey_blast_common_lib.utils import get_org_id_from_alias, get_non_human_ids, get_division_ids_for_last_season_in_all_leagues, get_all_division_ids_for_org
 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
 
+# Import status constants for game filtering
+FINAL_STATUS = "Final"
+FINAL_SO_STATUS = "Final(SO)"
+FORFEIT_STATUS = "FORFEIT"
+NOEVENTS_STATUS = "NOEVENTS"
+
 def calculate_current_point_streak(session, human_id, filter_condition):
     """
     Calculate the current point streak for a player.
@@ -64,8 +70,8 @@ def calculate_current_point_streak(session, human_id, filter_condition):
     
     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)
+def aggregate_skater_stats(session, aggregation_type, aggregation_id, debug_human_id=None, aggregation_window=None):
+    human_ids_to_filter = get_non_human_ids(session)
 
     # Get the name of the aggregation, for debug purposes
     if aggregation_type == 'org':
@@ -138,16 +144,26 @@ 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_participated: Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
+    # games_with_stats: Count only FINAL, FINAL_SO (for per-game averages)
     games_played_query = session.query(
         GameRoster.human_id,
-        func.count(Game.id).label('games_played'),
+        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.array_agg(Game.id).label('game_ids')
     ).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
@@ -206,7 +222,9 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         key = (aggregation_id, stat.human_id)
         if key not in stats_dict:
             stats_dict[key] = {
-                'games_played': 0,
+                'games_played': 0,  # DEPRECATED - for backward compatibility
+                'games_participated': 0,  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+                'games_with_stats': 0,  # Games with full stats: FINAL, FINAL_SO only
                 'goals': 0,
                 'assists': 0,
                 'penalties': 0,
@@ -224,6 +242,8 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
                 'last_game_id': None
             }
         stats_dict[key]['games_played'] += stat.games_played
+        stats_dict[key]['games_participated'] += stat.games_participated
+        stats_dict[key]['games_with_stats'] += stat.games_with_stats
         stats_dict[key]['game_ids'].extend(stat.game_ids)
 
     # Filter out entries with games_played less than min_games
@@ -253,14 +273,14 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             stats_dict[key]['penalties'] += stat.penalties
             stats_dict[key]['gm_penalties'] += stat.gm_penalties  # Update GM penalties
 
-    # Calculate per game stats
+    # Calculate per game stats (using games_with_stats as denominator for accuracy)
     for key, stat in stats_dict.items():
-        if stat['games_played'] > 0:
-            stat['goals_per_game'] = stat['goals'] / stat['games_played']
-            stat['points_per_game'] = stat['points'] / stat['games_played']
-            stat['assists_per_game'] = stat['assists'] / stat['games_played']
-            stat['penalties_per_game'] = stat['penalties'] / stat['games_played']
-            stat['gm_penalties_per_game'] = stat['gm_penalties'] / stat['games_played']  # Calculate GM penalties per game
+        if stat['games_with_stats'] > 0:
+            stat['goals_per_game'] = stat['goals'] / stat['games_with_stats']
+            stat['points_per_game'] = stat['points'] / stat['games_with_stats']
+            stat['assists_per_game'] = stat['assists'] / stat['games_with_stats']
+            stat['penalties_per_game'] = stat['penalties'] / stat['games_with_stats']
+            stat['gm_penalties_per_game'] = stat['gm_penalties'] / stat['games_with_stats']  # Calculate GM penalties per game
 
     # 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}
@@ -292,6 +312,8 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             stats_dict[key][f'{field}_rank'] = rank
 
     assign_ranks(stats_dict, 'games_played')
+    assign_ranks(stats_dict, 'games_participated')  # Rank by total participation
+    assign_ranks(stats_dict, 'games_with_stats')  # Rank by games with full stats
     assign_ranks(stats_dict, 'goals')
     assign_ranks(stats_dict, 'assists')
     assign_ranks(stats_dict, 'points')
@@ -330,7 +352,11 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         skater_stat = StatsModel(
             aggregation_id=aggregation_id,
             human_id=human_id,
-            games_played=stat['games_played'],
+            games_played=stat['games_played'],  # DEPRECATED - for backward compatibility
+            games_participated=stat['games_participated'],  # Total games: FINAL, FINAL_SO, FORFEIT, NOEVENTS
+            games_participated_rank=stat['games_participated_rank'],
+            games_with_stats=stat['games_with_stats'],  # Games with full stats: FINAL, FINAL_SO only
+            games_with_stats_rank=stat['games_with_stats_rank'],
             goals=stat['goals'],
             assists=stat['assists'],
             points=stat['goals'] + stat['assists'],
@@ -382,30 +408,30 @@ def run_aggregate_skater_stats():
             # 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')
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, debug_human_id=human_id_to_debug)
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, 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')
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, debug_human_id=human_id_to_debug)
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, 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)
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, 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')
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, 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')
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, 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_skater_stats(session, aggregation_type='org', aggregation_id=org_id, debug_human_id=human_id_to_debug)
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, debug_human_id=human_id_to_debug, aggregation_window='Daily')
         
     # Aggregate by level
     level_ids = session.query(Division.level_id).distinct().all()
@@ -415,12 +441,12 @@ def run_aggregate_skater_stats():
         # 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)
+            aggregate_skater_stats(session, aggregation_type='level', aggregation_id=level_id, 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)
+            aggregate_skater_stats(session, aggregation_type='level', aggregation_id=level_id, debug_human_id=human_id_to_debug)
 
 if __name__ == "__main__":
     run_aggregate_skater_stats()

hockey_blast_common_lib/options.py

@@ -9,17 +9,6 @@ MIN_GAMES_FOR_LEVEL_STATS = 1
 
 orgs = {'caha', 'sharksice', 'tvice'}
 
-not_human_names = [
-    ("Home", None, None),
-    ("Away", None, None),
-    (None, "Unknown", None),
-    ("Not", None , None),
-    (None , None, "Goalie"),
-    ("Unassigned",None , None),
-    # Critical addition - primary cause of 93.4% of roster insertion errors
-    ("Not", "Signed", "In")
-]
-
 def parse_args():
     parser = argparse.ArgumentParser(description="Process data for a specific organization.")
     parser.add_argument("org", choices=orgs, help="The organization to process (e.g., 'caha', 'sharksice', 'tvice').")

hockey_blast_common_lib/progress_utils.py

@@ -4,26 +4,34 @@ from datetime import datetime, timedelta
 class ProgressTracker:
     """
     Reusable progress tracker with ETA calculation for stats aggregation processes.
+    Supports optional custom counters for tracking additional metrics.
     """
-    
-    def __init__(self, total_items, description="Processing"):
+
+    def __init__(self, total_items, description="Processing", custom_counters=None):
         self.total_items = total_items
         self.description = description
         self.start_time = time.time()
         self.processed_items = 0
         self.last_update_time = self.start_time
+        self.custom_counters = custom_counters if custom_counters else {}
         
-    def update(self, processed_count=None):
+    def update(self, processed_count=None, **kwargs):
         """
         Update progress. If processed_count is None, increment by 1.
+        kwargs can be used to update custom counters.
         """
         if processed_count is not None:
             self.processed_items = processed_count
         else:
             self.processed_items += 1
-            
+
+        # Update custom counters
+        for key, value in kwargs.items():
+            if key in self.custom_counters:
+                self.custom_counters[key] = value
+
         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()
@@ -52,10 +60,15 @@ class ProgressTracker:
                 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}"
-        
+
+        # Add custom counters to the display
+        if self.custom_counters:
+            counter_parts = [f"{key}: {value}" for key, value in self.custom_counters.items()]
+            progress_msg += " | " + ", ".join(counter_parts)
+
         print(progress_msg, end="", flush=True)
         
         # Add newline when complete
@@ -84,8 +97,9 @@ class ProgressTracker:
         self.processed_items = self.total_items
         self._display_progress()
 
-def create_progress_tracker(total_items, description="Processing"):
+def create_progress_tracker(total_items, description="Processing", custom_counters=None):
     """
     Factory function to create a progress tracker.
+    custom_counters: dict of counter_name: initial_value for additional metrics to track
     """
-    return ProgressTracker(total_items, description)
+    return ProgressTracker(total_items, description, custom_counters)

hockey_blast_common_lib/stats_models.py

@@ -52,8 +52,12 @@ class BaseStatsSkater(db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
-    games_played = db.Column(db.Integer, default=0)
+    games_played = db.Column(db.Integer, default=0)  # DEPRECATED - use games_participated instead
     games_played_rank = db.Column(db.Integer, default=0)
+    games_participated = db.Column(db.Integer, default=0)  # Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
+    games_participated_rank = db.Column(db.Integer, default=0)
+    games_with_stats = db.Column(db.Integer, default=0)  # Count only FINAL, FINAL_SO
+    games_with_stats_rank = db.Column(db.Integer, default=0)
     goals = db.Column(db.Integer, default=0)
     goals_rank = db.Column(db.Integer, default=0)
     assists = db.Column(db.Integer, default=0)
@@ -104,8 +108,12 @@ class BaseStatsGoalie(db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
-    games_played = db.Column(db.Integer, default=0)
+    games_played = db.Column(db.Integer, default=0)  # DEPRECATED - use games_participated instead
     games_played_rank = db.Column(db.Integer, default=0)
+    games_participated = db.Column(db.Integer, default=0)  # Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
+    games_participated_rank = db.Column(db.Integer, default=0)
+    games_with_stats = db.Column(db.Integer, default=0)  # Count only FINAL, FINAL_SO
+    games_with_stats_rank = db.Column(db.Integer, default=0)
     goals_allowed = db.Column(db.Integer, default=0)
     goals_allowed_rank = db.Column(db.Integer, default=0)
     goals_allowed_per_game = db.Column(db.Float, default=0.0)
@@ -137,8 +145,12 @@ class BaseStatsReferee(db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
-    games_reffed = db.Column(db.Integer, default=0)
+    games_reffed = db.Column(db.Integer, default=0)  # DEPRECATED - use games_participated instead
     games_reffed_rank = db.Column(db.Integer, default=0)
+    games_participated = db.Column(db.Integer, default=0)  # Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
+    games_participated_rank = db.Column(db.Integer, default=0)
+    games_with_stats = db.Column(db.Integer, default=0)  # Count only FINAL, FINAL_SO (for per-game averages)
+    games_with_stats_rank = db.Column(db.Integer, default=0)
     penalties_given = db.Column(db.Integer, default=0)
     penalties_given_rank = db.Column(db.Integer, default=0)
     penalties_per_game = db.Column(db.Float, default=0.0)
@@ -170,8 +182,12 @@ class BaseStatsScorekeeper(db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
-    games_recorded = db.Column(db.Integer, default=0)
+    games_recorded = db.Column(db.Integer, default=0)  # DEPRECATED - use games_participated instead
     games_recorded_rank = db.Column(db.Integer, default=0)
+    games_participated = db.Column(db.Integer, default=0)  # Count FINAL, FINAL_SO, FORFEIT, NOEVENTS
+    games_participated_rank = db.Column(db.Integer, default=0)
+    games_with_stats = db.Column(db.Integer, default=0)  # Count only FINAL, FINAL_SO (for per-game averages)
+    games_with_stats_rank = db.Column(db.Integer, default=0)
     sog_given = db.Column(db.Integer, default=0)
     sog_given_rank = db.Column(db.Integer, default=0)
     sog_per_game = db.Column(db.Float, default=0.0)

hockey_blast_common_lib/utils.py

@@ -52,6 +52,24 @@ def get_human_ids_by_names(session, names):
         human_ids.update([result.id for result in results])
     return human_ids
 
+def get_non_human_ids(session):
+    """Get IDs of non-human entities (placeholder names, test accounts, etc.)
+
+    Returns set of human_ids that should be filtered out from statistics.
+    Filters out placeholder names like "Home", "Away", "Unknown", etc.
+    """
+    not_human_names = [
+        ("Home", None, None),
+        ("Away", None, None),
+        (None, "Unknown", None),
+        ("Not", None, None),
+        (None, None, "Goalie"),
+        ("Unassigned", None, None),
+        ("Not", "Signed", "In"),
+        ("Incognito", None, None)
+    ]
+    return get_human_ids_by_names(session, not_human_names)
+
 def get_division_ids_for_last_season_in_all_leagues(session, org_id):
     # # TODO = remove tmp hack
     # return get_all_division_ids_for_org(session, org_id)

{hockey_blast_common_lib-0.1.60.dist-info → hockey_blast_common_lib-0.1.62.dist-info}/METADATA

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

{hockey_blast_common_lib-0.1.60.dist-info → hockey_blast_common_lib-0.1.62.dist-info}/RECORD

@@ -1,28 +1,28 @@
 hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hockey_blast_common_lib/aggregate_all_stats.py,sha256=QhuSvGjuk4jVywNRcgxB-9ooJAoAbZRkaLjLe9Q1hEM,1363
-hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=lJE5TMBtJLqLeG9jxHV5xUcudusZ4t8yHQN6TvPK_0k,13804
+hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=5FwmRAW8ydgFd7LGZtH1j-7TCA50piT6igCsuy8bBqo,14883
 hockey_blast_common_lib/aggregate_h2h_stats.py,sha256=dC5TcJZGkpIQTiq3z40kOX6EjEhFbGv5EL0P1EClBQ0,11117
-hockey_blast_common_lib/aggregate_human_stats.py,sha256=ku42TAjUIj49822noM8fEeB8GS4vFeCCNrLupTWmqzg,26043
-hockey_blast_common_lib/aggregate_referee_stats.py,sha256=mUcTVQH9K4kwmIfgfGsnh_3AqX6Ia3RjfukkYuQas3I,13938
+hockey_blast_common_lib/aggregate_human_stats.py,sha256=JZcXJofF1wmFPcLbalM_GiXrq22eUJO28R_xyypw4rI,25456
+hockey_blast_common_lib/aggregate_referee_stats.py,sha256=rVxbuDjxYbI5zNlvOSbSHeG8yeuDpJSLNmjZKn3rBhQ,15764
 hockey_blast_common_lib/aggregate_s2s_stats.py,sha256=urYN0Q06twwLO-XWGlSMVAVOTVR_D2AWdmoGsxIYHXE,6737
-hockey_blast_common_lib/aggregate_scorekeeper_stats.py,sha256=Y0SSCBoujXNMs1_f-zn6odbLIrdTTkzOCpUyH40WBVs,12288
-hockey_blast_common_lib/aggregate_skater_stats.py,sha256=pA_2pDOGcJyEywISg2ySG8gFCuoLWwqw6a3Gm2wHLyo,23302
+hockey_blast_common_lib/aggregate_scorekeeper_stats.py,sha256=_0HR-KsuEPM7LFTVvmm8RwH_Y1_H9qrvW-wEMFI7LNU,13488
+hockey_blast_common_lib/aggregate_skater_stats.py,sha256=Tp7tJ03YdlVsm5yBNJYc7TC243m7GRtcHWO2o4X6kG4,24383
 hockey_blast_common_lib/assign_skater_skill.py,sha256=Asq6iRMPsCMDnvuNSd-M3s4Gee4kDocP9Eznwju_9kA,2749
 hockey_blast_common_lib/db_connection.py,sha256=HvPxDvOj7j5H85RfslGvHVNevfg7mKCd0syJ6NX21mU,1890
 hockey_blast_common_lib/dump_sample_db.sh,sha256=MY3lnzTXBoWd76-ZlZr9nWsKMEVgyRsUn-LZ2d1JWZs,810
 hockey_blast_common_lib/h2h_models.py,sha256=0st4xoJO0U6ONfx3BV03BQvHjZE31e_PqZfphAJMoSU,7968
-hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=e5qPt-WPwRu0-2l5neKpslO_oQtPUU6yiM9rr_In8Q0,4648905
+hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=57W5sPGpAp01YtIe5XrQeCgBCDFTiI-347nuzN3d3IU,4648906
 hockey_blast_common_lib/models.py,sha256=ccM886RcSFDiJ3yj2l9OqRi_PwR1L6WU8AsqzgV3_t0,19598
-hockey_blast_common_lib/options.py,sha256=rQaLRYYcaxXrpZoXfUpmvsahC23oVGPEOzEpqtthbIQ,1794
-hockey_blast_common_lib/progress_utils.py,sha256=H_zRFOsb2qQQpGw56wJghZ1nUe_m6zqGeR9hZ33Y1Uo,3229
+hockey_blast_common_lib/options.py,sha256=XecGGlizbul7BnMePrvIqvEq5_w49UoG3Yu9iv961gg,1499
+hockey_blast_common_lib/progress_utils.py,sha256=7cqyUTMmW3xAIh5JKFlhnBiybCJ9WvGDz7ihH59Lc_0,3953
 hockey_blast_common_lib/restore_sample_db.sh,sha256=7W3lzRZeu9zXIu1Bvtnaw8EHc1ulHmFM4mMh86oUQJo,2205
 hockey_blast_common_lib/skills_in_divisions.py,sha256=m-UEwMwn1KM7wOYvDstgsOEeH57M9V6yrkBoghzGYKE,7005
 hockey_blast_common_lib/skills_propagation.py,sha256=nUxntyK8M4xWjHpkfze8f0suaBeunxicgDCduGmNJ-A,18468
-hockey_blast_common_lib/stats_models.py,sha256=64sUq_iWhNXi_b_V_1INuQ1RusKaTASjurkRo5gQOs4,26703
+hockey_blast_common_lib/stats_models.py,sha256=yLfsR0RhSc95-8ULdJ8tuvLd6RjIFkgZ74ejubJYVUw,28187
 hockey_blast_common_lib/stats_utils.py,sha256=DXsPO4jw8XsdRUN46TGF_IiBAfz3GCIVBswCGp5ELDk,284
-hockey_blast_common_lib/utils.py,sha256=PduHp6HoI4sfr5HvJfQAaz7170dy5kTFVdIfWvBR-Jg,5874
+hockey_blast_common_lib/utils.py,sha256=1YJRAj1lhftjIAM2frFi4A4K90kCJaxWlgBQ1-77xZY,6486
 hockey_blast_common_lib/wsgi.py,sha256=y3NxoJfWjdzX3iP7RGvDEer6zcnPyCanpqSgW1BlXgg,779
-hockey_blast_common_lib-0.1.60.dist-info/METADATA,sha256=6GOkTYr8oNmJWRRPQiAraI4waI5ppLySU5DKBIXP4bw,318
-hockey_blast_common_lib-0.1.60.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.60.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.60.dist-info/RECORD,,
+hockey_blast_common_lib-0.1.62.dist-info/METADATA,sha256=zCGOcewa8kzP4jNrlDR-xmPFh7SygSOsYtXXG9kVhRc,318
+hockey_blast_common_lib-0.1.62.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.62.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.62.dist-info/RECORD,,