hockey-blast-common-lib 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

hockey_blast_common_lib/aggregate_referee_stats.py

@@ -0,0 +1,229 @@
+import sys, os
+from datetime import datetime, timedelta
+import sqlalchemy
+from models import Game, Penalty
+from stats_models import OrgStatsReferee, DivisionStatsReferee,OrgStatsWeeklyReferee, OrgStatsDailyReferee, DivisionStatsWeeklyReferee, DivisionStatsDailyReferee
+from db_connection import create_session
+from sqlalchemy.sql import func, case
+from options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, not_human_names
+from utils import get_org_id_from_alias, get_human_ids_by_names, get_division_ids_for_last_season_in_all_leagues
+
+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':
+        if aggregation_window == 'Daily':
+            StatsModel = OrgStatsDailyReferee
+        elif aggregation_window == 'Weekly':
+            StatsModel = OrgStatsWeeklyReferee
+        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
+        elif aggregation_window == 'Weekly':
+            StatsModel = DivisionStatsWeeklyReferee
+        else:
+            StatsModel = DivisionStatsReferee
+        min_games = MIN_GAMES_FOR_DIVISION_STATS
+        filter_condition = Game.division_id == aggregation_id
+    else:
+        raise ValueError("Invalid aggregation type")
+
+    # Apply aggregation window filter
+    if aggregation_window:
+        last_game_datetime = session.query(func.max(func.concat(Game.date, ' ', Game.time))).filter(filter_condition, Game.status.like('Final%')).scalar()
+        if last_game_datetime:
+            last_game_datetime = datetime.strptime(last_game_datetime, '%Y-%m-%d %H:%M:%S')
+            if aggregation_window == 'Daily':
+                start_datetime = last_game_datetime - timedelta(days=1)
+            elif aggregation_window == 'Weekly':
+                start_datetime = last_game_datetime - timedelta(weeks=1)
+            else:
+                start_datetime = None
+            if start_datetime:
+                game_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP).between(start_datetime, last_game_datetime)
+                filter_condition = filter_condition & game_window_filter
+
+    # Delete existing items from the stats table
+    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
+    session.commit()
+
+    # Aggregate games reffed for each referee
+    games_reffed_stats = session.query(
+        Game.referee_1_id.label('human_id'),
+        func.count(Game.id).label('games_reffed'),
+        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.array_agg(Game.id).label('game_ids')
+    ).filter(filter_condition).group_by(Game.referee_2_id).all()
+
+    # Aggregate penalties given for each referee
+    penalties_given_stats = session.query(
+        Game.id.label('game_id'),
+        Game.referee_1_id,
+        Game.referee_2_id,
+        func.count(Penalty.id).label('penalties_given'),
+        func.sum(case((func.lower(Penalty.penalty_minutes) == 'gm', 1), else_=0)).label('gm_given')
+    ).join(Game, Game.id == Penalty.game_id).filter(filter_condition).group_by(Game.id, Game.referee_1_id, Game.referee_2_id).all()
+
+    # Combine the results
+    stats_dict = {}
+    for stat in games_reffed_stats:
+        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
+        }
+
+    for stat in games_reffed_stats_2:
+        if stat.human_id in human_ids_to_filter:
+            continue
+        key = (aggregation_id, stat.human_id)
+        if key not in stats_dict:
+            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
+            }
+        else:
+            stats_dict[key]['games_reffed'] += stat.games_reffed
+            stats_dict[key]['game_ids'].extend(stat.game_ids)
+
+    for stat in penalties_given_stats:
+        if stat.referee_1_id and stat.referee_1_id not in human_ids_to_filter:
+            key = (aggregation_id, stat.referee_1_id)
+            if key not in stats_dict:
+                stats_dict[key] = {
+                    'games_reffed': 0,
+                    'penalties_given': stat.penalties_given / 2,
+                    'gm_given': stat.gm_given / 2,
+                    'penalties_per_game': 0.0,
+                    'gm_per_game': 0.0,
+                    'game_ids': [stat.game_id],
+                    'first_game_id': None,
+                    'last_game_id': None
+                }
+            else:
+                stats_dict[key]['penalties_given'] += stat.penalties_given / 2
+                stats_dict[key]['gm_given'] += stat.gm_given / 2
+                stats_dict[key]['game_ids'].append(stat.game_id)
+
+        if stat.referee_2_id and stat.referee_2_id not in human_ids_to_filter:
+            key = (aggregation_id, stat.referee_2_id)
+            if key not in stats_dict:
+                stats_dict[key] = {
+                    'games_reffed': 0,
+                    'penalties_given': stat.penalties_given / 2,
+                    'gm_given': stat.gm_given / 2,
+                    'penalties_per_game': 0.0,
+                    'gm_per_game': 0.0,
+                    'game_ids': [stat.game_id],
+                    'first_game_id': None,
+                    'last_game_id': None
+                }
+            else:
+                stats_dict[key]['penalties_given'] += stat.penalties_given / 2
+                stats_dict[key]['gm_given'] += stat.gm_given / 2
+                stats_dict[key]['game_ids'].append(stat.game_id)
+
+    # Calculate per game stats
+    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']
+
+    # 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}
+
+    # Populate first_game_id and last_game_id
+    for key, stat in stats_dict.items():
+        all_game_ids = stat['game_ids']
+        if all_game_ids:
+            first_game = session.query(Game).filter(Game.id.in_(all_game_ids)).order_by(Game.date, Game.time).first()
+            last_game = session.query(Game).filter(Game.id.in_(all_game_ids)).order_by(Game.date.desc(), Game.time.desc()).first()
+            stat['first_game_id'] = first_game.id if first_game else None
+            stat['last_game_id'] = last_game.id if last_game else None
+
+    # Calculate total_in_rank
+    total_in_rank = len(stats_dict)
+
+    # Assign ranks
+    def assign_ranks(stats_dict, field):
+        sorted_stats = sorted(stats_dict.items(), key=lambda x: x[1][field], reverse=True)
+        for rank, (key, stat) in enumerate(sorted_stats, start=1):
+            stats_dict[key][f'{field}_rank'] = rank
+
+    assign_ranks(stats_dict, 'games_reffed')
+    assign_ranks(stats_dict, 'penalties_given')
+    assign_ranks(stats_dict, 'penalties_per_game')
+    assign_ranks(stats_dict, 'gm_given')
+    assign_ranks(stats_dict, 'gm_per_game')
+
+    # Insert aggregated stats into the appropriate table with progress output
+    total_items = len(stats_dict)
+    batch_size = 1000
+    for i, (key, stat) in enumerate(stats_dict.items(), 1):
+        aggregation_id, human_id = key
+        if stat['games_reffed'] < min_games:
+            continue
+        referee_stat = StatsModel(
+            aggregation_id=aggregation_id,
+            human_id=human_id,
+            games_reffed=stat['games_reffed'],
+            penalties_given=stat['penalties_given'],
+            penalties_per_game=stat['penalties_per_game'],
+            gm_given=stat['gm_given'],
+            gm_per_game=stat['gm_per_game'],
+            games_reffed_rank=stat['games_reffed_rank'],
+            penalties_given_rank=stat['penalties_given_rank'],
+            penalties_per_game_rank=stat['penalties_per_game_rank'],
+            gm_given_rank=stat['gm_given_rank'],
+            gm_per_game_rank=stat['gm_per_game_rank'],
+            total_in_rank=total_in_rank,
+            first_game_id=stat['first_game_id'],
+            last_game_id=stat['last_game_id']
+        )
+        session.add(referee_stat)
+        # Commit in batches
+        if i % batch_size == 0:
+            session.commit()
+            print(f"\r{i}/{total_items} ({(i/total_items)*100:.2f}%)", end="")
+    session.commit()
+    print(f"\r{total_items}/{total_items} (100.00%)")
+    print("\nDone.")
+
+# Example usage
+if __name__ == "__main__":
+    args = parse_args()
+    org_alias = args.org
+    session = create_session("boss")
+    org_id = get_org_id_from_alias(session, org_alias)
+    division_ids = get_division_ids_for_last_season_in_all_leagues(session, org_id)
+    print(f"Aggregating referee stats for {len(division_ids)} divisions in {org_alias}...")
+    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='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')

