hockey-blast-common-lib 0.1.66__py3-none-any.whl → 0.1.67__py3-none-any.whl

hockey_blast_common_lib/aggregate_game_stats_all.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+Orchestrator for per-game statistics aggregation.
+
+This script provides a unified interface for running both skater and goalie
+per-game statistics aggregation. It supports full and append modes and can
+run aggregations for specific roles or all roles together.
+
+Usage examples:
+    # Full regeneration of all per-game stats
+    python aggregate_game_stats_all.py --mode full --role all
+
+    # Append new games for skaters only
+    python aggregate_game_stats_all.py --mode append --role skater
+
+    # Append new games for goalies only
+    python aggregate_game_stats_all.py --mode append --role goalie
+
+The script automatically manages sentinel record tracking across both stat types
+to ensure consistent append mode behavior.
+"""
+
+import argparse
+import os
+import sys
+from datetime import datetime
+
+# Add the package directory to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from hockey_blast_common_lib.aggregate_game_stats_goalie import aggregate_game_stats_goalie
+from hockey_blast_common_lib.aggregate_game_stats_skater import aggregate_game_stats_skater
+from hockey_blast_common_lib.db_connection import create_session
+
+
+def run_aggregation(mode="full", role="all", human_id=None):
+    """Run per-game statistics aggregation.
+
+    Args:
+        mode: "full" to regenerate all records, "append" to process new games only
+        role: "skater", "goalie", or "all" to specify which stats to aggregate
+        human_id: Optional human_id to process only one player (for testing/debugging)
+    """
+    session = create_session("boss")
+
+    start_time = datetime.now()
+    print(f"\n{'='*80}")
+    print(f"PER-GAME STATISTICS AGGREGATION")
+    print(f"Mode: {mode.upper()}")
+    print(f"Role: {role.upper()}")
+    if human_id:
+        print(f"Human ID Filter: {human_id}")
+    print(f"Started: {start_time.strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"{'='*80}\n")
+
+    # Run skater aggregation
+    if role in ["skater", "all"]:
+        try:
+            aggregate_game_stats_skater(session, mode=mode, human_id=human_id)
+        except Exception as e:
+            print(f"\nERROR: Skater aggregation failed: {e}")
+            import traceback
+            traceback.print_exc()
+            if role == "skater":
+                sys.exit(1)
+            # If running all, continue to goalie even if skater fails
+            print("\nContinuing to goalie aggregation...\n")
+
+    # Run goalie aggregation
+    if role in ["goalie", "all"]:
+        try:
+            aggregate_game_stats_goalie(session, mode=mode, human_id=human_id)
+        except Exception as e:
+            print(f"\nERROR: Goalie aggregation failed: {e}")
+            import traceback
+            traceback.print_exc()
+            sys.exit(1)
+
+    end_time = datetime.now()
+    duration = end_time - start_time
+
+    print(f"\n{'='*80}")
+    print(f"AGGREGATION COMPLETE")
+    print(f"Duration: {duration}")
+    print(f"Finished: {end_time.strftime('%Y-%m-%d %H:%M:%S')}")
+    print(f"{'='*80}\n")
+
+
+def main():
+    """Main entry point for CLI."""
+    parser = argparse.ArgumentParser(
+        description="Aggregate per-game statistics for skaters and goalies",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Full regeneration of all stats
+  %(prog)s --mode full --role all
+
+  # Append new games for skaters only
+  %(prog)s --mode append --role skater
+
+  # Append new games for goalies only
+  %(prog)s --mode append --role goalie
+
+Notes:
+  - Full mode deletes and regenerates all records
+  - Append mode uses sentinel tracking with 1-day overlap
+  - Only saves non-zero records (RAG optimization)
+  - Skater stats: saves games with goals, assists, or penalties
+  - Goalie stats: saves games where goalie faced shots
+        """,
+    )
+
+    parser.add_argument(
+        "--mode",
+        choices=["full", "append"],
+        default="full",
+        help="Aggregation mode (default: full)",
+    )
+
+    parser.add_argument(
+        "--role",
+        choices=["skater", "goalie", "all"],
+        default="all",
+        help="Which role stats to aggregate (default: all)",
+    )
+
+    parser.add_argument(
+        "--human-id",
+        type=int,
+        default=None,
+        help="Optional: Limit processing to specific human_id (for testing)",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        run_aggregation(mode=args.mode, role=args.role, human_id=args.human_id)
+    except KeyboardInterrupt:
+        print("\n\nAggregation cancelled by user.")
+        sys.exit(130)
+    except Exception as e:
+        print(f"\n\nFATAL ERROR: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

hockey_blast_common_lib/aggregate_game_stats_goalie.py

@@ -0,0 +1,257 @@
+import os
+import sys
+
+# Add the package directory to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datetime import datetime, timedelta
+
+from sqlalchemy import and_, func
+from sqlalchemy.exc import IntegrityError
+
+from hockey_blast_common_lib.db_connection import create_session
+from hockey_blast_common_lib.models import Division, Game, GameRoster, GoalieSaves, Human
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
+from hockey_blast_common_lib.stats_models import GameStatsGoalie
+from hockey_blast_common_lib.utils import get_non_human_ids
+
+# Import status constants for game filtering
+FINAL_STATUS = "Final"
+FINAL_SO_STATUS = "Final(SO)"
+
+
+def aggregate_game_stats_goalie(session, mode="full", human_id=None):
+    """Aggregate per-game goalie statistics.
+
+    Args:
+        session: Database session
+        mode: "full" to regenerate all records, "append" to process new games only
+        human_id: Optional human_id to process only one goalie (for testing/debugging)
+
+    The function stores individual game performance for each goalie with non-zero stats.
+    Only games where the goalie faced at least one shot are saved.
+    This sparse storage is optimized for RAG system queries.
+
+    Uses Incognito Human sentinel record (game_id=-1) to track last processed timestamp
+    for append mode with 1-day overlap to catch data corrections.
+
+    Note: Uses GameStatsGoalie table but shares sentinel tracking with GameStatsSkater
+    since both are per-game stats that should be processed together.
+    """
+
+    # Get Incognito Human for sentinel tracking (first_name="Incognito", middle_name="", last_name="Human")
+    incognito_human = session.query(Human).filter_by(
+        first_name="Incognito", middle_name="", last_name="Human"
+    ).first()
+    if not incognito_human:
+        raise RuntimeError("Incognito Human not found in database - required for sentinel tracking")
+    incognito_human_id = incognito_human.id
+
+    non_human_ids = get_non_human_ids(session)
+
+    # Add human_id to filter if specified
+    if human_id:
+        human = session.query(Human).filter_by(id=human_id).first()
+        if not human:
+            print(f"ERROR: Human ID {human_id} not found in database")
+            return
+        print(f"Limiting to human_id={human_id}: {human.first_name} {human.last_name}\n")
+
+    print(f"\n{'='*80}")
+    print(f"Aggregating per-game goalie statistics (mode: {mode})")
+    print(f"{'='*80}\n")
+
+    # Determine game filtering based on mode
+    # Note: We check GameStatsSkater for sentinel since they're processed together
+    if mode == "append":
+        # Import here to avoid circular dependency
+        from hockey_blast_common_lib.stats_models import GameStatsSkater
+
+        # Query sentinel record for last processed timestamp
+        sentinel = (
+            session.query(GameStatsSkater)
+            .filter(
+                GameStatsSkater.human_id == incognito_human_id,
+                GameStatsSkater.game_id == -1,
+            )
+            .first()
+        )
+
+        if sentinel:
+            last_processed = datetime.combine(sentinel.game_date, sentinel.game_time)
+            # Subtract 1 day for overlap to catch data corrections
+            start_datetime = last_processed - timedelta(days=1)
+            print(f"Append mode: Processing games after {start_datetime}")
+            print(f"(1-day overlap from last processed: {last_processed})\n")
+
+            # Delete records for games in the overlap window
+            delete_count = (
+                session.query(GameStatsGoalie)
+                .filter(
+                    GameStatsGoalie.human_id != incognito_human_id,
+                    func.cast(
+                        func.concat(GameStatsGoalie.game_date, " ", GameStatsGoalie.game_time),
+                        func.TIMESTAMP,
+                    ) >= start_datetime,
+                )
+                .delete(synchronize_session=False)
+            )
+            session.commit()
+            print(f"Deleted {delete_count} existing records in overlap window\n")
+        else:
+            # No sentinel found, treat as full mode
+            print("No sentinel record found - treating as full mode\n")
+            mode = "full"
+            start_datetime = None
+    else:
+        start_datetime = None
+
+    if mode == "full":
+        # Delete all existing records (no sentinel for goalie table)
+        delete_count = session.query(GameStatsGoalie).delete(synchronize_session=False)
+        session.commit()
+        print(f"Full mode: Deleted {delete_count} existing records\n")
+
+    # Build game filter for eligible games
+    game_filter = Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS])
+    if mode == "append" and start_datetime:
+        game_filter = and_(
+            game_filter,
+            func.cast(
+                func.concat(Game.date, " ", Game.time),
+                func.TIMESTAMP,
+            ) >= start_datetime,
+        )
+
+    # Count total GoalieSaves records to process for progress tracking
+    total_saves_records = (
+        session.query(GoalieSaves)
+        .join(Game, GoalieSaves.game_id == Game.id)
+        .filter(game_filter)
+        .count()
+    )
+    print(f"Processing {total_saves_records} goalie save records...\n")
+
+    if total_saves_records == 0:
+        print("No goalie records to process.\n")
+        return
+
+    # Query goalie saves joined with game metadata and roster
+    # GoalieSaves already has per-game goalie data
+    goalie_query = (
+        session.query(
+            GoalieSaves.game_id,
+            GoalieSaves.goalie_id.label("human_id"),
+            GameRoster.team_id,
+            Game.org_id,
+            Division.level_id,
+            Game.date.label("game_date"),
+            Game.time.label("game_time"),
+            GoalieSaves.goals_allowed,
+            GoalieSaves.shots_against.label("shots_faced"),
+            GoalieSaves.saves_count.label("saves"),
+        )
+        .join(Game, GoalieSaves.game_id == Game.id)
+        .join(Division, Game.division_id == Division.id)
+        .join(
+            GameRoster,
+            and_(
+                GameRoster.game_id == GoalieSaves.game_id,
+                GameRoster.human_id == GoalieSaves.goalie_id,
+            ),
+        )
+        .filter(
+            game_filter,
+            GoalieSaves.goalie_id.notin_(non_human_ids),  # Filter placeholder humans
+        )
+    )
+
+    # Add human_id filter if specified
+    if human_id:
+        goalie_query = goalie_query.filter(GoalieSaves.goalie_id == human_id)
+
+    goalie_records = goalie_query.all()
+
+    print(f"Found {len(goalie_records)} goalie save records\n")
+
+    # Filter to only non-zero stats (CRITICAL for RAG efficiency)
+    # Only save records where goalie faced at least one shot
+    print("Filtering to non-zero records...")
+    nonzero_records = [record for record in goalie_records if record.shots_faced > 0]
+
+    print(f"Filtered: {len(nonzero_records)} non-zero records (from {len(goalie_records)} total)\n")
+
+    # Insert records in batches with progress tracking
+    batch_size = 1000
+    total_records = len(nonzero_records)
+
+    if total_records == 0:
+        print("No non-zero records to insert.\n")
+    else:
+        progress = create_progress_tracker(total_records, "Inserting per-game goalie stats")
+
+        records_to_insert = []
+        for i, record in enumerate(nonzero_records, 1):
+            # Calculate save percentage
+            if record.shots_faced > 0:
+                save_percentage = (record.shots_faced - record.goals_allowed) / record.shots_faced
+            else:
+                save_percentage = 0.0
+
+            game_stats_record = GameStatsGoalie(
+                game_id=record.game_id,
+                human_id=record.human_id,
+                team_id=record.team_id,
+                org_id=record.org_id,
+                level_id=record.level_id,
+                game_date=record.game_date,
+                game_time=record.game_time,
+                goals_allowed=record.goals_allowed,
+                shots_faced=record.shots_faced,
+                saves=record.saves,
+                save_percentage=save_percentage,
+                created_at=datetime.utcnow(),
+            )
+
+            records_to_insert.append(game_stats_record)
+
+            # Commit in batches
+            if i % batch_size == 0 or i == total_records:
+                session.bulk_save_objects(records_to_insert)
+                session.commit()
+                records_to_insert = []
+                progress.update(i)
+
+        print("\nInsert complete.\n")
+
+    print(f"\n{'='*80}")
+    print("Per-game goalie statistics aggregation complete")
+    print(f"{'='*80}\n")
+
+
+def run_aggregate_game_stats_goalie():
+    """Main entry point for goalie per-game aggregation."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Aggregate per-game goalie statistics")
+    parser.add_argument(
+        "--mode",
+        choices=["full", "append"],
+        default="full",
+        help="Aggregation mode: 'full' to regenerate all, 'append' to add new games only",
+    )
+    parser.add_argument(
+        "--human-id",
+        type=int,
+        default=None,
+        help="Optional: Limit processing to specific human_id (for testing)",
+    )
+
+    args = parser.parse_args()
+
+    session = create_session("boss")
+    aggregate_game_stats_goalie(session, mode=args.mode, human_id=args.human_id)
+
+
+if __name__ == "__main__":
+    run_aggregate_game_stats_goalie()

hockey_blast_common_lib/aggregate_game_stats_skater.py

@@ -0,0 +1,361 @@
+import os
+import sys
+
+# Add the package directory to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datetime import datetime, timedelta
+
+from sqlalchemy import and_, case, func
+from sqlalchemy.exc import IntegrityError
+
+from hockey_blast_common_lib.db_connection import create_session
+from hockey_blast_common_lib.models import Division, Game, GameRoster, Goal, Human, Penalty
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
+from hockey_blast_common_lib.stats_models import GameStatsSkater
+from hockey_blast_common_lib.utils import get_non_human_ids
+
+# Import status constants for game filtering
+FINAL_STATUS = "Final"
+FINAL_SO_STATUS = "Final(SO)"
+
+
+def aggregate_game_stats_skater(session, mode="full", human_id=None):
+    """Aggregate per-game skater statistics.
+
+    Args:
+        session: Database session
+        mode: "full" to regenerate all records, "append" to process new games only
+        human_id: Optional human_id to process only one player (for testing/debugging)
+
+    The function stores individual game performance for each skater with non-zero stats.
+    Only games where the player recorded at least one goal, assist, or penalty minute are saved.
+    This sparse storage is optimized for RAG system queries.
+
+    Uses Incognito Human sentinel record (game_id=-1) to track last processed timestamp
+    for append mode with 1-day overlap to catch data corrections.
+    """
+
+    # Get Incognito Human for sentinel tracking (first_name="Incognito", middle_name="", last_name="Human")
+    incognito_human = session.query(Human).filter_by(
+        first_name="Incognito", middle_name="", last_name="Human"
+    ).first()
+    if not incognito_human:
+        raise RuntimeError("Incognito Human not found in database - required for sentinel tracking")
+    incognito_human_id = incognito_human.id
+
+    non_human_ids = get_non_human_ids(session)
+
+    # Add human_id to filter if specified
+    if human_id:
+        human = session.query(Human).filter_by(id=human_id).first()
+        if not human:
+            print(f"ERROR: Human ID {human_id} not found in database")
+            return
+        print(f"Limiting to human_id={human_id}: {human.first_name} {human.last_name}\n")
+
+    print(f"\n{'='*80}")
+    print(f"Aggregating per-game skater statistics (mode: {mode})")
+    print(f"{'='*80}\n")
+
+    # Determine game filtering based on mode
+    if mode == "append":
+        # Query sentinel record for last processed timestamp
+        sentinel = (
+            session.query(GameStatsSkater)
+            .filter(
+                GameStatsSkater.human_id == incognito_human_id,
+                GameStatsSkater.game_id == -1,
+            )
+            .first()
+        )
+
+        if sentinel:
+            last_processed = datetime.combine(sentinel.game_date, sentinel.game_time)
+            # Subtract 1 day for overlap to catch data corrections
+            start_datetime = last_processed - timedelta(days=1)
+            print(f"Append mode: Processing games after {start_datetime}")
+            print(f"(1-day overlap from last processed: {last_processed})\n")
+
+            # Delete records for games in the overlap window
+            delete_count = (
+                session.query(GameStatsSkater)
+                .filter(
+                    GameStatsSkater.human_id != incognito_human_id,
+                    func.cast(
+                        func.concat(GameStatsSkater.game_date, " ", GameStatsSkater.game_time),
+                        func.TIMESTAMP,
+                    ) >= start_datetime,
+                )
+                .delete(synchronize_session=False)
+            )
+            session.commit()
+            print(f"Deleted {delete_count} existing records in overlap window\n")
+        else:
+            # No sentinel found, treat as full mode
+            print("No sentinel record found - treating as full mode\n")
+            mode = "full"
+            start_datetime = None
+    else:
+        start_datetime = None
+
+    if mode == "full":
+        # Delete all existing records except sentinel
+        delete_count = (
+            session.query(GameStatsSkater)
+            .filter(GameStatsSkater.human_id != incognito_human_id)
+            .delete(synchronize_session=False)
+        )
+        session.commit()
+        print(f"Full mode: Deleted {delete_count} existing records\n")
+
+    # Build game filter for eligible games
+    game_filter = Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS])
+    if mode == "append" and start_datetime:
+        game_filter = and_(
+            game_filter,
+            func.cast(
+                func.concat(Game.date, " ", Game.time),
+                func.TIMESTAMP,
+            ) >= start_datetime,
+        )
+
+    # Count total games to process for progress tracking
+    total_games = session.query(Game).filter(game_filter).count()
+    print(f"Processing {total_games} games...\n")
+
+    if total_games == 0:
+        print("No games to process.\n")
+        return
+
+    # Query game roster entries for skaters (exclude goalies)
+    # Join with games to get metadata, filter by game status and date window
+    roster_query = (
+        session.query(
+            GameRoster.game_id,
+            GameRoster.human_id,
+            GameRoster.team_id,
+            Game.org_id,
+            Division.level_id,
+            Game.date.label("game_date"),
+            Game.time.label("game_time"),
+        )
+        .join(Game, GameRoster.game_id == Game.id)
+        .join(Division, Game.division_id == Division.id)
+        .filter(
+            ~GameRoster.role.ilike("g"),  # Exclude goalies
+            GameRoster.human_id.notin_(non_human_ids),  # Filter placeholder humans
+            game_filter,
+        )
+    )
+
+    # Add human_id filter if specified
+    if human_id:
+        roster_query = roster_query.filter(GameRoster.human_id == human_id)
+
+    roster_entries = roster_query.all()
+
+    # Build dict of roster entries by (game_id, human_id) for fast lookup
+    roster_dict = {}
+    for entry in roster_entries:
+        key = (entry.game_id, entry.human_id)
+        roster_dict[key] = {
+            "team_id": entry.team_id,
+            "org_id": entry.org_id,
+            "level_id": entry.level_id,
+            "game_date": entry.game_date,
+            "game_time": entry.game_time,
+            "goals": 0,
+            "assists": 0,
+            "points": 0,
+            "penalty_minutes": 0,
+        }
+
+    print(f"Found {len(roster_dict)} skater roster entries\n")
+
+    # Query goals and count by scorer and assisters
+    print("Aggregating goals and assists...")
+    goals = (
+        session.query(Goal)
+        .join(Game, Goal.game_id == Game.id)
+        .filter(game_filter)
+        .all()
+    )
+
+    for goal in goals:
+        # Count goal for scorer
+        key = (goal.game_id, goal.goal_scorer_id)
+        if key in roster_dict:
+            roster_dict[key]["goals"] += 1
+            roster_dict[key]["points"] += 1
+
+        # Count assists
+        if goal.assist_1_id:
+            key = (goal.game_id, goal.assist_1_id)
+            if key in roster_dict:
+                roster_dict[key]["assists"] += 1
+                roster_dict[key]["points"] += 1
+
+        if goal.assist_2_id:
+            key = (goal.game_id, goal.assist_2_id)
+            if key in roster_dict:
+                roster_dict[key]["assists"] += 1
+                roster_dict[key]["points"] += 1
+
+    print(f"Processed {len(goals)} goals\n")
+
+    # Query penalties and aggregate by penalized player
+    print("Aggregating penalties...")
+    penalties = (
+        session.query(Penalty)
+        .join(Game, Penalty.game_id == Game.id)
+        .filter(game_filter)
+        .all()
+    )
+
+    for penalty in penalties:
+        key = (penalty.game_id, penalty.penalized_player_id)
+        if key in roster_dict:
+            # Convert penalty minutes: "GM" (game misconduct) = 10, else parse integer
+            if penalty.penalty_minutes and penalty.penalty_minutes.upper() == "GM":
+                roster_dict[key]["penalty_minutes"] += 10
+            else:
+                try:
+                    minutes = int(penalty.penalty_minutes) if penalty.penalty_minutes else 0
+                    roster_dict[key]["penalty_minutes"] += minutes
+                except (ValueError, TypeError):
+                    # Log unconvertible values but don't crash
+                    print(f"Warning: Could not convert penalty_minutes '{penalty.penalty_minutes}' for penalty {penalty.id}")
+
+    print(f"Processed {len(penalties)} penalties\n")
+
+    # Filter to only non-zero stats (CRITICAL for RAG efficiency)
+    print("Filtering to non-zero records...")
+    nonzero_dict = {
+        key: stats
+        for key, stats in roster_dict.items()
+        if stats["goals"] > 0 or stats["assists"] > 0 or stats["penalty_minutes"] > 0
+    }
+
+    print(f"Filtered: {len(nonzero_dict)} non-zero records (from {len(roster_dict)} total)\n")
+
+    # Insert records in batches with progress tracking
+    batch_size = 1000
+    total_records = len(nonzero_dict)
+
+    if total_records == 0:
+        print("No non-zero records to insert.\n")
+    else:
+        progress = create_progress_tracker(total_records, "Inserting per-game skater stats")
+
+        records_to_insert = []
+        for i, (key, stats) in enumerate(nonzero_dict.items(), 1):
+            game_id, human_id = key
+
+            record = GameStatsSkater(
+                game_id=game_id,
+                human_id=human_id,
+                team_id=stats["team_id"],
+                org_id=stats["org_id"],
+                level_id=stats["level_id"],
+                game_date=stats["game_date"],
+                game_time=stats["game_time"],
+                goals=stats["goals"],
+                assists=stats["assists"],
+                points=stats["points"],
+                penalty_minutes=stats["penalty_minutes"],
+                created_at=datetime.utcnow(),
+            )
+
+            records_to_insert.append(record)
+
+            # Commit in batches
+            if i % batch_size == 0 or i == total_records:
+                session.bulk_save_objects(records_to_insert)
+                session.commit()
+                records_to_insert = []
+                progress.update(i)
+
+        print("\nInsert complete.\n")
+
+    # Update or create sentinel record with max game timestamp (skip if filtering by human_id)
+    if not human_id:
+        max_game = (
+            session.query(
+                Game.date.label("game_date"),
+                Game.time.label("game_time"),
+            )
+            .filter(game_filter)
+            .order_by(Game.date.desc(), Game.time.desc())
+            .first()
+        )
+
+        if max_game:
+            # Try to update existing sentinel
+            sentinel = (
+                session.query(GameStatsSkater)
+                .filter(
+                    GameStatsSkater.human_id == incognito_human_id,
+                    GameStatsSkater.game_id == -1,
+                )
+                .first()
+            )
+
+            if sentinel:
+                sentinel.game_date = max_game.game_date
+                sentinel.game_time = max_game.game_time
+                print(f"Updated sentinel record: {max_game.game_date} {max_game.game_time}")
+            else:
+                # Create new sentinel
+                sentinel = GameStatsSkater(
+                    game_id=-1,
+                    human_id=incognito_human_id,
+                    team_id=-1,  # Dummy value
+                    org_id=-1,  # Dummy value
+                    level_id=-1,  # Dummy value
+                    game_date=max_game.game_date,
+                    game_time=max_game.game_time,
+                    goals=0,
+                    assists=0,
+                    points=0,
+                    penalty_minutes=0,
+                    created_at=datetime.utcnow(),
+                )
+                session.add(sentinel)
+                print(f"Created sentinel record: {max_game.game_date} {max_game.game_time}")
+
+            session.commit()
+    else:
+        print("Skipping sentinel record creation (human_id filter active)")
+
+    print(f"\n{'='*80}")
+    print("Per-game skater statistics aggregation complete")
+    print(f"{'='*80}\n")
+
+
+def run_aggregate_game_stats_skater():
+    """Main entry point for skater per-game aggregation."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Aggregate per-game skater statistics")
+    parser.add_argument(
+        "--mode",
+        choices=["full", "append"],
+        default="full",
+        help="Aggregation mode: 'full' to regenerate all, 'append' to add new games only",
+    )
+    parser.add_argument(
+        "--human-id",
+        type=int,
+        default=None,
+        help="Optional: Limit processing to specific human_id (for testing)",
+    )
+
+    args = parser.parse_args()
+
+    session = create_session("boss")
+    aggregate_game_stats_skater(session, mode=args.mode, human_id=args.human_id)
+
+
+if __name__ == "__main__":
+    run_aggregate_game_stats_skater()

hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -117,6 +117,9 @@ def aggregate_goalie_stats(
     debug_human_id=None,
     aggregation_window=None,
 ):
+    # Capture start time for aggregation tracking
+    aggregation_start_time = datetime.utcnow()
+
     human_ids_to_filter = get_non_human_ids(session)
 
     # Get the name of the aggregation, for debug purposes
@@ -364,6 +367,7 @@ def aggregate_goalie_stats(
             total_in_rank=total_in_rank,
             first_game_id=stat["first_game_id"],
             last_game_id=stat["last_game_id"],
+            aggregation_started_at=aggregation_start_time,
         )
         session.add(goalie_stat)
         # Commit in batches
@@ -371,6 +375,13 @@ def aggregate_goalie_stats(
             session.commit()
     session.commit()
 
+    # Update all records with completion timestamp
+    aggregation_end_time = datetime.utcnow()
+    session.query(StatsModel).filter(
+        StatsModel.aggregation_id == aggregation_id
+    ).update({StatsModel.aggregation_completed_at: aggregation_end_time})
+    session.commit()
+
 
 def run_aggregate_goalie_stats():
     session = create_session("boss")

hockey_blast_common_lib/aggregate_human_stats.py

@@ -44,6 +44,9 @@ def aggregate_human_stats(
     human_id_filter=None,
     aggregation_window=None,
 ):
+    # Capture start time for aggregation tracking
+    aggregation_start_time = datetime.utcnow()
+
     human_ids_to_filter = get_non_human_ids(session)
 
     if aggregation_type == "org":
@@ -517,6 +520,7 @@ def aggregate_human_stats(
             last_game_id_referee=stat["last_game_id_referee"],
             first_game_id_scorekeeper=stat["first_game_id_scorekeeper"],
             last_game_id_scorekeeper=stat["last_game_id_scorekeeper"],
+            aggregation_started_at=aggregation_start_time,
         )
         session.add(human_stat)
         # Commit in batches
@@ -607,10 +611,18 @@ def aggregate_human_stats(
         last_game_id_referee=overall_stats["last_game_id_referee"],
         first_game_id_scorekeeper=overall_stats["first_game_id_scorekeeper"],
         last_game_id_scorekeeper=overall_stats["last_game_id_scorekeeper"],
+        aggregation_started_at=aggregation_start_time,
     )
     session.add(overall_human_stat)
     session.commit()
 
+    # Update all records with completion timestamp
+    aggregation_end_time = datetime.utcnow()
+    session.query(StatsModel).filter(
+        StatsModel.aggregation_id == aggregation_id
+    ).update({StatsModel.aggregation_completed_at: aggregation_end_time})
+    session.commit()
+
 
 def run_aggregate_human_stats():
     session = create_session("boss")

hockey_blast_common_lib/aggregate_referee_stats.py

@@ -5,6 +5,7 @@ import sys
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
+from datetime import datetime
 
 import sqlalchemy
 from sqlalchemy.sql import case, func
@@ -102,6 +103,9 @@ def insert_percentile_markers_referee(
 def aggregate_referee_stats(
     session, aggregation_type, aggregation_id, aggregation_window=None
 ):
+    # Capture start time for aggregation tracking
+    aggregation_start_time = datetime.utcnow()
+
     human_ids_to_filter = get_non_human_ids(session)
 
     if aggregation_type == "org":
@@ -375,6 +379,7 @@ def aggregate_referee_stats(
             total_in_rank=total_in_rank,
             first_game_id=stat["first_game_id"],
             last_game_id=stat["last_game_id"],
+            aggregation_started_at=aggregation_start_time,
         )
         session.add(referee_stat)
         # Commit in batches
@@ -382,6 +387,13 @@ def aggregate_referee_stats(
             session.commit()
     session.commit()
 
+    # Update all records with completion timestamp
+    aggregation_end_time = datetime.utcnow()
+    session.query(StatsModel).filter(
+        StatsModel.aggregation_id == aggregation_id
+    ).update({StatsModel.aggregation_completed_at: aggregation_end_time})
+    session.commit()
+
 
 def run_aggregate_referee_stats():
     session = create_session("boss")

hockey_blast_common_lib/aggregate_scorekeeper_stats.py

@@ -5,6 +5,8 @@ import sys
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
+from datetime import datetime
+
 import sqlalchemy
 from sqlalchemy.sql import func
 
@@ -151,6 +153,9 @@ def aggregate_scorekeeper_stats(
     if aggregation_type == "org" and aggregation_id != ALL_ORGS_ID:
         return  # Do nothing for individual organization IDs
 
+    # Capture start time for aggregation tracking
+    aggregation_start_time = datetime.utcnow()
+
     human_ids_to_filter = get_non_human_ids(session)
 
     if aggregation_type == "org":
@@ -370,6 +375,7 @@ def aggregate_scorekeeper_stats(
             total_in_rank=total_in_rank,
             first_game_id=stat["first_game_id"],
             last_game_id=stat["last_game_id"],
+            aggregation_started_at=aggregation_start_time,
         )
         session.add(scorekeeper_stat)
         # Commit in batches
@@ -377,6 +383,13 @@ def aggregate_scorekeeper_stats(
             session.commit()
     session.commit()
 
+    # Update all records with completion timestamp
+    aggregation_end_time = datetime.utcnow()
+    session.query(StatsModel).filter(
+        StatsModel.aggregation_id == aggregation_id
+    ).update({StatsModel.aggregation_completed_at: aggregation_end_time})
+    session.commit()
+
 
 def run_aggregate_scorekeeper_stats():
     session = create_session("boss")

hockey_blast_common_lib/aggregate_skater_stats.py

@@ -6,6 +6,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
 
 import sqlalchemy
+from datetime import datetime
 from sqlalchemy import and_, case, func
 from sqlalchemy.sql import case, func
 
@@ -223,6 +224,9 @@ def aggregate_skater_stats(
     debug_human_id=None,
     aggregation_window=None,
 ):
+    # Capture start time for aggregation tracking
+    aggregation_start_time = datetime.utcnow()
+
     human_ids_to_filter = get_non_human_ids(session)
 
     # Get the name of the aggregation, for debug purposes
@@ -754,6 +758,7 @@ def aggregate_skater_stats(
             ),
             first_game_id=stat["first_game_id"],
             last_game_id=stat["last_game_id"],
+            aggregation_started_at=aggregation_start_time,
         )
         session.add(skater_stat)
         # Commit in batches
@@ -761,6 +766,13 @@ def aggregate_skater_stats(
             session.commit()
     session.commit()
 
+    # Update all records with completion timestamp
+    aggregation_end_time = datetime.utcnow()
+    session.query(StatsModel).filter(
+        StatsModel.aggregation_id == aggregation_id
+    ).update({StatsModel.aggregation_completed_at: aggregation_end_time})
+    session.commit()
+
 
 def run_aggregate_skater_stats():
     session = create_session("boss")

hockey_blast_common_lib/aggregate_team_goalie_stats.py

@@ -15,6 +15,8 @@ import sys
 
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
+from datetime import datetime
+
 import sqlalchemy
 from sqlalchemy import func
 
@@ -62,6 +64,9 @@ def aggregate_team_goalie_stats(session, aggregation_type, aggregation_id):
         aggregation_type: "org" or "division"
         aggregation_id: ID of the organization or division
     """
+    # Capture start time for aggregation tracking
+    aggregation_start_time = datetime.utcnow()
+
     human_ids_to_filter = get_non_human_ids(session)
 
     # Determine aggregation details
@@ -221,10 +226,19 @@ def aggregate_team_goalie_stats(session, aggregation_type, aggregation_id):
                 shots_faced_rank=0,
                 goals_allowed_per_game_rank=0,
                 save_percentage_rank=0,
+                aggregation_started_at=aggregation_start_time,
             )
             session.add(goalie_stat)
 
     session.commit()
+
+    # Update all records with completion timestamp
+    aggregation_end_time = datetime.utcnow()
+    session.query(StatsModel).filter(
+        StatsModel.aggregation_id == aggregation_id
+    ).update({StatsModel.aggregation_completed_at: aggregation_end_time})
+    session.commit()
+
     progress.finish()
     print(f"✓ Team goalie stats aggregation complete for {aggregation_name}")
 

hockey_blast_common_lib/aggregate_team_skater_stats.py

@@ -15,6 +15,8 @@ import sys
 
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
+from datetime import datetime
+
 import sqlalchemy
 from sqlalchemy import and_, case, func
 
@@ -63,6 +65,9 @@ def aggregate_team_skater_stats(session, aggregation_type, aggregation_id):
         aggregation_type: "org" or "division"
         aggregation_id: ID of the organization or division
     """
+    # Capture start time for aggregation tracking
+    aggregation_start_time = datetime.utcnow()
+
     human_ids_to_filter = get_non_human_ids(session)
 
     # Determine aggregation details
@@ -269,10 +274,19 @@ def aggregate_team_skater_stats(session, aggregation_type, aggregation_id):
                 gm_penalties_per_game_rank=0,
                 current_point_streak_rank=0,
                 current_point_streak_avg_points_rank=0,
+                aggregation_started_at=aggregation_start_time,
             )
             session.add(skater_stat)
 
     session.commit()
+
+    # Update all records with completion timestamp
+    aggregation_end_time = datetime.utcnow()
+    session.query(StatsModel).filter(
+        StatsModel.aggregation_id == aggregation_id
+    ).update({StatsModel.aggregation_completed_at: aggregation_end_time})
+    session.commit()
+
     progress.finish()
     print(f"✓ Team skater stats aggregation complete for {aggregation_name}")
 

hockey_blast_common_lib/models.py

@@ -53,7 +53,8 @@ class Game(db.Model):
     time = db.Column(db.Time)
     day_of_week = db.Column(db.Integer)  # 1 to 7 for Monday to Sunday
     period_length = db.Column(db.Integer)  # In minutes
-    location = db.Column(db.String(100))
+    location = db.Column(db.String(100))  # DEPRECATED: Use location_id instead
+    location_id = db.Column(db.Integer, db.ForeignKey("locations.id"), nullable=True)
     scorekeeper_id = db.Column(db.Integer, db.ForeignKey("humans.id"))
     referee_1_id = db.Column(db.Integer, db.ForeignKey("humans.id"))
     referee_2_id = db.Column(db.Integer, db.ForeignKey("humans.id"))
@@ -72,6 +73,7 @@ class Game(db.Model):
     home_ot_score = db.Column(db.Integer, default=0)
     visitor_ot_score = db.Column(db.Integer, default=0)
     game_type = db.Column(db.String(50))
+    live_time = db.Column(db.String(50), nullable=True)  # e.g., "Period 1, 1:10 left" for live games
     went_to_ot = db.Column(db.Boolean, default=False)
     home_period_1_shots = db.Column(db.Integer)
     home_period_2_shots = db.Column(db.Integer)
@@ -245,6 +247,7 @@ class Level(db.Model):
     org_id = db.Column(db.Integer, db.ForeignKey("organizations.id"), nullable=False)
     skill_value = db.Column(db.Float)  # A number from 0 (NHL) to 100 (pedestrian)
     level_name = db.Column(db.String(100))
+    short_name = db.Column(db.String(50))  # Shortened display name (e.g., "D-7B-W" for "Adult Division 7B West")
     level_alternative_name = db.Column(db.String(100))
     is_seed = db.Column(db.Boolean, nullable=True, default=False)  # New field
     skill_propagation_sequence = db.Column(db.Integer, nullable=True, default=-1)
@@ -253,6 +256,17 @@ class Level(db.Model):
     )
 
 
+class Location(db.Model):
+    __tablename__ = "locations"
+    id = db.Column(db.Integer, primary_key=True)
+    location_in_game_source = db.Column(db.String(200), nullable=False, unique=True)  # Raw string from Game.location, e.g., "San Jose Orange (N)"
+    location_name = db.Column(db.String(200), nullable=True)  # Optional: Facility name, e.g., "Sharks Ice At San Jose"
+    rink_name = db.Column(db.String(200), nullable=True)  # Optional: Specific rink, e.g., "Orange (N)"
+    address = db.Column(db.String(500), nullable=True)
+    google_maps_link = db.Column(db.String(500), nullable=True)
+    master_location_id = db.Column(db.Integer, db.ForeignKey("locations.id"), nullable=True)  # Points to the canonical location for this rink
+
+
 class LevelsMonthly(db.Model):
     __tablename__ = "levels_monthly"
     id = db.Column(db.Integer, primary_key=True)
@@ -427,6 +441,7 @@ class Season(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     season_number = db.Column(db.Integer)
     season_name = db.Column(db.String(100))
+    base_season_name = db.Column(db.String(100))  # Static prefix for season name (e.g., "Silver Stick", "Over", etc.)
     start_date = db.Column(db.Date)
     end_date = db.Column(db.Date)
     league_number = db.Column(

hockey_blast_common_lib/stats_models.py

@@ -4,7 +4,13 @@ from sqlalchemy.orm import synonym
 from hockey_blast_common_lib.models import db
 
 
-class BaseStatsHuman(db.Model):
+class AggregationTimestampMixin:
+    """Mixin to add aggregation timestamp tracking to all stats models."""
+    aggregation_started_at = db.Column(db.DateTime, nullable=True)
+    aggregation_completed_at = db.Column(db.DateTime, nullable=True)
+
+
+class BaseStatsHuman(AggregationTimestampMixin, db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey("humans.id"), nullable=False)
@@ -92,7 +98,7 @@ class BaseStatsHuman(db.Model):
         )
 
 
-class BaseStatsSkater(db.Model):
+class BaseStatsSkater(AggregationTimestampMixin, db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey("humans.id"), nullable=False)
@@ -193,7 +199,7 @@ class BaseStatsSkater(db.Model):
         )
 
 
-class BaseStatsGoalie(db.Model):
+class BaseStatsGoalie(AggregationTimestampMixin, db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey("humans.id"), nullable=False)
@@ -261,7 +267,7 @@ class BaseStatsGoalie(db.Model):
         )
 
 
-class BaseStatsReferee(db.Model):
+class BaseStatsReferee(AggregationTimestampMixin, db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey("humans.id"), nullable=False)
@@ -331,7 +337,7 @@ class BaseStatsReferee(db.Model):
         )
 
 
-class BaseStatsScorekeeper(db.Model):
+class BaseStatsScorekeeper(AggregationTimestampMixin, db.Model):
     __abstract__ = True
     id = db.Column(db.Integer, primary_key=True)
     human_id = db.Column(db.Integer, db.ForeignKey("humans.id"), nullable=False)
@@ -1045,3 +1051,80 @@ class DivisionStatsGoalieTeam(BaseStatsGoalie):
             db.Index("idx_division_team_goalie_save_pct", "division_id", "save_percentage"),
             db.Index("idx_division_team_goalie_gaa", "division_id", "goals_allowed_per_game"),
         )
