hockey-blast-common-lib 0.1.51__py3-none-any.whl → 0.1.54__py3-none-any.whl

hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -16,6 +16,7 @@ from hockey_blast_common_lib.utils import assign_ranks
 from sqlalchemy import func, case, and_
 from collections import defaultdict
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
 
 def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_filter_out, debug_human_id=None, aggregation_window=None):
     human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
@@ -190,33 +191,51 @@ def run_aggregate_goalie_stats():
 
     for org_id in org_ids:
         division_ids = get_all_division_ids_for_org(session, org_id)
-        print(f"Aggregating goalie stats for {len(division_ids)} divisions in org_id {org_id}...")
-        total_divisions = len(division_ids)
-        processed_divisions = 0
-        for division_id in division_ids:
-            aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
-            aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
-            aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
-            processed_divisions += 1
-            if human_id_to_debug is None:
-                print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
-
-        aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
-        aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
-        aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+        org_name = session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
         
-        # Aggregate by level
-    level_ids = session.query(Division.level_id).distinct().all()
-    level_ids = [level_id[0] for level_id in level_ids]
-    total_levels = len(level_ids)
-    processed_levels = 0
-    for level_id in level_ids:
-        if level_id is None:
-            continue
+        if human_id_to_debug is None and division_ids:
+            # Process divisions with progress tracking
+            progress = create_progress_tracker(len(division_ids), f"Processing {len(division_ids)} divisions for {org_name}")
+            for i, division_id in enumerate(division_ids):
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+                progress.update(i + 1)
+        else:
+            # Debug mode or no divisions - process without progress tracking
+            for division_id in division_ids:
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_goalie_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+
+        # Process org-level stats with progress tracking
         if human_id_to_debug is None:
-            print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
-        processed_levels += 1
-        aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            org_progress = create_progress_tracker(3, f"Processing org-level stats for {org_name}")
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            org_progress.update(1)
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+            org_progress.update(2)
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+            org_progress.update(3)
+        else:
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_goalie_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+        
+    # Aggregate by level
+    level_ids = session.query(Division.level_id).distinct().all()
+    level_ids = [level_id[0] for level_id in level_ids if level_id[0] is not None]
+    
+    if human_id_to_debug is None and level_ids:
+        # Process levels with progress tracking
+        level_progress = create_progress_tracker(len(level_ids), f"Processing {len(level_ids)} skill levels")
+        for i, level_id in enumerate(level_ids):
+            aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            level_progress.update(i + 1)
+    else:
+        # Debug mode or no levels - process without progress tracking
+        for level_id in level_ids:
+            aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
 
 if __name__ == "__main__":
     run_aggregate_goalie_stats()

hockey_blast_common_lib/aggregate_h2h_stats.py

@@ -7,6 +7,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from hockey_blast_common_lib.models import Game, GameRoster, Goal, Penalty
 from hockey_blast_common_lib.h2h_models import H2HStats, H2HStatsMeta
 from hockey_blast_common_lib.db_connection import create_session
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
 from sqlalchemy.sql import func
 from sqlalchemy import types
 
@@ -41,6 +42,9 @@ def aggregate_h2h_stats():
 
     total_games = games_query.count()
     print(f"Total games to process: {total_games}")
+    
+    # Create progress tracker
+    progress = create_progress_tracker(total_games, "Processing H2H stats")
     processed = 0
     latest_game_id = None
     for game in games_query:
@@ -191,14 +195,11 @@ def aggregate_h2h_stats():
                 # --- TODO: Add more detailed logic for goalie/skater, referee/player, shootouts, etc. ---
         latest_game_id = game.id
         processed += 1
-        if processed % 10 == 0 or processed == total_games:
-            print(f"\rProcessed {processed}/{total_games} games ({(processed/total_games)*100:.2f}%)", end="")
-            sys.stdout.flush()
+        progress.update(processed)
     # Commit all stats at once
     session.query(H2HStats).delete()
     session.add_all(list(h2h_stats_dict.values()))
     session.commit()
-    print(f"\rProcessed {processed}/{total_games} games (100.00%)")
     # Save/update meta
     meta = H2HStatsMeta(
         last_run_timestamp=datetime.utcnow(),

hockey_blast_common_lib/aggregate_human_stats.py

@@ -15,6 +15,7 @@ from hockey_blast_common_lib.utils import get_fake_human_for_stats, get_org_id_f
 from hockey_blast_common_lib.utils import assign_ranks
 from hockey_blast_common_lib.utils import get_start_datetime
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
 
 def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_filter_out, human_id_filter=None, aggregation_window=None):
     human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
@@ -425,35 +426,53 @@ def run_aggregate_human_stats():
     org_ids = session.query(Organization.id).all()
     org_ids = [org_id[0] for org_id in org_ids]
 
-    for org_id in [-1]:#org_ids:
+    for org_id in org_ids:
         division_ids = get_all_division_ids_for_org(session, org_id)
-        print(f"Aggregating human stats for {len(division_ids)} divisions in org_id {org_id}...")
-        total_divisions = len(division_ids)
-        processed_divisions = 0
-        for division_id in division_ids:
-            aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
-            aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
-            aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
-            processed_divisions += 1
-            if human_id_to_debug is None:
-                print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
-        print("")
-        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
-        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
-        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+        org_name = session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
         
-        # Aggregate by level
-    level_ids = session.query(Division.level_id).distinct().all()
-    level_ids = [level_id[0] for level_id in level_ids]
-    total_levels = len(level_ids)
-    processed_levels = 0
-    for level_id in level_ids:
-        if level_id is None:
-            continue
+        if human_id_to_debug is None and division_ids:
+            # Process divisions with progress tracking
+            progress = create_progress_tracker(len(division_ids), f"Processing {len(division_ids)} divisions for {org_name}")
+            for i, division_id in enumerate(division_ids):
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+                progress.update(i + 1)
+        else:
+            # Debug mode or no divisions - process without progress tracking
+            for division_id in division_ids:
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+
+        # Process org-level stats with progress tracking
         if human_id_to_debug is None:
-            print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
-        processed_levels += 1
-        aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            org_progress = create_progress_tracker(3, f"Processing org-level stats for {org_name}")
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            org_progress.update(1)
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+            org_progress.update(2)
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+            org_progress.update(3)
+        else:
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+        
+    # Aggregate by level
+    level_ids = session.query(Division.level_id).distinct().all()
+    level_ids = [level_id[0] for level_id in level_ids if level_id[0] is not None]
+    
+    if human_id_to_debug is None and level_ids:
+        # Process levels with progress tracking
+        level_progress = create_progress_tracker(len(level_ids), f"Processing {len(level_ids)} skill levels")
+        for i, level_id in enumerate(level_ids):
+            aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            level_progress.update(i + 1)
+    else:
+        # Debug mode or no levels - process without progress tracking
+        for level_id in level_ids:
+            aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
 
 if __name__ == "__main__":
     run_aggregate_human_stats()