hockey_blast_common_lib/aggregate_skater_stats.py

@@ -0,0 +1,323 @@
+import sys, os
+from datetime import datetime, timedelta
+import sqlalchemy
+from options import not_human_names
+
+from models import Game, Goal, Penalty, GameRoster
+from stats_models import OrgStatsSkater, DivisionStatsSkater, OrgStatsWeeklySkater, OrgStatsDailySkater, DivisionStatsWeeklySkater, DivisionStatsDailySkater
+from db_connection import create_session
+from sqlalchemy.sql import func, case
+from options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS
+from utils import get_org_id_from_alias, get_human_ids_by_names, get_division_ids_for_last_season_in_all_leagues
+from sqlalchemy import func, case, and_
+
+def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_filter_out, filter_human_id=None, aggregation_window=None):
+    human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
+
+    if aggregation_type == 'org':
+        if aggregation_window == 'Daily':
+            StatsModel = OrgStatsDailySkater
+        elif aggregation_window == 'Weekly':
+            StatsModel = OrgStatsWeeklySkater
+        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
+        elif aggregation_window == 'Weekly':
+            StatsModel = DivisionStatsWeeklySkater
+        else:
+            StatsModel = DivisionStatsSkater
+        min_games = MIN_GAMES_FOR_DIVISION_STATS
+        filter_condition = Game.division_id == aggregation_id
+    else:
+        raise ValueError("Invalid aggregation type")
+
+    # Apply aggregation window filter
+    if aggregation_window:
+        last_game_datetime = session.query(func.max(func.concat(Game.date, ' ', Game.time))).filter(filter_condition, Game.status.like('Final%')).scalar()
+        if last_game_datetime:
+            last_game_datetime = datetime.strptime(last_game_datetime, '%Y-%m-%d %H:%M:%S')
+            if aggregation_window == 'Daily':
+                start_datetime = last_game_datetime - timedelta(days=1)
+            elif aggregation_window == 'Weekly':
+                start_datetime = last_game_datetime - timedelta(weeks=1)
+            else:
+                start_datetime = None
+            if start_datetime:
+                game_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP).between(start_datetime, last_game_datetime)
+                filter_condition = filter_condition & game_window_filter
+
+    # Delete existing items from the stats table
+    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
+    session.commit()
+
+    # Filter for specific human_id if provided
+    human_filter = []
+    if filter_human_id:
+        human_filter = [GameRoster.human_id == filter_human_id]
+
+    # 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).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, 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)).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, 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)).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, 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)).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, 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.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)).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, Penalty.penalized_player_id).all()
+
+    # Combine the results
+    stats_dict = {}
+    for stat in games_played_stats:
+        if stat.human_id in human_ids_to_filter:
+            continue
+        key = (aggregation_id, stat.human_id)
+        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
+        }
+
+    for stat in goals_stats:
+        if stat.human_id in human_ids_to_filter:
+            continue
+        key = (aggregation_id, stat.human_id)
+        if key not in stats_dict:
+            stats_dict[key] = {
+                'games_played': 0,
+                'goals': stat.goals,
+                'assists': 0,
+                'penalties': 0,
+                'points': stat.goals,  # Initialize points with goals
+                '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
+            }
+        else:
+            stats_dict[key]['goals'] += stat.goals
+            stats_dict[key]['points'] += stat.goals  # Update points
+
+    for stat in assists_stats:
+        if stat.human_id in human_ids_to_filter:
+            continue
+        key = (aggregation_id, stat.human_id)
+        if key not in stats_dict:
+            stats_dict[key] = {
+                'games_played': 0,
+                'goals': 0,
+                'assists': stat.assists,
+                'penalties': 0,
+                'points': stat.assists,  # Initialize points with assists
+                '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
+            }
+        else:
+            stats_dict[key]['assists'] += stat.assists
+            stats_dict[key]['points'] += stat.assists  # Update points
+
+    for stat in assists_stats_2:
+        if stat.human_id in human_ids_to_filter:
+            continue
+        key = (aggregation_id, stat.human_id)
+        if key not in stats_dict:
+            stats_dict[key] = {
+                'games_played': 0,
+                'goals': 0,
+                'assists': stat.assists,
+                'penalties': 0,
+                'points': stat.assists,  # Initialize points with assists
+                '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
+            }
+        else:
+            stats_dict[key]['assists'] += stat.assists
+            stats_dict[key]['points'] += stat.assists  # Update points
+
+    for stat in penalties_stats:
+        if stat.human_id in human_ids_to_filter:
+            continue
+        key = (aggregation_id, stat.human_id)
+        if key not in stats_dict:
+            stats_dict[key] = {
+                'games_played': 0,
+                'goals': 0,
+                'assists': 0,
+                'penalties': stat.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
+            }
+        else:
+            stats_dict[key]['penalties'] += stat.penalties
+
+    # Calculate per game stats
+    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']
+
+    # 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}
+
+    # Populate first_game_id and last_game_id
+    for key, stat in stats_dict.items():
+        all_game_ids = stat['game_ids']
+        if all_game_ids:
+            first_game = session.query(Game).filter(Game.id.in_(all_game_ids)).order_by(Game.date, Game.time).first()
+            last_game = session.query(Game).filter(Game.id.in_(all_game_ids)).order_by(Game.date.desc(), Game.time.desc()).first()
+            stat['first_game_id'] = first_game.id if first_game else None
+            stat['last_game_id'] = last_game.id if last_game else None
+
+    # Debug output for totals if filter_human_id is provided
+    if filter_human_id:
+        for key, stat in stats_dict.items():
+            if key[1] == filter_human_id:
+                print(f"Human ID: {filter_human_id}")
+                print(f"Total Games Played: {stat['games_played']}")
+                print(f"Total Goals: {stat['goals']}")
+                print(f"Total Assists: {stat['assists']}")
+                print(f"Total Penalties: {stat['penalties']}")
+
+    # Calculate total_in_rank
+    total_in_rank = len(stats_dict)
+
+    # Assign ranks
+    def assign_ranks(stats_dict, field):
+        sorted_stats = sorted(stats_dict.items(), key=lambda x: x[1][field], reverse=True)
+        for rank, (key, stat) in enumerate(sorted_stats, start=1):
+            stats_dict[key][f'{field}_rank'] = rank
+
+    assign_ranks(stats_dict, 'games_played')
+    assign_ranks(stats_dict, 'goals')
+    assign_ranks(stats_dict, 'assists')
+    assign_ranks(stats_dict, 'points')
+    assign_ranks(stats_dict, 'penalties')
+    assign_ranks(stats_dict, 'goals_per_game')
+    assign_ranks(stats_dict, 'points_per_game')
+    assign_ranks(stats_dict, 'assists_per_game')
+    assign_ranks(stats_dict, 'penalties_per_game')
+
+    # Insert aggregated stats into the appropriate table with progress output
+    total_items = len(stats_dict)
+    batch_size = 1000
+    for i, (key, stat) in enumerate(stats_dict.items(), 1):
+        aggregation_id, human_id = key
+        if stat['games_played'] < min_games:
+            continue
+        goals_per_game = stat['goals'] / stat['games_played'] if stat['games_played'] > 0 else 0.0
+        points_per_game = (stat['goals'] + stat['assists']) / stat['games_played'] if stat['games_played'] > 0 else 0.0
+        assists_per_game = stat['assists'] / stat['games_played'] if stat['games_played'] > 0 else 0.0
+        penalties_per_game = stat['penalties'] / stat['games_played'] if stat['games_played'] > 0 else 0.0
+        skater_stat = StatsModel(
+            aggregation_id=aggregation_id,
+            human_id=human_id,
+            games_played=stat['games_played'],
+            goals=stat['goals'],
+            assists=stat['assists'],
+            points=stat['goals'] + stat['assists'],
+            penalties=stat['penalties'],
+            goals_per_game=goals_per_game,
+            points_per_game=points_per_game,
+            assists_per_game=assists_per_game,
+            penalties_per_game=penalties_per_game,
+            games_played_rank=stat['games_played_rank'],
+            goals_rank=stat['goals_rank'],
+            assists_rank=stat['assists_rank'],
+            points_rank=stat['points_rank'],
+            penalties_rank=stat['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'],
+            penalties_per_game_rank=stat['penalties_per_game_rank'],
+            total_in_rank=total_in_rank,
+            first_game_id=stat['first_game_id'],
+            last_game_id=stat['last_game_id']
+        )
+        session.add(skater_stat)
+        # Commit in batches
+        if i % batch_size == 0:
+            session.commit()
+            print(f"\r{i}/{total_items} ({(i/total_items)*100:.2f}%)", end="")
+    session.commit()
+    print(f"\r{total_items}/{total_items} (100.00%)")
+    print("\nDone.")
+
+# Example usage
+if __name__ == "__main__":
+    args = parse_args()
+    org_alias = args.org
+    session = create_session("boss")
+    org_id = get_org_id_from_alias(session, org_alias)
+
+    division_ids = get_division_ids_for_last_season_in_all_leagues(session, org_id)
+    print(f"Aggregating skater stats for {len(division_ids)} divisions in {org_alias}...")
+    for division_id in division_ids:
+        aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, filter_human_id=None)
+        aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, filter_human_id=None, aggregation_window='Weekly')
+        aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, filter_human_id=None, aggregation_window='Daily')
+
+    aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, filter_human_id=None)
+    aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, filter_human_id=None, aggregation_window='Weekly')
+    aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, filter_human_id=None, aggregation_window='Daily')

hockey_blast_common_lib/db_connection.py

@@ -11,6 +11,15 @@ DB_PARAMS = {
         "host": "localhost",
         "port": 5432
     },
+
+    "boss": {
+        "dbname": "hockey_blast",
+        "user": "boss",
+        "password": "WrongPassword",
+        "host": "localhost",
+        "port": 5432
+    },
+
 }
 
 def get_db_params(config_name):

hockey_blast_common_lib/options.py

@@ -0,0 +1,22 @@
+import argparse
+
+MAX_HUMAN_SEARCH_RESULTS = 25
+MAX_TEAM_SEARCH_RESULTS = 25
+MIN_GAMES_FOR_ORG_STATS = 1
+MIN_GAMES_FOR_DIVISION_STATS = 1
+
+orgs = {'caha', 'sharksice', 'tvice'}
+
+not_human_names = [
+    ("Away", None, None),
+    (None, "Unknown", None),
+    ("Not", None , None),
+    (None , None, "Goalie")
+]
+
+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').")
+    parser.add_argument("--reprocess", action="store_true", help="Reprocess existing data.")
+    parser.add_argument("--pre_process", action="store_true", help="Pre-Process existing data.")
+    return parser.parse_args()