+
+
+# Per-Game Statistics Models (for RAG system)
+# These models store individual game performance data for each player/goalie
+# CRITICAL: Only non-zero rows are saved (games where player recorded stats)
+
+
+class GameStatsSkater(db.Model):
+    """Per-game skater statistics.
+
+    Stores individual game performance for skaters.
+    Only records where player had non-zero stats are saved.
+    Optimized for queries like "show me top N games by points for player X".
+    """
+    __tablename__ = "game_stats_skater"
+
+    id = db.Column(db.Integer, primary_key=True)
+    game_id = db.Column(db.Integer, db.ForeignKey("games.id"), nullable=False, index=True)
+    human_id = db.Column(db.Integer, db.ForeignKey("humans.id"), nullable=False, index=True)
+    team_id = db.Column(db.Integer, db.ForeignKey("teams.id"), nullable=False, index=True)
+    org_id = db.Column(db.Integer, db.ForeignKey("organizations.id"), nullable=False, index=True)
+    level_id = db.Column(db.Integer, db.ForeignKey("levels.id"), nullable=False, index=True)
+
+    # Denormalized game metadata for sorting/filtering
+    game_date = db.Column(db.Date, nullable=False, index=True)
+    game_time = db.Column(db.Time, nullable=False)
+
+    # Performance stats
+    goals = db.Column(db.Integer, default=0, nullable=False)
+    assists = db.Column(db.Integer, default=0, nullable=False)
+    points = db.Column(db.Integer, default=0, nullable=False)
+    penalty_minutes = db.Column(db.Integer, default=0, nullable=False)
+
+    # Tracking
+    created_at = db.Column(db.DateTime, nullable=False, default=db.func.current_timestamp())
+
+    __table_args__ = (
+        db.UniqueConstraint("game_id", "human_id", name="_game_human_uc_skater"),
+        db.Index("idx_game_stats_skater_human_date", "human_id", "game_date", postgresql_using="btree"),
+        db.Index("idx_game_stats_skater_human_team_date", "human_id", "team_id", "game_date", postgresql_using="btree"),
+    )
+
+
+class GameStatsGoalie(db.Model):
+    """Per-game goalie statistics.
+
+    Stores individual game performance for goalies.
+    Only records where goalie faced shots are saved.
+    Optimized for queries like "show me top N games by save% for goalie X".
+    """
+    __tablename__ = "game_stats_goalie"
+
+    id = db.Column(db.Integer, primary_key=True)
+    game_id = db.Column(db.Integer, db.ForeignKey("games.id"), nullable=False, index=True)
+    human_id = db.Column(db.Integer, db.ForeignKey("humans.id"), nullable=False, index=True)
+    team_id = db.Column(db.Integer, db.ForeignKey("teams.id"), nullable=False, index=True)
+    org_id = db.Column(db.Integer, db.ForeignKey("organizations.id"), nullable=False, index=True)
+    level_id = db.Column(db.Integer, db.ForeignKey("levels.id"), nullable=False, index=True)
+
+    # Denormalized game metadata for sorting/filtering
+    game_date = db.Column(db.Date, nullable=False, index=True)
+    game_time = db.Column(db.Time, nullable=False)
+
+    # Performance stats
+    goals_allowed = db.Column(db.Integer, default=0, nullable=False)
+    shots_faced = db.Column(db.Integer, default=0, nullable=False)
+    saves = db.Column(db.Integer, default=0, nullable=False)  # Computed: shots_faced - goals_allowed
+    save_percentage = db.Column(db.Float, default=0.0, nullable=False)  # Computed: saves / shots_faced
+
+    # Tracking
+    created_at = db.Column(db.DateTime, nullable=False, default=db.func.current_timestamp())
+
+    __table_args__ = (
+        db.UniqueConstraint("game_id", "human_id", "team_id", name="_game_human_uc_goalie"),
+        db.Index("idx_game_stats_goalie_human_date", "human_id", "game_date", postgresql_using="btree"),
+        db.Index("idx_game_stats_goalie_human_team_date", "human_id", "team_id", "game_date", postgresql_using="btree"),
+    )