hockey_blast_common_lib/aggregate_referee_stats.py

@@ -15,6 +15,7 @@ from hockey_blast_common_lib.utils import get_org_id_from_alias, get_human_ids_b
 from hockey_blast_common_lib.utils import assign_ranks
 from hockey_blast_common_lib.utils import get_start_datetime
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
 
 def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_filter_out, aggregation_window=None):
     human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
@@ -214,33 +215,51 @@ def run_aggregate_referee_stats():
 
     for org_id in org_ids:
         division_ids = get_all_division_ids_for_org(session, org_id)
-        print(f"Aggregating referee stats for {len(division_ids)} divisions in org_id {org_id}...")
-        total_divisions = len(division_ids)
-        processed_divisions = 0
-        for division_id in division_ids:
-            aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names)
-            aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
-            aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
-            processed_divisions += 1
-            if human_id_to_debug is None:
-                print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
-
-        aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names)
-        aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
-        aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+        org_name = session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
         
-        # Aggregate by level
-    level_ids = session.query(Division.level_id).distinct().all()
-    level_ids = [level_id[0] for level_id in level_ids]
-    total_levels = len(level_ids)
-    processed_levels = 0
-    for level_id in level_ids:
-        if level_id is None:
-            continue
+        if human_id_to_debug is None and division_ids:
+            # Process divisions with progress tracking
+            progress = create_progress_tracker(len(division_ids), f"Processing {len(division_ids)} divisions for {org_name}")
+            for i, division_id in enumerate(division_ids):
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names)
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+                progress.update(i + 1)
+        else:
+            # Debug mode or no divisions - process without progress tracking
+            for division_id in division_ids:
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names)
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+                aggregate_referee_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+
+        # Process org-level stats with progress tracking
         if human_id_to_debug is None:
-            print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
-        processed_levels += 1
-        aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names)
+            org_progress = create_progress_tracker(3, f"Processing org-level stats for {org_name}")
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names)
+            org_progress.update(1)
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+            org_progress.update(2)
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+            org_progress.update(3)
+        else:
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names)
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+            aggregate_referee_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, aggregation_window='Daily')
+        
+    # Aggregate by level
+    level_ids = session.query(Division.level_id).distinct().all()
+    level_ids = [level_id[0] for level_id in level_ids if level_id[0] is not None]
+    
+    if human_id_to_debug is None and level_ids:
+        # Process levels with progress tracking
+        level_progress = create_progress_tracker(len(level_ids), f"Processing {len(level_ids)} skill levels")
+        for i, level_id in enumerate(level_ids):
+            aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names)
+            level_progress.update(i + 1)
+    else:
+        # Debug mode or no levels - process without progress tracking
+        for level_id in level_ids:
+            aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names)
 
 if __name__ == "__main__":
     run_aggregate_referee_stats()

hockey_blast_common_lib/aggregate_s2s_stats.py

