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

hockey_blast_common_lib/aggregate_all_stats.py

@@ -11,6 +11,12 @@ from hockey_blast_common_lib.aggregate_scorekeeper_stats import (
     run_aggregate_scorekeeper_stats,
 )
 from hockey_blast_common_lib.aggregate_skater_stats import run_aggregate_skater_stats
+from hockey_blast_common_lib.aggregate_team_goalie_stats import (
+    run_aggregate_team_goalie_stats,
+)
+from hockey_blast_common_lib.aggregate_team_skater_stats import (
+    run_aggregate_team_skater_stats,
+)
 
 if __name__ == "__main__":
     print("Running aggregate_skater_stats...", flush=True)
@@ -32,3 +38,11 @@ if __name__ == "__main__":
     print("Running aggregate_human_stats...", flush=True)
     run_aggregate_human_stats()
     print("Finished running aggregate_human_stats\n")
+
+    print("Running aggregate_team_skater_stats...", flush=True)
+    run_aggregate_team_skater_stats()
+    print("Finished running aggregate_team_skater_stats\n")
+
+    print("Running aggregate_team_goalie_stats...", flush=True)
+    run_aggregate_team_goalie_stats()
+    print("Finished running aggregate_team_goalie_stats\n")

hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -35,8 +35,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 (
     assign_ranks,
+    calculate_percentile_value,
     get_all_division_ids_for_org,
     get_non_human_ids,
+    get_percentile_human,
     get_start_datetime,
 )
 
@@ -47,6 +49,67 @@ FORFEIT_STATUS = "FORFEIT"
 NOEVENTS_STATUS = "NOEVENTS"
 
 