hockey_blast_common_lib/utils.py

@@ -269,7 +269,8 @@ def calculate_percentile_value(values, percentile):
     lower_value = sorted_values[lower_index]
     upper_value = sorted_values[upper_index]
 
-    return lower_value + fraction * (upper_value - lower_value)
+    # Convert Decimal to float to avoid type errors with database Decimal fields
+    return float(lower_value) + fraction * (float(upper_value) - float(lower_value))
 
 
 # TEST DB CONNECTION, PERMISSIONS...

{hockey_blast_common_lib-0.1.66.dist-info → hockey_blast_common_lib-0.1.67.dist-info}/METADATA

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

{hockey_blast_common_lib-0.1.66.dist-info → hockey_blast_common_lib-0.1.67.dist-info}/RECORD

@@ -1,31 +1,34 @@
 hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hockey_blast_common_lib/aggregate_all_stats.py,sha256=lWDhdYMYFEdNFTM3FmAKWiHFYSkb0OLjTkagguHlwls,1914
-hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=Z_xRHR-C6_2KO67LmIW8uKVD4tpEXXvFhfo0DHouuHo,19871
+hockey_blast_common_lib/aggregate_game_stats_all.py,sha256=r0s2ki8y60pHL3wI8yDhRkAfNRRRgnOfzbJUwO6T4QY,4738
+hockey_blast_common_lib/aggregate_game_stats_goalie.py,sha256=XMGhkCfj9EQ2kK1V8z0xLrCDi9t1Sqq0OxusG1uSXNk,9505
+hockey_blast_common_lib/aggregate_game_stats_skater.py,sha256=00x8TUzPxClmfGZ7M6dPKUNJdYaCF1qIA6KmO7izI0Q,13013
+hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=hYhoCGf3p0lsLMYT11e-jqFLi3Yv2O3JmljdWRqww4I,20310
 hockey_blast_common_lib/aggregate_h2h_stats.py,sha256=nStyIm_be25pKDYbPCaOSHFTjbaMLFxFAa2mTU1tL_k,11486