@@ -0,0 +1,143 @@
+import sys, os
+from datetime import datetime
+
+# Add the package directory to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from hockey_blast_common_lib.models import Game, Goal, Penalty, GameRoster
+from hockey_blast_common_lib.h2h_models import SkaterToSkaterStats, SkaterToSkaterStatsMeta
+from hockey_blast_common_lib.db_connection import create_session
+from sqlalchemy.sql import func
+from sqlalchemy import types
+
+# Optional: Limit processing to a specific human_id
+LIMIT_HUMAN_ID = None
+
+def aggregate_s2s_stats():
+    session = create_session("boss")
+    meta = session.query(SkaterToSkaterStatsMeta).order_by(SkaterToSkaterStatsMeta.id.desc()).first()
+    s2s_stats_dict = {}  # (skater1_id, skater2_id) -> SkaterToSkaterStats instance
+
+    if meta is None or meta.last_run_timestamp is None or meta.last_processed_game_id is None:
+        # Full run: delete all existing stats and process all games
+        session.query(SkaterToSkaterStats).delete()
+        session.commit()
+        games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
+        print("No previous run found, deleted all existing Skater-to-Skater stats, processing all games...")
+    else:
+        # Incremental: only process games after last processed
+        for stat in session.query(SkaterToSkaterStats).all():
+            s2s_stats_dict[(stat.skater1_id, stat.skater2_id)] = stat
+        last_game = session.query(Game).filter(Game.id == meta.last_processed_game_id).first()
+        if last_game:
+            last_dt = datetime.combine(last_game.date, last_game.time)
+            games_query = session.query(Game).filter(
+                func.cast(func.concat(Game.date, ' ', Game.time), types.TIMESTAMP()) > last_dt
+            ).order_by(Game.date, Game.time, Game.id)
+            print(f"Resuming from game after id {meta.last_processed_game_id} ({last_dt})...")
+        else:
+            games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
+            print("Previous game id not found, processing all games...")
+
+    total_games = games_query.count()
+    print(f"Total games to process: {total_games}")
+    processed = 0
+    latest_game_id = None
+
+    for game in games_query:
+        # Separate skaters into home and away rosters (exclude goalies)
+        home_skaters = [entry.human_id for entry in session.query(GameRoster).filter(GameRoster.game_id == game.id, GameRoster.team_id == game.home_team_id, ~GameRoster.role.ilike('g')).all()]
+        away_skaters = [entry.human_id for entry in session.query(GameRoster).filter(GameRoster.game_id == game.id, GameRoster.team_id == game.visitor_team_id, ~GameRoster.role.ilike('g')).all()]
+
+        if LIMIT_HUMAN_ID is not None and LIMIT_HUMAN_ID not in home_skaters + away_skaters:
+            continue
+
+        # Create pairs of skaters from different rosters
+        for h_skater in home_skaters:
+            for a_skater in away_skaters:
+                if LIMIT_HUMAN_ID is not None and LIMIT_HUMAN_ID not in [h_skater, a_skater]:
+                    continue
+
+                s1, s2 = sorted([h_skater, a_skater])
+                key = (s1, s2)
+                s2s = s2s_stats_dict.get(key)
+                if not s2s:
+                    s2s = SkaterToSkaterStats(
+                        skater1_id=s1,
+                        skater2_id=s2,
+                        games_against=0,
+                        games_tied_against=0,
+                        skater1_wins_vs_skater2=0,
+                        skater2_wins_vs_skater1=0,
+                        skater1_goals_against_skater2=0,
+                        skater2_goals_against_skater1=0,
+                        skater1_assists_against_skater2=0,
+                        skater2_assists_against_skater1=0,
+                        skater1_penalties_against_skater2=0,
+                        skater2_penalties_against_skater1=0
+                    )
+                    s2s_stats_dict[key] = s2s
+
+                # Update stats
+                s2s.games_against += 1
+                if _is_tie(game):
+                    s2s.games_tied_against += 1
+                elif _is_win(game, s1, game.home_team_id):
+                    s2s.skater1_wins_vs_skater2 += 1
+                elif _is_win(game, s2, game.visitor_team_id):
+                    s2s.skater2_wins_vs_skater1 += 1
+
+                # Goals and assists
+                goals_stats = session.query(Goal).filter(Goal.game_id == game.id).all()
+                for goal in goals_stats:
+                    if goal.goal_scorer_id == s1:
+                        s2s.skater1_goals_against_skater2 += 1
+                    if goal.goal_scorer_id == s2:
+                        s2s.skater2_goals_against_skater1 += 1
+                    if goal.assist_1_id == s1 or goal.assist_2_id == s1:
+                        s2s.skater1_assists_against_skater2 += 1
+                    if goal.assist_1_id == s2 or goal.assist_2_id == s2:
+                        s2s.skater2_assists_against_skater1 += 1
+
+                # Penalties
+                penalties_stats = session.query(Penalty).filter(Penalty.game_id == game.id).all()
+                for penalty in penalties_stats:
+                    if penalty.penalized_player_id == s1:
+                        s2s.skater1_penalties_against_skater2 += 1
+                    if penalty.penalized_player_id == s2:
+                        s2s.skater2_penalties_against_skater1 += 1
+
+        latest_game_id = game.id
+        processed += 1
+        if processed % 10 == 0 or processed == total_games:
+            print(f"\rProcessed {processed}/{total_games} games ({(processed/total_games)*100:.2f}%)", end="")
+            sys.stdout.flush()
+
+    # Commit all stats at once
+    session.query(SkaterToSkaterStats).delete()
+    session.add_all(list(s2s_stats_dict.values()))
+    session.commit()
+    print(f"\rProcessed {processed}/{total_games} games (100.00%)")
+
+    # Save/update meta
+    meta = SkaterToSkaterStatsMeta(
+        last_run_timestamp=datetime.utcnow(),
+        last_processed_game_id=latest_game_id
+    )
+    session.add(meta)
+    session.commit()
+    print("Skater-to-Skater aggregation complete.")
+
+# --- Helper functions for win/loss/tie ---
+def _is_win(game, skater_id, team_id):
+    if team_id == game.home_team_id:
+        return (game.home_final_score or 0) > (game.visitor_final_score or 0)
+    if team_id == game.visitor_team_id:
+        return (game.visitor_final_score or 0) > (game.home_final_score or 0)
+    return False
+
+def _is_tie(game):
+    return (game.home_final_score is not None and game.visitor_final_score is not None and game.home_final_score == game.visitor_final_score)
+
+if __name__ == "__main__":
+    aggregate_s2s_stats()

hockey_blast_common_lib/aggregate_skater_stats.py

@@ -16,6 +16,53 @@ from hockey_blast_common_lib.utils import get_start_datetime
 from sqlalchemy import func, case, and_
 from collections import defaultdict
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
+
+def calculate_current_point_streak(session, human_id, filter_condition):
+    """
+    Calculate the current point streak for a player.
+    A point streak is consecutive games (from the most recent game backward) where the player had at least one point.
+    Returns a tuple: (streak_length, average_points_during_streak)
+    """
+    # Get all games for this player ordered by date/time descending (most recent first)
+    games = session.query(Game).join(GameRoster, Game.id == GameRoster.game_id).filter(
+        GameRoster.human_id == human_id,
+        ~GameRoster.role.ilike('g'),  # Exclude goalie games
+        filter_condition,
+        Game.status.like('Final%')  # Only final games
+    ).order_by(Game.date.desc(), Game.time.desc()).all()
+    
+    if not games:
+        return 0, 0.0
+    
+    current_streak = 0
+    total_points_in_streak = 0
+    
+    for game in games:
+        # Check if the player had any points in this game
+        goals = session.query(Goal).filter(
+            Goal.game_id == game.id,
+            Goal.goal_scorer_id == human_id
+        ).count()
+        
+        assists = session.query(Goal).filter(
+            Goal.game_id == game.id,
+            ((Goal.assist_1_id == human_id) | (Goal.assist_2_id == human_id))
+        ).count()
+        
+        total_points = goals + assists
+        
+        if total_points > 0:
+            current_streak += 1
+            total_points_in_streak += total_points
+        else:
+            # Streak is broken, stop counting
+            break
+    
+    # Calculate average points during streak
+    avg_points_during_streak = total_points_in_streak / current_streak if current_streak > 0 else 0.0
+    
+    return current_streak, avg_points_during_streak
 
 def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_filter_out, debug_human_id=None, aggregation_window=None):
     human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
@@ -57,7 +104,12 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     elif aggregation_type == 'level':
         StatsModel = LevelStatsSkater
         min_games = MIN_GAMES_FOR_LEVEL_STATS
-        filter_condition = Division.level_id == aggregation_id
+        # Get division IDs for this level to avoid cartesian product
+        division_ids = session.query(Division.id).filter(Division.level_id == aggregation_id).all()
+        division_ids = [div_id[0] for div_id in division_ids]
+        if not division_ids:
+            return  # No divisions for this level
+        filter_condition = Game.division_id.in_(division_ids)
         # Add filter to only include games for the last 5 years
         # five_years_ago = datetime.now() - timedelta(days=5*365)
         # level_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP) >= five_years_ago
@@ -86,39 +138,65 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     #     human_filter = [GameRoster.human_id == debug_human_id]
 
     # Aggregate games played for each human in each division, excluding goalies
-    games_played_stats = session.query(
+    games_played_query = session.query(
         GameRoster.human_id,
         func.count(Game.id).label('games_played'),
         func.array_agg(Game.id).label('game_ids')
-    ).join(Game, Game.id == GameRoster.game_id).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(GameRoster.human_id).all()
+    ).join(Game, Game.id == GameRoster.game_id)
+    
+    # Only join Division if not level aggregation (since we filter on Game.division_id directly for levels)
+    if aggregation_type != 'level':
+        games_played_query = games_played_query.join(Division, Game.division_id == Division.id)
+    
+    games_played_stats = games_played_query.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(GameRoster.human_id).all()
 
     # Aggregate goals for each human in each division, excluding goalies