+def insert_percentile_markers_goalie(
+    session, stats_dict, aggregation_id, total_in_rank, StatsModel
+):
+    """Insert percentile marker records for goalie 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
+    stat_fields = [
+        "games_played",
+        "games_participated",
+        "games_with_stats",
+        "goals_allowed",
+        "shots_faced",
+        "goals_allowed_per_game",
+        "save_percentage",
+    ]
+
+    percentiles = [25, 50, 75, 90, 95]
+
+    for percentile in percentiles:
+        percentile_human_id = get_percentile_human(session, "Goalie", 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
+
+        goalie_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,
+            games_with_stats=int(percentile_values.get("games_with_stats", 0)),
+            games_with_stats_rank=0,
+            goals_allowed=int(percentile_values.get("goals_allowed", 0)),
+            shots_faced=int(percentile_values.get("shots_faced", 0)),
+            goals_allowed_per_game=percentile_values.get("goals_allowed_per_game", 0.0),
+            save_percentage=percentile_values.get("save_percentage", 0.0),
+            games_played_rank=0,
+            goals_allowed_rank=0,
+            shots_faced_rank=0,
+            goals_allowed_per_game_rank=0,
+            save_percentage_rank=0,
+            total_in_rank=total_in_rank,
+            first_game_id=None,
+            last_game_id=None,
+        )
+        session.add(goalie_stat)
+
+    session.commit()
+
+
 def aggregate_goalie_stats(
     session,
     aggregation_type,
@@ -243,6 +306,11 @@ def aggregate_goalie_stats(
     assign_ranks(stats_dict, "goals_allowed_per_game", reverse_rank=True)
     assign_ranks(stats_dict, "save_percentage")
 
+    # Calculate and insert percentile marker records
+    insert_percentile_markers_goalie(
+        session, stats_dict, aggregation_id, total_in_rank, StatsModel
+    )
+
     # Debug output for specific human
     if debug_human_id:
         if any(key[1] == debug_human_id for key in stats_dict):

hockey_blast_common_lib/aggregate_referee_stats.py

@@ -29,8 +29,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 (
     assign_ranks,
+    calculate_percentile_value,
     get_all_division_ids_for_org,
     get_non_human_ids,
+    get_percentile_human,
     get_start_datetime,
 )
 
@@ -41,6 +43,62 @@ FORFEIT_STATUS = "FORFEIT"
 NOEVENTS_STATUS = "NOEVENTS"
 
 
+def insert_percentile_markers_referee(
+    session, stats_dict, aggregation_id, total_in_rank, StatsModel
+):
+    """Insert percentile marker records for referee stats."""
+    if not stats_dict:
+        return
+
+    stat_fields = [
+        "games_reffed",
+        "games_participated",
+        "games_with_stats",
+        "penalties_given",
+        "penalties_per_game",
+        "gm_given",
+        "gm_per_game",
+    ]
+
+    percentiles = [25, 50, 75, 90, 95]
+
+    for percentile in percentiles:
+        percentile_human_id = get_percentile_human(session, "Ref", 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
+
+        referee_stat = StatsModel(
+            aggregation_id=aggregation_id,
+            human_id=percentile_human_id,
+            games_reffed=int(percentile_values.get("games_reffed", 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,
+            penalties_given=int(percentile_values.get("penalties_given", 0)),
+            penalties_per_game=percentile_values.get("penalties_per_game", 0.0),
+            gm_given=int(percentile_values.get("gm_given", 0)),
+            gm_per_game=percentile_values.get("gm_per_game", 0.0),
+            games_reffed_rank=0,
+            penalties_given_rank=0,
+            penalties_per_game_rank=0,
+            gm_given_rank=0,
+            gm_per_game_rank=0,
+            total_in_rank=total_in_rank,
+            first_game_id=None,
+            last_game_id=None,
+        )
+        session.add(referee_stat)
+
+    session.commit()
+
+
 def aggregate_referee_stats(
     session, aggregation_type, aggregation_id, aggregation_window=None
 ):
@@ -281,6 +339,11 @@ def aggregate_referee_stats(
     assign_ranks(stats_dict, "gm_given")
     assign_ranks(stats_dict, "gm_per_game")
 
+    # Calculate and insert percentile marker records
+    insert_percentile_markers_referee(
+        session, stats_dict, aggregation_id, total_in_rank, StatsModel
+    )
+
     # Insert aggregated stats into the appropriate table with progress output
     total_items = len(stats_dict)
     batch_size = 1000

hockey_blast_common_lib/aggregate_scorekeeper_stats.py

@@ -22,7 +22,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 +35,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
 ):
@@ -252,6 +325,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):

hockey_blast_common_lib/aggregate_skater_stats.py

@@ -37,8 +37,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 +117,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,
@@ -561,6 +662,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):

hockey_blast_common_lib/aggregate_team_goalie_stats.py

@@ -0,0 +1,251 @@
+"""
+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__))))
+
+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
+    """
+    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,
+            )
+            session.add(goalie_stat)
+
+    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)

hockey_blast_common_lib/aggregate_team_skater_stats.py

@@ -0,0 +1,299 @@
+"""
+Aggregate skater statistics by team.
+
+This module aggregates player statistics for each team, counting only games
+where the player 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 OrgStatsSkaterTeam / DivisionStatsSkaterTeam
+
+"""
+import os
+import sys
+
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import sqlalchemy
+from sqlalchemy import and_, case, func
+
+from hockey_blast_common_lib.db_connection import create_session
+from hockey_blast_common_lib.models import (
+    Division,
+    Game,
+    GameRoster,
+    Goal,
+    Human,
+    Organization,
+    Penalty,
+    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 (
+    DivisionStatsSkaterTeam,
+    OrgStatsSkaterTeam,
+)
+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_skater_stats(session, aggregation_type, aggregation_id):
+    """
+    Aggregate skater stats by team for an organization or division.
+
+    For each team in the aggregation scope, calculates stats for all players
+    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
+    """
+    human_ids_to_filter = get_non_human_ids(session)
+
+    # Determine aggregation details
+    if aggregation_type == "org":
+        StatsModel = OrgStatsSkaterTeam
+        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 = DivisionStatsSkaterTeam
+        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 skater 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 this team
+        # Filter to only games where players 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"),  # Exclude 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 players 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, assists, points
+        goals_assists_query = (
+            session.query(
+                GameRoster.human_id,
+                func.count(func.distinct(case((Goal.goal_scorer_id == GameRoster.human_id, Goal.id)))).label("goals"),
+                func.count(
+                    func.distinct(
+                        case(
+                            (
+                                (Goal.assist_1_id == GameRoster.human_id) | (Goal.assist_2_id == GameRoster.human_id),
+                                Goal.id,
+                            )
+                        )
+                    )
+                ).label("assists"),
+            )
+            .join(Game, Game.id == GameRoster.game_id)
+            .outerjoin(Goal, Game.id == Goal.game_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 goals_assists_query.all():
+            if row.human_id in stats_dict:
+                stats_dict[row.human_id]["goals"] = row.goals
+                stats_dict[row.human_id]["assists"] = row.assists
+                stats_dict[row.human_id]["points"] = row.goals + row.assists
+
+        # Aggregate penalties
+        penalties_query = (
+            session.query(
+                GameRoster.human_id,
+                func.count(Penalty.id).label("penalties"),
+                func.sum(case((Penalty.penalty_minutes == "GM", 1), else_=0)).label("gm_penalties"),
+            )
+            .join(Game, Game.id == GameRoster.game_id)
+            .outerjoin(Penalty, and_(Game.id == Penalty.game_id, Penalty.penalized_player_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, FORFEIT_STATUS, NOEVENTS_STATUS]),
+                filter_condition,
+            )
+            .group_by(GameRoster.human_id)
+        )
+
+        for row in penalties_query.all():
+            if row.human_id in stats_dict:
+                stats_dict[row.human_id]["penalties"] = row.penalties
+                stats_dict[row.human_id]["gm_penalties"] = row.gm_penalties
+
+        # Calculate per-game averages
+        for human_id, stats in stats_dict.items():
+            games_with_stats = stats.get("games_with_stats", 0)
+            if games_with_stats > 0:
+                stats["goals_per_game"] = stats.get("goals", 0) / games_with_stats
+                stats["assists_per_game"] = stats.get("assists", 0) / games_with_stats
+                stats["points_per_game"] = stats.get("points", 0) / games_with_stats
+                stats["penalties_per_game"] = stats.get("penalties", 0) / games_with_stats
+                stats["gm_penalties_per_game"] = stats.get("gm_penalties", 0) / games_with_stats
+            else:
+                stats["goals_per_game"] = 0.0
+                stats["assists_per_game"] = 0.0
+                stats["points_per_game"] = 0.0
+                stats["penalties_per_game"] = 0.0
+                stats["gm_penalties_per_game"] = 0.0
+
+        # Insert stats for each player on this team
+        for human_id, stats in stats_dict.items():
+            skater_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=stats.get("goals", 0),
+                assists=stats.get("assists", 0),
+                points=stats.get("points", 0),
+                penalties=stats.get("penalties", 0),
+                gm_penalties=stats.get("gm_penalties", 0),
+                goals_per_game=stats.get("goals_per_game", 0.0),
+                assists_per_game=stats.get("assists_per_game", 0.0),
+                points_per_game=stats.get("points_per_game", 0.0),
+                penalties_per_game=stats.get("penalties_per_game", 0.0),
+                gm_penalties_per_game=stats.get("gm_penalties_per_game", 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 streak fields to 0 (not calculated for team stats)
+                current_point_streak=0,
+                current_point_streak_avg_points=0.0,
+                # Ranks will be assigned later if needed
+                games_played_rank=0,
+                games_participated_rank=0,
+                games_with_stats_rank=0,
+                goals_rank=0,
+                assists_rank=0,
+                points_rank=0,
+                penalties_rank=0,
+                gm_penalties_rank=0,
+                goals_per_game_rank=0,
+                assists_per_game_rank=0,
+                points_per_game_rank=0,
+                penalties_per_game_rank=0,
+                gm_penalties_per_game_rank=0,
+                current_point_streak_rank=0,
+                current_point_streak_avg_points_rank=0,
+            )
+            session.add(skater_stat)
+
+    session.commit()
+    progress.finish()
+    print(f"✓ Team skater stats aggregation complete for {aggregation_name}")
+
+
+def run_aggregate_team_skater_stats():
+    """
+    Run team skater 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_skater_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_skater_stats(session, "division", division_id)