-hockey_blast_common_lib/aggregate_human_stats.py,sha256=uoGBkROBKh8n18TyzZ6vHX_viCTpHbRsiVLyflJq92g,29247
-hockey_blast_common_lib/aggregate_referee_stats.py,sha256=VZVqiTfcHKtpyqUjvFBlypz2P8bIVg9wp0OK-MOu7O8,19580
+hockey_blast_common_lib/aggregate_human_stats.py,sha256=2NrdgKHQnaYHaM9tNjq8512Ea9RuySTRdzpRlHpkt7k,29741
+hockey_blast_common_lib/aggregate_referee_stats.py,sha256=UUbd_YqdOFGFCRMcobU5ROfojKXKtcpEYJ8pL8Wqka8,20049
 hockey_blast_common_lib/aggregate_s2s_stats.py,sha256=gB3Oi1emtBWL3bKojUhHH01gAbQTSLvgqO1WcvLI6F8,7449
-hockey_blast_common_lib/aggregate_scorekeeper_stats.py,sha256=NVCL5QzeIodTKs_OvDlcKDtGKnyxA_ZMlKTGfeO4H6Y,17829
-hockey_blast_common_lib/aggregate_skater_stats.py,sha256=pU9ULO90165QqWWMz5leSHD9iJb5rJegBzGjZpiKYGw,34870
-hockey_blast_common_lib/aggregate_team_goalie_stats.py,sha256=Yy06zDrgLDsI2QqjFzPck3mYWNhyTxSVpZHSdpDSkRE,9569
-hockey_blast_common_lib/aggregate_team_skater_stats.py,sha256=cGP8eLTDD0lEkkTmUlBvSwqYfAGIfEOQREy_xtHxHKI,11962
+hockey_blast_common_lib/aggregate_scorekeeper_stats.py,sha256=Bk6XOlv61kd1PwmWws8JEdsJt1nXnGEuDM1ecPaHEZM,18299
+hockey_blast_common_lib/aggregate_skater_stats.py,sha256=ognlux7PFqRZS0YxW89aQGZkfdoG1Z0pjT8A9lrfATs,35339
+hockey_blast_common_lib/aggregate_team_goalie_stats.py,sha256=ApgaR2beGmrV7docvDjXIGEACTt8f5T5pcmKisqLHpI,10044
+hockey_blast_common_lib/aggregate_team_skater_stats.py,sha256=f93Dq884U47nlatWkyl4Tgtl-SvaBMg3pmR-rOJdWXU,12437
 hockey_blast_common_lib/assign_skater_skill.py,sha256=it3jiSyUq7XpKqxzs88lyB5t1c3t1idIS_JRwq_FQoo,2810
 hockey_blast_common_lib/db_connection.py,sha256=KACyHaOMeTX9zPNztYy8uOeB1ubIUenZcEKAeD5gC24,3333
 hockey_blast_common_lib/dump_sample_db.sh,sha256=MY3lnzTXBoWd76-ZlZr9nWsKMEVgyRsUn-LZ2d1JWZs,810
 hockey_blast_common_lib/embedding_utils.py,sha256=XbJvJlq6BKE6_oLzhUKcCrx6-TM8P-xl-S1SVLr_teU,10222
 hockey_blast_common_lib/h2h_models.py,sha256=DEmQnmuacBVRNWvpRvq2RlwmhQYrT7XPOSTDNVtchr0,8597
-hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=sh_-vvwEIiKDCtmIIzyiyaNs67gUHCTu6CGCCdBcT6Q,4648833
-hockey_blast_common_lib/models.py,sha256=RQGUq8C8eJqUB2o3QCSs14W-9B4lMTUNvwNDM-Lc6j4,21687
+hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=dIAe4lsuCBQqE1WEkRyycEPYkAUlsA1scIU50SRalsI,4648840
+hockey_blast_common_lib/models.py,sha256=HdSrKvNVvKNr2klvAinpj5aXiFxv9Vb0IrYkrIURj0o,22889
 hockey_blast_common_lib/options.py,sha256=wzfGWKK_dHBA_PfiOvbP_-HtdoJCR0E7DkA5_cYDb_k,1578
 hockey_blast_common_lib/progress_utils.py,sha256=7Txjpx5G4vHbnPTvNYuBA_WtrY0QFA4mDEYUDuZyY1E,3923
 hockey_blast_common_lib/restore_sample_db.sh,sha256=7W3lzRZeu9zXIu1Bvtnaw8EHc1ulHmFM4mMh86oUQJo,2205
 hockey_blast_common_lib/skills_in_divisions.py,sha256=9sGtU6SLj8BXb5R74ue1oPWa2nbk4JfJz5VmcuxetzA,8542
 hockey_blast_common_lib/skills_propagation.py,sha256=qBK84nzkn8ZQHum0bdxFQwLvdgVE7DtWoPP9cdbOmRo,20201
