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

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
 
@@ -22,7 +24,9 @@ from hockey_blast_common_lib.stats_models import (
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
 from hockey_blast_common_lib.utils import (
     assign_ranks,
+    calculate_percentile_value,
     get_non_human_ids,
+    get_percentile_human,
     get_start_datetime,
 )
 
@@ -33,6 +37,77 @@ FORFEIT_STATUS = "FORFEIT"
 NOEVENTS_STATUS = "NOEVENTS"
 
 
+def insert_percentile_markers_scorekeeper(
+    session, stats_dict, aggregation_id, total_in_rank, StatsModel
+):
+    """Insert percentile marker records for scorekeeper stats."""
+    if not stats_dict:
+        return
+
+    stat_fields = [
+        "games_recorded",
+        "games_participated",
+        "games_with_stats",
+        "sog_given",
+        "sog_per_game",
+        "total_saves_recorded",
+        "avg_saves_per_game",
+        "avg_max_saves_per_5sec",
+        "avg_max_saves_per_20sec",
+        "peak_max_saves_per_5sec",
+        "peak_max_saves_per_20sec",
+        "quality_score",
+    ]
+
+    percentiles = [25, 50, 75, 90, 95]
+
+    for percentile in percentiles:
+        percentile_human_id = get_percentile_human(session, "Scorekeeper", percentile)
+
+        percentile_values = {}
+        for field in stat_fields:
+            values = [stat[field] for stat in stats_dict.values() if field in stat]
+            if values:
+                percentile_values[field] = calculate_percentile_value(values, percentile)
+            else:
+                percentile_values[field] = 0
+
+        scorekeeper_stat = StatsModel(
+            aggregation_id=aggregation_id,
+            human_id=percentile_human_id,
+            games_recorded=int(percentile_values.get("games_recorded", 0)),
+            games_participated=int(percentile_values.get("games_participated", 0)),
+            games_participated_rank=0,
+            games_with_stats=int(percentile_values.get("games_with_stats", 0)),
+            games_with_stats_rank=0,
+            sog_given=int(percentile_values.get("sog_given", 0)),
+            sog_per_game=percentile_values.get("sog_per_game", 0.0),
+            total_saves_recorded=int(percentile_values.get("total_saves_recorded", 0)),
+            avg_saves_per_game=percentile_values.get("avg_saves_per_game", 0.0),
+            avg_max_saves_per_5sec=percentile_values.get("avg_max_saves_per_5sec", 0.0),
+            avg_max_saves_per_20sec=percentile_values.get("avg_max_saves_per_20sec", 0.0),
+            peak_max_saves_per_5sec=int(percentile_values.get("peak_max_saves_per_5sec", 0)),
+            peak_max_saves_per_20sec=int(percentile_values.get("peak_max_saves_per_20sec", 0)),
+            quality_score=percentile_values.get("quality_score", 0.0),
+            games_recorded_rank=0,
+            sog_given_rank=0,
+            sog_per_game_rank=0,
+            total_saves_recorded_rank=0,
+            avg_saves_per_game_rank=0,
+            avg_max_saves_per_5sec_rank=0,
+            avg_max_saves_per_20sec_rank=0,
+            peak_max_saves_per_5sec_rank=0,
+            peak_max_saves_per_20sec_rank=0,
+            quality_score_rank=0,
+            total_in_rank=total_in_rank,
+            first_game_id=None,
+            last_game_id=None,
+        )
+        session.add(scorekeeper_stat)
+
+    session.commit()
+
+
 def calculate_quality_score(
     avg_max_saves_5sec, avg_max_saves_20sec, peak_max_saves_5sec, peak_max_saves_20sec
 ):
@@ -78,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":
@@ -252,6 +330,11 @@ def aggregate_scorekeeper_stats(
         stats_dict, "quality_score", reverse_rank=True
     )  # Lower is better (less problematic)
 
+    # Calculate and insert percentile marker records
+    insert_percentile_markers_scorekeeper(
+        session, stats_dict, aggregation_id, total_in_rank, StatsModel
+    )
+
     # Insert aggregated stats into the appropriate table with progress output
     batch_size = 1000
     for i, (key, stat) in enumerate(stats_dict.items(), 1):
@@ -292,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
@@ -299,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
 
@@ -37,8 +38,10 @@ from hockey_blast_common_lib.stats_models import (
 )
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
 from hockey_blast_common_lib.utils import (
+    calculate_percentile_value,
     get_all_division_ids_for_org,
     get_non_human_ids,
+    get_percentile_human,
     get_start_datetime,
 )
 
@@ -115,6 +118,105 @@ def calculate_current_point_streak(session, human_id, filter_condition):
     return current_streak, avg_points_during_streak
 
 
+def insert_percentile_markers_skater(
+    session, stats_dict, aggregation_id, total_in_rank, StatsModel, aggregation_window
+):
+    """Insert percentile marker records for skater stats.
+
+    For each stat field, calculate the 25th, 50th, 75th, 90th, and 95th percentile values
+    and insert marker records with fake human IDs.
+    """
+    if not stats_dict:
+        return
+
+    # Define the stat fields we want to calculate percentiles for
+    # Each field has percentile calculated SEPARATELY
+    stat_fields = [
+        "games_played",
+        "games_participated",
+        "games_with_stats",
+        "goals",
+        "assists",
+        "points",
+        "penalties",
+        "gm_penalties",
+        "goals_per_game",
+        "assists_per_game",
+        "points_per_game",
+        "penalties_per_game",
+        "gm_penalties_per_game",
+    ]
+
+    # Add streak fields only for all-time stats
+    if aggregation_window is None:
+        stat_fields.extend(
+            ["current_point_streak", "current_point_streak_avg_points"]
+        )
+
+    # For each percentile (25, 50, 75, 90, 95)
+    percentiles = [25, 50, 75, 90, 95]
+
+    for percentile in percentiles:
+        # Get or create the percentile marker human
+        percentile_human_id = get_percentile_human(session, "Skater", percentile)
+
+        # Calculate percentile values for each stat field SEPARATELY
+        percentile_values = {}
+        for field in stat_fields:
+            # Extract all values for this field
+            values = [stat[field] for stat in stats_dict.values() if field in stat]
+            if values:
+                percentile_values[field] = calculate_percentile_value(values, percentile)
+            else:
+                percentile_values[field] = 0
+
+        # Create the stats record for this percentile marker
+        skater_stat = StatsModel(
+            aggregation_id=aggregation_id,
+            human_id=percentile_human_id,
+            games_played=int(percentile_values.get("games_played", 0)),
+            games_participated=int(percentile_values.get("games_participated", 0)),
+            games_participated_rank=0,  # Percentile markers don't have ranks
+            games_with_stats=int(percentile_values.get("games_with_stats", 0)),
+            games_with_stats_rank=0,
+            goals=int(percentile_values.get("goals", 0)),
+            assists=int(percentile_values.get("assists", 0)),
+            points=int(percentile_values.get("points", 0)),
+            penalties=int(percentile_values.get("penalties", 0)),
+            gm_penalties=int(percentile_values.get("gm_penalties", 0)),
+            goals_per_game=percentile_values.get("goals_per_game", 0.0),
+            points_per_game=percentile_values.get("points_per_game", 0.0),
+            assists_per_game=percentile_values.get("assists_per_game", 0.0),
+            penalties_per_game=percentile_values.get("penalties_per_game", 0.0),
+            gm_penalties_per_game=percentile_values.get("gm_penalties_per_game", 0.0),
+            games_played_rank=0,
+            goals_rank=0,
+            assists_rank=0,
+            points_rank=0,
+            penalties_rank=0,
+            gm_penalties_rank=0,
+            goals_per_game_rank=0,
+            points_per_game_rank=0,
+            assists_per_game_rank=0,
+            penalties_per_game_rank=0,
+            gm_penalties_per_game_rank=0,
+            total_in_rank=total_in_rank,
+            current_point_streak=int(
+                percentile_values.get("current_point_streak", 0)
+            ),
+            current_point_streak_rank=0,
+            current_point_streak_avg_points=percentile_values.get(
+                "current_point_streak_avg_points", 0.0
+            ),
+            current_point_streak_avg_points_rank=0,
+            first_game_id=None,  # Percentile markers don't have game references
+            last_game_id=None,
+        )
+        session.add(skater_stat)
+
+    session.commit()
+
+
 def aggregate_skater_stats(
     session,
     aggregation_type,
@@ -122,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
@@ -561,6 +666,11 @@ def aggregate_skater_stats(
         assign_ranks(stats_dict, "current_point_streak")
         assign_ranks(stats_dict, "current_point_streak_avg_points")
 
+    # Calculate and insert percentile marker records
+    insert_percentile_markers_skater(
+        session, stats_dict, aggregation_id, total_in_rank, StatsModel, aggregation_window
+    )
+
     # Debug output for specific human
     if debug_human_id:
         if any(key[1] == debug_human_id for key in stats_dict):
@@ -648,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
@@ -655,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

@@ -0,0 +1,265 @@
+"""
+Aggregate goalie statistics by team.
+
+This module aggregates goalie statistics for each team, counting only games
+where the goalie was on that specific team (using GameRoster.team_id).
+
+Key difference from regular aggregation:
+- Aggregates by (aggregation_id, team_id, human_id) instead of just (aggregation_id, human_id)
+- Filters to only games where GameRoster.team_id matches the target team
+- Stores results in OrgStatsGoalieTeam / DivisionStatsGoalieTeam
+
+"""
+import os
+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
+
+from hockey_blast_common_lib.db_connection import create_session
+from hockey_blast_common_lib.models import (
+    Division,
+    Game,
+    GameRoster,
+    GoalieSaves,
+    Human,
+    Organization,
+    Team,
+)
+from hockey_blast_common_lib.options import (
+    MIN_GAMES_FOR_DIVISION_STATS,
+    MIN_GAMES_FOR_ORG_STATS,
+)
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
+from hockey_blast_common_lib.stats_models import (
+    DivisionStatsGoalieTeam,
+    OrgStatsGoalieTeam,
+)
+from hockey_blast_common_lib.utils import (
+    calculate_percentile_value,
+    get_non_human_ids,
+    get_percentile_human,
+)
+
+# Import status constants for game filtering
+FINAL_STATUS = "Final"
+FINAL_SO_STATUS = "Final(SO)"
+FORFEIT_STATUS = "FORFEIT"
+NOEVENTS_STATUS = "NOEVENTS"
+
+
+def aggregate_team_goalie_stats(session, aggregation_type, aggregation_id):
+    """
+    Aggregate goalie stats by team for an organization or division.
+
+    For each team in the aggregation scope, calculates stats for all goalies
+    who played for that team, counting only games where they were on that team.
+
+    Args:
+        session: Database session
+        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
+    if aggregation_type == "org":
+        StatsModel = OrgStatsGoalieTeam
+        min_games = MIN_GAMES_FOR_ORG_STATS
+        aggregation_name = (
+            session.query(Organization)
+            .filter(Organization.id == aggregation_id)
+            .first()
+            .organization_name
+        )
+        filter_condition = Game.org_id == aggregation_id
+    elif aggregation_type == "division":
+        StatsModel = DivisionStatsGoalieTeam
+        min_games = MIN_GAMES_FOR_DIVISION_STATS
+        aggregation_name = (
+            session.query(Division).filter(Division.id == aggregation_id).first().level
+        )
+        filter_condition = Game.division_id == aggregation_id
+    else:
+        raise ValueError(f"Invalid aggregation type: {aggregation_type}")
+
+    print(f"Aggregating team goalie stats for {aggregation_name}...")
+
+    # Delete existing stats for this aggregation
+    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
+    session.commit()
+
+    # Get all teams in this aggregation scope
+    if aggregation_type == "org":
+        teams_query = (
+            session.query(Team.id, Team.name)
+            .join(Game, (Game.home_team_id == Team.id) | (Game.visitor_team_id == Team.id))
+            .filter(Game.org_id == aggregation_id)
+            .distinct()
+        )
+    else:  # division
+        teams_query = (
+            session.query(Team.id, Team.name)
+            .join(Game, (Game.home_team_id == Team.id) | (Game.visitor_team_id == Team.id))
+            .filter(Game.division_id == aggregation_id)
+            .distinct()
+        )
+
+    teams = teams_query.all()
+    print(f"Found {len(teams)} teams in {aggregation_name}")
+
+    # Process each team
+    progress = create_progress_tracker(len(teams), description="Processing teams")
+    for team_id, team_name in teams:
+        progress.update(1)
+
+        # Aggregate stats for goalies on this team
+        # Filter to only games where goalies were on THIS team
+        games_played_query = (
+            session.query(
+                GameRoster.human_id,
+                func.count(Game.id).label("games_played"),
+                func.count(Game.id).label("games_participated"),
+                func.count(Game.id).label("games_with_stats"),
+                func.array_agg(Game.id).label("game_ids"),
+            )
+            .join(Game, Game.id == GameRoster.game_id)
+            .filter(
+                GameRoster.team_id == team_id,  # KEY: Filter by team
+                GameRoster.role.ilike("g"),  # Only goalies
+                GameRoster.human_id.notin_(human_ids_to_filter),
+                Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS, FORFEIT_STATUS, NOEVENTS_STATUS]),
+                filter_condition,  # org_id or division_id filter
+            )
+            .group_by(GameRoster.human_id)
+            .having(func.count(Game.id) >= min_games)
+        )
+
+        games_played_data = games_played_query.all()
+        if not games_played_data:
+            continue  # No goalies met minimum games for this team
+
+        # Create stats dictionary
+        stats_dict = {}
+        for row in games_played_data:
+            stats_dict[row.human_id] = {
+                "games_played": row.games_played,
+                "games_participated": row.games_participated,
+                "games_with_stats": row.games_with_stats,
+                "game_ids": row.game_ids,
+                "first_game_id": row.game_ids[0] if row.game_ids else None,
+                "last_game_id": row.game_ids[-1] if row.game_ids else None,
+            }
+
+        # Aggregate goals allowed and shots faced from GoalieSaves table
+        goalie_saves_query = (
+            session.query(
+                GameRoster.human_id,
+                func.sum(GoalieSaves.goals_allowed).label("goals_allowed"),
+                func.sum(GoalieSaves.shots_against).label("shots_faced"),
+            )
+            .join(Game, Game.id == GameRoster.game_id)
+            .join(
+                GoalieSaves,
+                (GoalieSaves.game_id == Game.id) & (GoalieSaves.goalie_id == GameRoster.human_id),
+            )
+            .filter(
+                GameRoster.team_id == team_id,  # KEY: Filter by team
+                GameRoster.role.ilike("g"),
+                GameRoster.human_id.in_(stats_dict.keys()),
+                Game.status.in_([FINAL_STATUS, FINAL_SO_STATUS]),
+                filter_condition,
+            )
+            .group_by(GameRoster.human_id)
+        )
+
+        for row in goalie_saves_query.all():
+            if row.human_id in stats_dict:
+                stats_dict[row.human_id]["goals_allowed"] = row.goals_allowed or 0
+                stats_dict[row.human_id]["shots_faced"] = row.shots_faced or 0
+
+        # Calculate per-game averages and save percentage
+        for human_id, stats in stats_dict.items():
+            games_with_stats = stats.get("games_with_stats", 0)
+            goals_allowed = stats.get("goals_allowed", 0)
+            shots_faced = stats.get("shots_faced", 0)
+
+            if games_with_stats > 0:
+                stats["goals_allowed_per_game"] = goals_allowed / games_with_stats
+            else:
+                stats["goals_allowed_per_game"] = 0.0
+
+            if shots_faced > 0:
+                saves = shots_faced - goals_allowed
+                stats["save_percentage"] = saves / shots_faced
+            else:
+                stats["save_percentage"] = 0.0
+
+        # Insert stats for each goalie on this team
+        for human_id, stats in stats_dict.items():
+            goalie_stat = StatsModel(
+                aggregation_id=aggregation_id,
+                team_id=team_id,
+                human_id=human_id,
+                games_played=stats.get("games_played", 0),
+                games_participated=stats.get("games_participated", 0),
+                games_with_stats=stats.get("games_with_stats", 0),
+                goals_allowed=stats.get("goals_allowed", 0),
+                shots_faced=stats.get("shots_faced", 0),
+                goals_allowed_per_game=stats.get("goals_allowed_per_game", 0.0),
+                save_percentage=stats.get("save_percentage", 0.0),
+                total_in_rank=len(stats_dict),
+                first_game_id=stats.get("first_game_id"),
+                last_game_id=stats.get("last_game_id"),
+                # Initialize rank fields to 0 (not calculated for team stats)
+                games_played_rank=0,
+                games_participated_rank=0,
+                games_with_stats_rank=0,
+                goals_allowed_rank=0,
+                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}")
+
+
+def run_aggregate_team_goalie_stats():
+    """
+    Run team goalie stats aggregation for all organizations and divisions.
+    """
+    from hockey_blast_common_lib.utils import get_all_division_ids_for_org
+
+    session = create_session("boss")
+
+    # Get all org_id present in the Organization table
+    org_ids = session.query(Organization.id).all()
+    org_ids = [org_id[0] for org_id in org_ids]
+
+    for org_id in org_ids:
+        # Aggregate for organization level
+        aggregate_team_goalie_stats(session, "org", org_id)
+
+        # Aggregate for all divisions in this organization
+        division_ids = get_all_division_ids_for_org(session, org_id)
+        for division_id in division_ids:
+            aggregate_team_goalie_stats(session, "division", division_id)