-    goals_stats = session.query(
+    goals_query = session.query(
         Goal.goal_scorer_id.label('human_id'),
         func.count(Goal.id).label('goals'),
         func.array_agg(Goal.game_id).label('goal_game_ids')
-    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.goal_scorer_id == GameRoster.human_id)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.goal_scorer_id).all()
+    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.goal_scorer_id == GameRoster.human_id))
+    
+    if aggregation_type != 'level':
+        goals_query = goals_query.join(Division, Game.division_id == Division.id)
+    
+    goals_stats = goals_query.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.goal_scorer_id).all()
 
     # Aggregate assists for each human in each division, excluding goalies
-    assists_stats = session.query(
+    assists_query = session.query(
         Goal.assist_1_id.label('human_id'),
         func.count(Goal.id).label('assists'),
         func.array_agg(Goal.game_id).label('assist_game_ids')
-    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.assist_1_id == GameRoster.human_id)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.assist_1_id).all()
-
-    assists_stats_2 = session.query(
+    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.assist_1_id == GameRoster.human_id))
+    
+    if aggregation_type != 'level':
+        assists_query = assists_query.join(Division, Game.division_id == Division.id)
+    
+    assists_stats = assists_query.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.assist_1_id).all()
+
+    assists_query_2 = session.query(
         Goal.assist_2_id.label('human_id'),
         func.count(Goal.id).label('assists'),
         func.array_agg(Goal.game_id).label('assist_2_game_ids')
-    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.assist_2_id == GameRoster.human_id)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.assist_2_id).all()
+    ).join(Game, Game.id == Goal.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Goal.assist_2_id == GameRoster.human_id))
+    
+    if aggregation_type != 'level':
+        assists_query_2 = assists_query_2.join(Division, Game.division_id == Division.id)
+    
+    assists_stats_2 = assists_query_2.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Goal.assist_2_id).all()
 
     # Aggregate penalties for each human in each division, excluding goalies
-    penalties_stats = session.query(
+    penalties_query = session.query(
         Penalty.penalized_player_id.label('human_id'),
         func.count(Penalty.id).label('penalties'),
         func.sum(case((Penalty.penalty_minutes == 'GM', 1), else_=0)).label('gm_penalties'),  # New aggregation for GM penalties
         func.array_agg(Penalty.game_id).label('penalty_game_ids')
-    ).join(Game, Game.id == Penalty.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Penalty.penalized_player_id == GameRoster.human_id)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Penalty.penalized_player_id).all()
+    ).join(Game, Game.id == Penalty.game_id).join(GameRoster, and_(Game.id == GameRoster.game_id, Penalty.penalized_player_id == GameRoster.human_id))
+    
+    if aggregation_type != 'level':
+        penalties_query = penalties_query.join(Division, Game.division_id == Division.id)
+    
+    penalties_stats = penalties_query.filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Penalty.penalized_player_id).all()
 
     # Combine the results
     stats_dict = {}
@@ -139,6 +217,8 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
                 'assists_per_game': 0.0,
                 'penalties_per_game': 0.0,
                 'gm_penalties_per_game': 0.0,  # Initialize GM penalties per game
+                'current_point_streak': 0,  # Initialize current point streak
+                'current_point_streak_avg_points': 0.0,  # Initialize current point streak average points
                 'game_ids': [],
                 'first_game_id': None,
                 'last_game_id': None
@@ -194,6 +274,14 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             stat['first_game_id'] = first_game.id if first_game else None
             stat['last_game_id'] = last_game.id if last_game else None
 
+    # Calculate current point streak (only for all-time stats)
+    if aggregation_window is None:
+        for key, stat in stats_dict.items():
+            aggregation_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
+
     # Calculate total_in_rank
     total_in_rank = len(stats_dict)
 
@@ -214,6 +302,9 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     assign_ranks(stats_dict, 'assists_per_game')
     assign_ranks(stats_dict, 'penalties_per_game')
     assign_ranks(stats_dict, 'gm_penalties_per_game')  # Assign ranks for GM penalties per game
+    if aggregation_window is None:  # Only assign current_point_streak ranks for all-time stats
+        assign_ranks(stats_dict, 'current_point_streak')
+        assign_ranks(stats_dict, 'current_point_streak_avg_points')
 
     # Debug output for specific human
     if debug_human_id:
@@ -262,6 +353,10 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             penalties_per_game_rank=stat['penalties_per_game_rank'],
             gm_penalties_per_game_rank=stat['gm_penalties_per_game_rank'],  # Include GM penalties per game rank
             total_in_rank=total_in_rank,
+            current_point_streak=stat.get('current_point_streak', 0),
+            current_point_streak_rank=stat.get('current_point_streak_rank', 0),
+            current_point_streak_avg_points=stat.get('current_point_streak_avg_points', 0.0),
+            current_point_streak_avg_points_rank=stat.get('current_point_streak_avg_points_rank', 0),
             first_game_id=stat['first_game_id'],
             last_game_id=stat['last_game_id']
         )
@@ -281,33 +376,51 @@ def run_aggregate_skater_stats():
 
     for org_id in org_ids:
         division_ids = get_all_division_ids_for_org(session, org_id)
-        print(f"Aggregating skater stats for {len(division_ids)} divisions in org_id {org_id}...")
-        total_divisions = len(division_ids)
-        processed_divisions = 0
-        for division_id in division_ids:
-            aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
-            aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
-            aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
-            processed_divisions += 1
-            if human_id_to_debug is None:
-                print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
-
-        aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
-        aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
-        aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+        org_name = session.query(Organization.organization_name).filter(Organization.id == org_id).scalar() or f"org_id {org_id}"
+        
+        if human_id_to_debug is None and division_ids:
+            # Process divisions with progress tracking
+            progress = create_progress_tracker(len(division_ids), f"Processing {len(division_ids)} divisions for {org_name}")
+            for i, division_id in enumerate(division_ids):
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+                progress.update(i + 1)
+        else:
+            # Debug mode or no divisions - process without progress tracking
+            for division_id in division_ids:
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+                aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+
+        # Process org-level stats with progress tracking
+        if human_id_to_debug is None:
+            org_progress = create_progress_tracker(3, f"Processing org-level stats for {org_name}")
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            org_progress.update(1)
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+            org_progress.update(2)
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
+            org_progress.update(3)
+        else:
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug, aggregation_window='Daily')
         
     # Aggregate by level
     level_ids = session.query(Division.level_id).distinct().all()
