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

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
 
@@ -117,6 +118,118 @@ def calculate_current_point_streak(session, human_id, filter_condition):
     return current_streak, avg_points_during_streak
 
 
+def calculate_all_point_streaks_batch(session, human_ids, filter_condition):
+    """
+    Calculate point streaks for ALL players in one batch query.
+    This is MUCH faster than calling calculate_current_point_streak() for each player.
+
+    Args:
+        session: Database session
+        human_ids: List of all human_ids to calculate streaks for (e.g., 150 players in a division)
+        filter_condition: SQLAlchemy filter condition (org/division/level + time window)
+
+    Returns:
+        Dict[human_id] -> (streak_length, avg_points_per_game)
+
+    Performance:
+        - Old: N queries (one per player)
+        - New: 1 query for all players
+        - Speedup: ~150x for typical division
+    """
+    if not human_ids:
+        return {}
+
+    # Single query for ALL players at once
+    game_points = (
+        session.query(
+            GameRoster.human_id,
+            Game.id.label("game_id"),
+            Game.date,
+            Game.time,
+            func.sum(
+                case((Goal.goal_scorer_id == GameRoster.human_id, 1), else_=0)
+            ).label("goals"),
+            func.sum(
+                case(
+                    (
+                        (Goal.assist_1_id == GameRoster.human_id) |
+                        (Goal.assist_2_id == GameRoster.human_id),
+                        1
+                    ),
+                    else_=0
+                )
+            ).label("assists"),
+        )
+        .join(Game, GameRoster.game_id == Game.id)
+        .outerjoin(Goal, Game.id == Goal.game_id)
+        .filter(
+            GameRoster.human_id.in_(human_ids),  # ← ALL players at once!
+            ~GameRoster.role.ilike("g"),  # Exclude goalie games
+            filter_condition,
+            (Game.status.like("Final%")) | (Game.status == "NOEVENTS"),
+        )
+        .group_by(GameRoster.human_id, Game.id, Game.date, Game.time)
+        .order_by(
+            GameRoster.human_id,  # Group by player first
+            Game.date.desc(),      # Then most recent games first
+            Game.time.desc()
+        )
+        .all()
+    )
+
+    # Process results in Python to calculate streaks
+    streaks_by_human = {}
+    processed_humans = set()  # Track which humans we've finished processing
+    current_human = None
+    current_streak = 0
+    total_points = 0
+
+    for row in game_points:
+        # Skip if we've already processed this human (streak already broken)
+        if row.human_id in processed_humans:
+            continue
+
+        # New player?
+        if row.human_id != current_human:
+            # Save previous player's streak (if any)
+            if current_human is not None:
+                avg = total_points / current_streak if current_streak > 0 else 0.0
+                streaks_by_human[current_human] = (current_streak, avg)
+                processed_humans.add(current_human)
+
+            # Reset for new player
+            current_human = row.human_id
+            current_streak = 0
+            total_points = 0
+
+        # Calculate points for this game
+        points = (row.goals or 0) + (row.assists or 0)
+
+        if points > 0:
+            # Streak continues
+            current_streak += 1
+            total_points += points
+        else:
+            # Streak broken - save and mark as processed
+            avg = total_points / current_streak if current_streak > 0 else 0.0
+            streaks_by_human[current_human] = (current_streak, avg)
+            processed_humans.add(current_human)
+            # Reset current_human so we skip remaining games for this player
+            current_human = None
+
+    # Don't forget the last player (if still in a streak)
+    if current_human is not None and current_human not in processed_humans:
+        avg = total_points / current_streak if current_streak > 0 else 0.0
+        streaks_by_human[current_human] = (current_streak, avg)
+
+    # Ensure all requested human_ids have a result (even if 0,0)
+    for human_id in human_ids:
+        if human_id not in streaks_by_human:
+            streaks_by_human[human_id] = (0, 0.0)
+
+    return streaks_by_human
+
+
 def insert_percentile_markers_skater(
     session, stats_dict, aggregation_id, total_in_rank, StatsModel, aggregation_window
 ):
@@ -223,6 +336,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
@@ -601,34 +717,26 @@ def aggregate_skater_stats(
                 stat["last_game_id"] = last_game.id if last_game else None
 
     # Calculate current point streak (only for all-time stats)
+    # OPTIMIZED: Use batch calculation instead of N+1 queries
     if aggregation_window is None:
         total_players = len(stats_dict)
-        # Show progress for All Orgs - this is the slowest part
-        if (
-            aggregation_type == "org"
-            and aggregation_id == ALL_ORGS_ID
-            and total_players > 1000
-        ):
-            progress = create_progress_tracker(
-                total_players, f"Calculating point streaks for {total_players} players"
-            )
-            for idx, (key, stat) in enumerate(stats_dict.items()):
-                agg_id, human_id = key
-                streak_length, avg_points = calculate_current_point_streak(
-                    session, human_id, filter_condition
-                )
-                stat["current_point_streak"] = streak_length
-                stat["current_point_streak_avg_points"] = avg_points
-                if (idx + 1) % 100 == 0 or (idx + 1) == total_players:
-                    progress.update(idx + 1)
-        else:
-            for key, stat in stats_dict.items():
-                agg_id, human_id = key
-                streak_length, avg_points = calculate_current_point_streak(
-                    session, human_id, filter_condition
-                )
-                stat["current_point_streak"] = streak_length
-                stat["current_point_streak_avg_points"] = avg_points
+
+        # Extract all human_ids from stats_dict
+        all_human_ids = [key[1] for key in stats_dict.keys()]
+
+        # Calculate all point streaks in ONE batch query (instead of N queries)
+        print(f"Calculating point streaks for {total_players} players using batch query...")
+        all_streaks = calculate_all_point_streaks_batch(
+            session, all_human_ids, filter_condition
+        )
+        print(f"✓ Point streaks calculated for {len(all_streaks)} players")
+
+        # Assign streak values to stats_dict
+        for key, stat in stats_dict.items():
+            agg_id, human_id = key
+            streak_length, avg_points = all_streaks.get(human_id, (0, 0.0))
+            stat["current_point_streak"] = streak_length
+            stat["current_point_streak_avg_points"] = avg_points
 
     # Calculate total_in_rank
     total_in_rank = len(stats_dict)
@@ -754,6 +862,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 +870,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.68.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hockey-blast-common-lib
-Version: 0.1.66
+Version: 0.1.68
 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.68.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=u5a4i6FOOhkFGTAiJjn4_tGnJX2pFb9Qg1fNhpCt-xY,39016
+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=DwPmAO5wg7a-BMw0qrVc8SJA0D8sTt5U5G0IEkSXh7k,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.68.dist-info/METADATA,sha256=ZLJPHKBMKWh9U2WPCKNWjoRTYEgcmsR5JBHKYMHkEGY,318
+hockey_blast_common_lib-0.1.68.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.68.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.68.dist-info/RECORD,,