hockey_blast_common_lib/stats_models.py

@@ -922,3 +922,126 @@ class SkillValuePPGRatio(db.Model):
             "from_skill_value", "to_skill_value", name="_from_to_skill_value_uc"
         ),
     )
+
+
+# Team-based statistics models (inherit from existing bases, add team_id field)
+class OrgStatsSkaterTeam(BaseStatsSkater):
+    __tablename__ = "org_stats_skater_team"
+    org_id = db.Column(db.Integer, db.ForeignKey("organizations.id"), nullable=False)
+    team_id = db.Column(db.Integer, db.ForeignKey("teams.id"), nullable=False)
+    aggregation_id = synonym("org_id")
+
+    @declared_attr
+    def aggregation_type(cls):
+        return "org_team"
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return "org_id"
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            db.UniqueConstraint(
+                "org_id",
+                "team_id",
+                "human_id",
+                name="_org_team_human_uc_skater_team1",
+            ),
+            db.Index("idx_org_team_team_id", "team_id"),
+            db.Index("idx_org_team_human_id", "human_id"),
+            db.Index("idx_org_team_goals_per_game", "org_id", "goals_per_game"),
+            db.Index("idx_org_team_points_per_game", "org_id", "points_per_game"),
+            db.Index("idx_org_team_assists_per_game", "org_id", "assists_per_game"),
+        )
+
+
+class DivisionStatsSkaterTeam(BaseStatsSkater):
+    __tablename__ = "division_stats_skater_team"
+    division_id = db.Column(db.Integer, db.ForeignKey("divisions.id"), nullable=False)
+    team_id = db.Column(db.Integer, db.ForeignKey("teams.id"), nullable=False)
+    aggregation_id = synonym("division_id")
+
+    @declared_attr
+    def aggregation_type(cls):
+        return "division_team"
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return "division_id"
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            db.UniqueConstraint(
+                "division_id",
+                "team_id",
+                "human_id",
+                name="_division_team_human_uc_skater_team1",
+            ),
+            db.Index("idx_division_team_team_id", "team_id"),
+            db.Index("idx_division_team_human_id", "human_id"),
+            db.Index("idx_division_team_goals_per_game", "division_id", "goals_per_game"),
+            db.Index("idx_division_team_points_per_game", "division_id", "points_per_game"),
+            db.Index("idx_division_team_assists_per_game", "division_id", "assists_per_game"),
+        )
+
+
+class OrgStatsGoalieTeam(BaseStatsGoalie):
+    __tablename__ = "org_stats_goalie_team"
+    org_id = db.Column(db.Integer, db.ForeignKey("organizations.id"), nullable=False)
+    team_id = db.Column(db.Integer, db.ForeignKey("teams.id"), nullable=False)
+    aggregation_id = synonym("org_id")
+
+    @declared_attr
+    def aggregation_type(cls):
+        return "org_team"
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return "org_id"
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            db.UniqueConstraint(
+                "org_id",
+                "team_id",
+                "human_id",
+                name="_org_team_human_uc_goalie_team1",
+            ),
+            db.Index("idx_org_team_goalie_team_id", "team_id"),
+            db.Index("idx_org_team_goalie_human_id", "human_id"),
+            db.Index("idx_org_team_goalie_save_pct", "org_id", "save_percentage"),
+            db.Index("idx_org_team_goalie_gaa", "org_id", "goals_allowed_per_game"),
+        )
+
+
+class DivisionStatsGoalieTeam(BaseStatsGoalie):
+    __tablename__ = "division_stats_goalie_team"
+    division_id = db.Column(db.Integer, db.ForeignKey("divisions.id"), nullable=False)
+    team_id = db.Column(db.Integer, db.ForeignKey("teams.id"), nullable=False)
+    aggregation_id = synonym("division_id")
+
+    @declared_attr
+    def aggregation_type(cls):
+        return "division_team"
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return "division_id"
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            db.UniqueConstraint(
+                "division_id",
+                "team_id",
+                "human_id",
+                name="_division_team_human_uc_goalie_team1",
+            ),
+            db.Index("idx_division_team_goalie_team_id", "team_id"),
+            db.Index("idx_division_team_goalie_human_id", "human_id"),
+            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"),
+        )