-    level_ids = [level_id[0] for level_id in level_ids]
-    total_levels = len(level_ids)
-    processed_levels = 0
-    for level_id in level_ids:
-        if level_id is None:
-            continue
-        if human_id_to_debug is None:
-            print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
-        processed_levels += 1
-        aggregate_skater_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+    level_ids = [level_id[0] for level_id in level_ids if level_id[0] is not None]
+    
+    if human_id_to_debug is None and level_ids:
+        # Process levels with progress tracking
+        level_progress = create_progress_tracker(len(level_ids), f"Processing {len(level_ids)} skill levels")
+        for i, level_id in enumerate(level_ids):
+            aggregate_skater_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+            level_progress.update(i + 1)
+    else:
+        # Debug mode or no levels - process without progress tracking
+        for level_id in level_ids:
+            aggregate_skater_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
 
 if __name__ == "__main__":
     run_aggregate_skater_stats()

hockey_blast_common_lib/assign_skater_skill.py

@@ -6,43 +6,53 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from hockey_blast_common_lib.models import Human, Level
 from hockey_blast_common_lib.stats_models import LevelStatsSkater
 from hockey_blast_common_lib.db_connection import create_session
-from sqlalchemy.sql import func
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
 
-def calculate_skater_skill_value(session, human_id, level_stats):
-    max_skill_value = 0
+def calculate_skater_skill_value(session, level_stats):
+    min_skill_value = float('inf')  # Start with infinity since we want the minimum
 
     for stat in level_stats:
         level = session.query(Level).filter(Level.id == stat.level_id).first()
         if not level or level.skill_value < 0:
             continue
         level_skill_value = level.skill_value
-        ppg_ratio = stat.points_per_game_rank / stat.total_in_rank
-        games_played_ratio = stat.games_played_rank / stat.total_in_rank
-
-        # Take the maximum of the two ratios
-        skill_value = level_skill_value * max(ppg_ratio, games_played_ratio)
-        max_skill_value = max(max_skill_value, skill_value)
-
-    return max_skill_value
+        
+        # Fix critical bug: Invert rank ratios so better players (lower ranks) get higher skill values
+        # Rank 1 (best) should get factor close to 1.0, worst rank should get factor close to 0.0
+        if stat.total_in_rank > 1:
+            ppg_skill_factor = 1 - (stat.points_per_game_rank - 1) / (stat.total_in_rank - 1)
+        else:
+            ppg_skill_factor = 1.0  # Only one player in level
+        
+        # Apply skill adjustment: range from 0.8 to 1.2 of level base skill
+        # Since lower skill_value is better: Best player gets 0.8x (closer to better levels), worst gets 1.2x
+        skill_adjustment = 1.2 - 0.4 * ppg_skill_factor
+        skill_value = level_skill_value * skill_adjustment
+        
+        # Take the minimum skill value across all levels the player has played in (lower is better)
+        min_skill_value = min(min_skill_value, skill_value)
+
+    return min_skill_value if min_skill_value != float('inf') else 0
 
 def assign_skater_skill_values():
     session = create_session("boss")
 
     humans = session.query(Human).all()
     total_humans = len(humans)
-    processed_humans = 0
+    
+    # Create progress tracker
+    progress = create_progress_tracker(total_humans, "Assigning skater skill values")
 
-    for human in humans:
+    for i, human in enumerate(humans):
         level_stats = session.query(LevelStatsSkater).filter(LevelStatsSkater.human_id == human.id).all()
         if level_stats:
-            skater_skill_value = calculate_skater_skill_value(session, human.id, level_stats)
+            skater_skill_value = calculate_skater_skill_value(session, level_stats)
             human.skater_skill_value = skater_skill_value
             session.commit()
 
-        processed_humans += 1
-        print(f"\rProcessed {processed_humans}/{total_humans} humans ({(processed_humans/total_humans)*100:.2f}%)", end="")
+        progress.update(i + 1)
 
-    print("\nSkater skill values have been assigned to all humans.")
+    print("Skater skill values have been assigned to all humans.")
 
 if __name__ == "__main__":
     assign_skater_skill_values()

hockey_blast_common_lib/h2h_models.py