-hockey_blast_common_lib/stats_models.py,sha256=EU7Uw9ANPNNEx4vORgJkMFdgyTXQGmGLOF7YiY8jeBY,35488
+hockey_blast_common_lib/stats_models.py,sha256=r-7cqStcIAO72gotRp1o8-HB4tXvJPsc4d3702gIQYM,39605
 hockey_blast_common_lib/stats_utils.py,sha256=PTZvykl1zfEcojnzDFa1J3V3F5gREmoFG1lQHLnYHgo,300
-hockey_blast_common_lib/utils.py,sha256=xHgA3Xh40i4CBVArvfW2j123XGdgrMTFqTudPQHwkho,8997
+hockey_blast_common_lib/utils.py,sha256=911NlMLzwMX5uwmytcpxNPRP-Y8OjDxTGKKIcyED5ls,9099
 hockey_blast_common_lib/wsgi.py,sha256=oL9lPWccKLTAYIKPJkKZV5keVE-Dgosv74CBi770NNc,786
-hockey_blast_common_lib-0.1.66.dist-info/METADATA,sha256=ANT3HdUqzzFk-q_2ujzu9oPPmohLJFXXZdYAqj-P0Yg,318
-hockey_blast_common_lib-0.1.66.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.66.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.66.dist-info/RECORD,,
+hockey_blast_common_lib-0.1.67.dist-info/METADATA,sha256=U8V1E5eCzhwWfqAX7sAPimvb6WpAsnO44AgNNb3q9tI,318
+hockey_blast_common_lib-0.1.67.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.67.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.67.dist-info/RECORD,,