hockey_blast_common_lib/utils.py

@@ -85,6 +85,7 @@ def get_non_human_ids(session):
 
     Returns set of human_ids that should be filtered out from statistics.
     Filters out placeholder names like "Home", "Away", "Unknown", etc.
+    Also excludes percentile marker humans.
     """
     not_human_names = [
         ("Home", None, None),
@@ -95,7 +96,11 @@ def get_non_human_ids(session):
         ("Unassigned", None, None),
         ("Not", "Signed", "In"),
         ("Incognito", None, None),
+        ("Empty", None , "Net"),
+        ("Fake", "Stats", "Human"),
+        (None, None, "Percentile"),
     ]
+
     return get_human_ids_by_names(session, not_human_names)
 
 
@@ -206,6 +211,67 @@ def get_fake_level(session):
     return fake_skill
 
 
+def get_percentile_human(session, entity_type, percentile):
+    """Get or create a human record representing a percentile marker.
+
+    Args:
+        session: Database session
+        entity_type: One of "Skater", "Goalie", "Ref", "Scorekeeper"
+        percentile: One of 25, 50, 75, 90, 95
+
+    Returns:
+        human_id of the percentile marker record
+    """
+    first_name = entity_type
+    middle_name = str(percentile)
+    last_name = "Percentile"
+
+    # Check if the human already exists
+    existing_human = (
+        session.query(Human)
+        .filter_by(first_name=first_name, middle_name=middle_name, last_name=last_name)
+        .first()
+    )
+    if existing_human:
+        return existing_human.id
+
+    # Create a new human
+    human = Human(first_name=first_name, middle_name=middle_name, last_name=last_name)
+    session.add(human)
+    session.commit()
+
+    return human.id
+
+
+def calculate_percentile_value(values, percentile):
+    """Calculate the percentile value from a list of values.
+
+    Args:
+        values: List of numeric values
+        percentile: Percentile to calculate (e.g., 25, 50, 75, 90, 95)
+
+    Returns:
+        The value at the given percentile
+    """
+    if not values:
+        return 0
+
+    sorted_values = sorted(values)
+    n = len(sorted_values)
+
+    # Calculate index (using linear interpolation method)
+    index = (percentile / 100.0) * (n - 1)
+    lower_index = int(index)
+    upper_index = min(lower_index + 1, n - 1)
+
+    # Interpolate if needed
+    fraction = index - lower_index
+    lower_value = sorted_values[lower_index]
+    upper_value = sorted_values[upper_index]
+
+    return lower_value + fraction * (upper_value - lower_value)
+
+
 # TEST DB CONNECTION, PERMISSIONS...
 # from hockey_blast_common_lib.db_connection import create_session
 # session = create_session("frontend")

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

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

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

@@ -1,29 +1,31 @@
 hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hockey_blast_common_lib/aggregate_all_stats.py,sha256=ozILLB3-CRABYN9JHeH2sFeXw-sFhkXboU7sKTV2Ok8,1378
-hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=QPza_glSHcggt0KTwVB6USTkvEdP3yZj7GjpNeGjFE8,17433
+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_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=YyFFHU2FJnXyUEzkzMnJoa5O28zjtF_spJeGedaI4QA,17389
+hockey_blast_common_lib/aggregate_referee_stats.py,sha256=VZVqiTfcHKtpyqUjvFBlypz2P8bIVg9wp0OK-MOu7O8,19580
 hockey_blast_common_lib/aggregate_s2s_stats.py,sha256=gB3Oi1emtBWL3bKojUhHH01gAbQTSLvgqO1WcvLI6F8,7449
-hockey_blast_common_lib/aggregate_scorekeeper_stats.py,sha256=r0CUsOSjeKwAEanrPSkqVufkxk9Iv_c125mKdhwR9Ns,14758
-hockey_blast_common_lib/aggregate_skater_stats.py,sha256=chy-LcuNIGHP85h0FiXZT3nZrbGKbcr66_j-atrucXs,30706
+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/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=u5lGgEUTbJddCd-y2hu8LsMRoZW0Ox_jNzWYqNR1sbc,4648908
+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/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=t4nBxEr__dPJlO005jKvwQRWdUJwoXsALtVmW3crtdM,31100
+hockey_blast_common_lib/stats_models.py,sha256=EU7Uw9ANPNNEx4vORgJkMFdgyTXQGmGLOF7YiY8jeBY,35488
 hockey_blast_common_lib/stats_utils.py,sha256=PTZvykl1zfEcojnzDFa1J3V3F5gREmoFG1lQHLnYHgo,300
-hockey_blast_common_lib/utils.py,sha256=18ThTgXliIPwBPBNAY6jU9fLUpKaiOwvsr6xBGtj4vg,7159
+hockey_blast_common_lib/utils.py,sha256=xHgA3Xh40i4CBVArvfW2j123XGdgrMTFqTudPQHwkho,8997
 hockey_blast_common_lib/wsgi.py,sha256=oL9lPWccKLTAYIKPJkKZV5keVE-Dgosv74CBi770NNc,786
-hockey_blast_common_lib-0.1.64.dist-info/METADATA,sha256=Pmli4OSe-AKxoOz3Eb0kptBpyK2dALHREZiRbTK2bhQ,318
-hockey_blast_common_lib-0.1.64.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.64.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.64.dist-info/RECORD,,
+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,,