@@ -75,3 +75,33 @@ class H2HStatsMeta(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     last_run_timestamp = db.Column(db.DateTime, nullable=True)  # When the h2h stats were last updated
     last_processed_game_id = db.Column(db.Integer, nullable=True)  # Game.id of the latest processed game
+
+class SkaterToSkaterStats(db.Model):
+    __tablename__ = 'skater_to_skater_stats'
+    id = db.Column(db.Integer, primary_key=True)
+    skater1_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    skater2_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    __table_args__ = (
+        db.UniqueConstraint('skater1_id', 'skater2_id', name='_s2s_skater_pair_uc'),
+        db.Index('ix_s2s_skater_pair', 'skater1_id', 'skater2_id'),
+    )
+
+    # General stats
+    games_against = db.Column(db.Integer, default=0, nullable=False)
+    games_tied_against = db.Column(db.Integer, default=0, nullable=False)
+    skater1_wins_vs_skater2 = db.Column(db.Integer, default=0, nullable=False)
+    skater2_wins_vs_skater1 = db.Column(db.Integer, default=0, nullable=False)
+
+    # Cumulative stats
+    skater1_goals_against_skater2 = db.Column(db.Integer, default=0, nullable=False)
+    skater2_goals_against_skater1 = db.Column(db.Integer, default=0, nullable=False)
+    skater1_assists_against_skater2 = db.Column(db.Integer, default=0, nullable=False)
+    skater2_assists_against_skater1 = db.Column(db.Integer, default=0, nullable=False)
+    skater1_penalties_against_skater2 = db.Column(db.Integer, default=0, nullable=False)
+    skater2_penalties_against_skater1 = db.Column(db.Integer, default=0, nullable=False)
+
+class SkaterToSkaterStatsMeta(db.Model):
+    __tablename__ = 'skater_to_skater_stats_meta'
+    id = db.Column(db.Integer, primary_key=True)
+    last_run_timestamp = db.Column(db.DateTime, nullable=True)
+    last_processed_game_id = db.Column(db.Integer, nullable=True)

hockey_blast_common_lib/models.py

@@ -322,7 +322,11 @@ class Shootout(db.Model):
 class Team(db.Model):
     __tablename__ = 'teams'
     id = db.Column(db.Integer, primary_key=True)
-    name = db.Column(db.String(100), unique=True, nullable=False)
+    name = db.Column(db.String(100), nullable=False)
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    __table_args__ = (
+        db.UniqueConstraint('org_id', 'name', name='_org_team_name_uc'),
+    )
 
 class TeamDivision(db.Model):
     __tablename__ = 'teams_divisions'
@@ -351,6 +355,7 @@ class RequestLog(db.Model):
     path = db.Column(db.String, nullable=False)
     timestamp = db.Column(db.DateTime, nullable=False)
     cgi_params = db.Column(db.String, nullable=True)
+    response_time_ms = db.Column(db.Float, nullable=True)  # Response time in milliseconds
 
 # # MANUAL AMENDS HAPPEN HERE :)
 # from db_connection import create_session

hockey_blast_common_lib/progress_utils.py

@@ -0,0 +1,91 @@
+import time
+from datetime import datetime, timedelta
+
+class ProgressTracker:
+    """
+    Reusable progress tracker with ETA calculation for stats aggregation processes.
+    """
+    
+    def __init__(self, total_items, description="Processing"):
+        self.total_items = total_items
+        self.description = description
+        self.start_time = time.time()
+        self.processed_items = 0
+        self.last_update_time = self.start_time
+        
+    def update(self, processed_count=None):
+        """
+        Update progress. If processed_count is None, increment by 1.
+        """
+        if processed_count is not None:
+            self.processed_items = processed_count
+        else:
+            self.processed_items += 1
+            
+        current_time = time.time()
+        
+        # Only update display if at least 0.1 seconds have passed (to avoid spamming)
+        if current_time - self.last_update_time >= 0.1 or self.processed_items == self.total_items:
+            self._display_progress()
+            self.last_update_time = current_time
+            
+    def _display_progress(self):
+        """
+        Display progress with percentage, ETA, and elapsed time.
+        """
+        current_time = time.time()
+        elapsed_time = current_time - self.start_time
+        
+        if self.processed_items == 0:
+            percentage = 0.0
+            eta_str = "calculating..."
+        else:
+            percentage = (self.processed_items / self.total_items) * 100
+            
+            # Calculate ETA
+            if self.processed_items == self.total_items:
+                eta_str = "completed!"
+            else:
+                avg_time_per_item = elapsed_time / self.processed_items
+                remaining_items = self.total_items - self.processed_items
+                eta_seconds = avg_time_per_item * remaining_items
+                eta_str = self._format_time(eta_seconds)
+        
+        elapsed_str = self._format_time(elapsed_time)
+        
+        progress_msg = f"\r{self.description}: {self.processed_items}/{self.total_items} ({percentage:.1f}%) | "
+        progress_msg += f"Elapsed: {elapsed_str} | ETA: {eta_str}"
+        
+        print(progress_msg, end="", flush=True)
+        
+        # Add newline when complete
+        if self.processed_items == self.total_items:
+            print()  # Newline to finish the progress line
+    
+    def _format_time(self, seconds):
+        """
+        Format seconds into a human-readable string.
+        """
+        if seconds < 60:
+            return f"{seconds:.1f}s"
+        elif seconds < 3600:
+            minutes = int(seconds // 60)
+            secs = int(seconds % 60)
+            return f"{minutes}m {secs}s"
+        else:
+            hours = int(seconds // 3600)
+            minutes = int((seconds % 3600) // 60)
+            return f"{hours}h {minutes}m"
+    
+    def finish(self):
+        """
+        Mark progress as complete and add final newline.
+        """
+        self.processed_items = self.total_items
+        self._display_progress()
+
+def create_progress_tracker(total_items, description="Processing"):
+    """
+    Factory function to create a progress tracker.
+    """
+    return ProgressTracker(total_items, description)

hockey_blast_common_lib/skills_propagation.py

@@ -9,6 +9,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from hockey_blast_common_lib.models import Level, Division
 from hockey_blast_common_lib.stats_models import LevelsGraphEdge, LevelStatsSkater, SkillValuePPGRatio
 from hockey_blast_common_lib.db_connection import create_session
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
 from sqlalchemy import func
 
 import numpy as np
@@ -56,10 +57,11 @@ def reset_skill_values_in_divisions():
             # If no match found, check each alternative name individually
             skills = session.query(Level).filter(Level.org_id == division.org_id).all()
             for s in skills:
-                alternative_names = s.level_alternative_name.split(',')
-                if div_level in alternative_names:
-                    level = s
-                    break
+                if s.level_alternative_name:  # Check if not None
+                    alternative_names = s.level_alternative_name.split(',')
+                    if div_level in alternative_names:
+                        level = s
+                        break
 
         if level:
             # Assign the skill_value and set skill_propagation_sequence to 0
@@ -70,19 +72,30 @@ def reset_skill_values_in_divisions():
                 level.skill_propagation_sequence = -1
                 level.skill_value = -1
         else:
-            # Add new Skill with values previously used for division
-            new_level = Level(
-                org_id=division.org_id,
-                skill_value=-1,
-                level_name=division.level,
-                level_alternative_name='',
-                is_seed=False,
-                skill_propagation_sequence=-1
-            )
-            session.add(new_level)
-            session.commit()
-            division.skill_id = new_level.id
-            print(f"Created new Level for Division {division.level}")
+            # Check if level already exists with this org_id/level_name combination
+            existing_level = session.query(Level).filter(
+                Level.org_id == division.org_id,
+                Level.level_name == division.level
+            ).first()
+            
+            if existing_level:
+                # Use existing level
+                division.level_id = existing_level.id
+                print(f"Using existing Level for Division {division.level}")
+            else:
+                # Add new Skill with values previously used for division
+                new_level = Level(
+                    org_id=division.org_id,
+                    skill_value=-1,
+                    level_name=division.level,
+                    level_alternative_name='',
+                    is_seed=False,
+                    skill_propagation_sequence=-1
+                )
+                session.add(new_level)
+                session.commit()
+                division.level_id = new_level.id
+                print(f"Created new Level for Division {division.level}")
 
         # Commit the changes to the Division
         session.commit()
@@ -113,14 +126,20 @@ def build_levels_graph_edges():
     # Dictionary to store edges
     edges = {}
 
-    # Build edges
+    # Build edges - batch load all levels first for performance
+    all_level_ids = list(level_human_stats.keys())
+    levels_dict = {level.id: level for level in session.query(Level).filter(Level.id.in_(all_level_ids)).all()}
+    
     total_levels = len(level_human_stats)
+    progress = create_progress_tracker(total_levels, "Building level graph edges")
     processed_levels = 0
     for from_level_id, from_humans in level_human_stats.items():
-        from_level = session.query(Level).filter_by(id=from_level_id).first()
+        from_level = levels_dict.get(from_level_id)
+        if not from_level:
+            continue
         for to_level_id, to_humans in level_human_stats.items():
-            to_level = session.query(Level).filter_by(id=to_level_id).first()
-            if from_level.id >= to_level.id:
+            to_level = levels_dict.get(to_level_id)
+            if not to_level or from_level.id >= to_level.id:
                 continue
 
             common_humans = set(from_humans.keys()) & set(to_humans.keys())
@@ -171,7 +190,7 @@ def build_levels_graph_edges():
             edges[(from_level_id, to_level_id)] = edge
 
         processed_levels += 1
-        print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
+        progress.update(processed_levels)
 
     # Insert edges into the database
     for edge in edges.values():
@@ -313,12 +332,12 @@ def propagate_skill_levels(propagation_sequence):
                         # First confirm which way are we going here
                         if (ppg_ratio_edge < 1 and correlation.ppg_ratio > 1) or (ppg_ratio_edge > 1 and correlation.ppg_ratio < 1):
                             # Reverse the correlation
-                            from_skill_value=correlation.to_skill_value
-                            to_skill_value=correlation.from_skill_value
+                            from_skill_value = correlation.to_skill_value
+                            to_skill_value = correlation.from_skill_value
                             ppg_ratio_range = 1 / correlation.ppg_ratio
                         else:
-                            from_skill_value=correlation.from_skill_value
-                            to_skill_value=correlation.to_skill_value
+                            from_skill_value = correlation.from_skill_value
+                            to_skill_value = correlation.to_skill_value
                             ppg_ratio_range = correlation.ppg_ratio
 
                         # Now both ratios are either < 1 or > 1
@@ -345,6 +364,7 @@ def propagate_skill_levels(propagation_sequence):
                     suggested_skill_values[target_level_id].append(weighted_avg_skill_value)
 
     # Update skill values for target levels
+    session.flush()  # Ensure all previous changes are flushed before updates
     for target_level_id, skill_values in suggested_skill_values.items():
         skill_values = Config.discard_outliers(np.array(skill_values))
         if len(skill_values) > 0:
@@ -352,10 +372,16 @@ def propagate_skill_levels(propagation_sequence):
             avg_skill_value = max(avg_skill_value, 9.6)
             if avg_skill_value < min_skill_value:
                 avg_skill_value = min_skill_value - 0.01
-            session.query(Level).filter_by(id=target_level_id).update({
-                'skill_value': avg_skill_value,
-                'skill_propagation_sequence': propagation_sequence + 1
-            })
+            try:
+                session.query(Level).filter_by(id=target_level_id).update({
+                    'skill_value': avg_skill_value,
+                    'skill_propagation_sequence': propagation_sequence + 1
+                })
+                session.flush()  # Flush each update individually
+            except Exception as e:
+                print(f"Error updating level {target_level_id}: {e}")
+                session.rollback()
+                continue
     session.commit()
 
     print(f"Skill levels have been propagated for sequence {propagation_sequence}.")

hockey_blast_common_lib/stats_models.py

@@ -75,6 +75,10 @@ class BaseStatsSkater(db.Model):
     gm_penalties_per_game = db.Column(db.Float, default=0.0)
     gm_penalties_per_game_rank = db.Column(db.Integer, default=0)
     total_in_rank = db.Column(db.Integer, default=0)
+    current_point_streak = db.Column(db.Integer, default=0)
+    current_point_streak_rank = db.Column(db.Integer, default=0)
+    current_point_streak_avg_points = db.Column(db.Float, default=0.0)
+    current_point_streak_avg_points_rank = db.Column(db.Integer, default=0)
     first_game_id = db.Column(db.Integer, db.ForeignKey('games.id'))
     last_game_id = db.Column(db.Integer, db.ForeignKey('games.id'))
 
@@ -87,6 +91,8 @@ class BaseStatsSkater(db.Model):
             db.Index(f'idx_{cls.aggregation_type}_assists_per_game3', cls.get_aggregation_column(), 'assists_per_game'),
             db.Index(f'idx_{cls.aggregation_type}_penalties_per_game3', cls.get_aggregation_column(), 'penalties_per_game'),
             db.Index(f'idx_{cls.aggregation_type}_gm_penalties_per_game3', cls.get_aggregation_column(), 'gm_penalties_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_current_point_streak3', cls.get_aggregation_column(), 'current_point_streak'),
+            db.Index(f'idx_{cls.aggregation_type}_current_point_streak_avg_points3', cls.get_aggregation_column(), 'current_point_streak_avg_points'),
             db.Index(f'idx_{cls.aggregation_type}_games_played3', cls.get_aggregation_column(), 'games_played')
         )
 

{hockey_blast_common_lib-0.1.51.dist-info → hockey_blast_common_lib-0.1.54.dist-info}/METADATA

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

hockey_blast_common_lib-0.1.54.dist-info/RECORD

@@ -0,0 +1,27 @@
+hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hockey_blast_common_lib/aggregate_all_stats.py,sha256=2bOj2BW0k3ZPQR1NH04upnkIfO9SastzTz7XwO3ujYo,1104
+hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=0pJOT6nKgFYmSTWA3HY-BKARgc7l6czqvzWfwNQMad0,14346
+hockey_blast_common_lib/aggregate_h2h_stats.py,sha256=dC5TcJZGkpIQTiq3z40kOX6EjEhFbGv5EL0P1EClBQ0,11117
+hockey_blast_common_lib/aggregate_human_stats.py,sha256=ku42TAjUIj49822noM8fEeB8GS4vFeCCNrLupTWmqzg,26043
+hockey_blast_common_lib/aggregate_referee_stats.py,sha256=mUcTVQH9K4kwmIfgfGsnh_3AqX6Ia3RjfukkYuQas3I,13938
+hockey_blast_common_lib/aggregate_s2s_stats.py,sha256=urYN0Q06twwLO-XWGlSMVAVOTVR_D2AWdmoGsxIYHXE,6737
+hockey_blast_common_lib/aggregate_skater_stats.py,sha256=pA_2pDOGcJyEywISg2ySG8gFCuoLWwqw6a3Gm2wHLyo,23302
+hockey_blast_common_lib/assign_skater_skill.py,sha256=8gAiqQm14QMFJNmdKb2jjaGyQlhzvVhXrqVvaZ84KDM,2499
+hockey_blast_common_lib/db_connection.py,sha256=HvPxDvOj7j5H85RfslGvHVNevfg7mKCd0syJ6NX21mU,1890
+hockey_blast_common_lib/dump_sample_db.sh,sha256=MY3lnzTXBoWd76-ZlZr9nWsKMEVgyRsUn-LZ2d1JWZs,810
+hockey_blast_common_lib/h2h_models.py,sha256=0st4xoJO0U6ONfx3BV03BQvHjZE31e_PqZfphAJMoSU,7968
+hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=fzSnsPZVLF7RVGymJcXZPIragcHXnMwX-Levh9LY_ao,4648903
+hockey_blast_common_lib/models.py,sha256=aa5M1hF-IQ3XbDBgq_GK2pk-GcHtatH94ADEg7GAR7M,16734
+hockey_blast_common_lib/options.py,sha256=2L4J9rKCKr58om34259D3_s7kbPdknMSwoo6IwTNnx0,849
+hockey_blast_common_lib/progress_utils.py,sha256=H_zRFOsb2qQQpGw56wJghZ1nUe_m6zqGeR9hZ33Y1Uo,3229
+hockey_blast_common_lib/restore_sample_db.sh,sha256=7W3lzRZeu9zXIu1Bvtnaw8EHc1ulHmFM4mMh86oUQJo,2205
+hockey_blast_common_lib/skills_in_divisions.py,sha256=m-UEwMwn1KM7wOYvDstgsOEeH57M9V6yrkBoghzGYKE,7005
+hockey_blast_common_lib/skills_propagation.py,sha256=CYpnjcJit01-QxkvVstNx1DhUo5ljZB_-o31vGzPT-A,17668
+hockey_blast_common_lib/stats_models.py,sha256=uBNQSqCMXurzS-tD13OoV5WqurYYGHMZMHk1CeA5jgI,26104
+hockey_blast_common_lib/stats_utils.py,sha256=DXsPO4jw8XsdRUN46TGF_IiBAfz3GCIVBswCGp5ELDk,284
+hockey_blast_common_lib/utils.py,sha256=PduHp6HoI4sfr5HvJfQAaz7170dy5kTFVdIfWvBR-Jg,5874
+hockey_blast_common_lib/wsgi.py,sha256=y3NxoJfWjdzX3iP7RGvDEer6zcnPyCanpqSgW1BlXgg,779
+hockey_blast_common_lib-0.1.54.dist-info/METADATA,sha256=ApLUd6xFjG9PecXGI42K-4eyVYLrCbgGNtbccp3EOXY,318
+hockey_blast_common_lib-0.1.54.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.54.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.54.dist-info/RECORD,,

hockey_blast_common_lib-0.1.51.dist-info/RECORD

@@ -1,25 +0,0 @@
-hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hockey_blast_common_lib/aggregate_all_stats.py,sha256=2bOj2BW0k3ZPQR1NH04upnkIfO9SastzTz7XwO3ujYo,1104
-hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=_9lP5xNX_QcIge-sHbqIlt7mKcFJBGVBbr33Rtf3LAY,12365
-hockey_blast_common_lib/aggregate_h2h_stats.py,sha256=Hqhca_OyA9BwLOLU488RcPuZZgpAW0gx4G8EhD7Noy8,11166
-hockey_blast_common_lib/aggregate_human_stats.py,sha256=uBNzXbFsK5PhPg-5wjH2iuJ7VPpA7MWKFHx90rMbhjQ,24084
-hockey_blast_common_lib/aggregate_referee_stats.py,sha256=dSl0LEpCzyzpD_tv8yw07NLBImo2RP_xuUQZK_p5kFs,12189
-hockey_blast_common_lib/aggregate_skater_stats.py,sha256=MU4ICUUtDDKhdeb4sc0UPzjREwSB0rFZuJqRtIDedDU,17393
-hockey_blast_common_lib/assign_skater_skill.py,sha256=p-0fbodGpM8BCjKHDpxNb7BH2FcIlBsJwON844KNrUY,1817
-hockey_blast_common_lib/db_connection.py,sha256=HvPxDvOj7j5H85RfslGvHVNevfg7mKCd0syJ6NX21mU,1890
-hockey_blast_common_lib/dump_sample_db.sh,sha256=MY3lnzTXBoWd76-ZlZr9nWsKMEVgyRsUn-LZ2d1JWZs,810
-hockey_blast_common_lib/h2h_models.py,sha256=inB_QAm8Unkc0QRVibiw-Wf8yebNk8zhwxF9EZGMNKM,6350
-hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=6_atrXLDO31Qyc9CnangK-xywBHIAI3Ztvng-PZXe6U,4648905
-hockey_blast_common_lib/models.py,sha256=nbJjypa2OBO5_fwjAbWVgBp4WDCuE-RtaELzJ9cvqB4,16468
-hockey_blast_common_lib/options.py,sha256=2L4J9rKCKr58om34259D3_s7kbPdknMSwoo6IwTNnx0,849
-hockey_blast_common_lib/restore_sample_db.sh,sha256=7W3lzRZeu9zXIu1Bvtnaw8EHc1ulHmFM4mMh86oUQJo,2205
-hockey_blast_common_lib/skills_in_divisions.py,sha256=m-UEwMwn1KM7wOYvDstgsOEeH57M9V6yrkBoghzGYKE,7005
-hockey_blast_common_lib/skills_propagation.py,sha256=x6yy7fJ6IX3YiHqiP_v7-p_S2Expb8JJ-mWuajEFBdY,16388
-hockey_blast_common_lib/stats_models.py,sha256=NWigeIowIJU6o1Sk1cP08kEy4t594LZpecKUnl-O6as,25552
-hockey_blast_common_lib/stats_utils.py,sha256=DXsPO4jw8XsdRUN46TGF_IiBAfz3GCIVBswCGp5ELDk,284
-hockey_blast_common_lib/utils.py,sha256=PduHp6HoI4sfr5HvJfQAaz7170dy5kTFVdIfWvBR-Jg,5874
-hockey_blast_common_lib/wsgi.py,sha256=y3NxoJfWjdzX3iP7RGvDEer6zcnPyCanpqSgW1BlXgg,779
-hockey_blast_common_lib-0.1.51.dist-info/METADATA,sha256=wr1jHyXwbpWDlzqSguE3UWILsSlrcu3xgjwZ_IdoQ3A,318
-hockey_blast_common_lib-0.1.51.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.51.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.51.dist-info/RECORD,,