hockey-blast-common-lib 0.1.28__tar.gz → 0.1.31__tar.gz

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/PKG-INFO

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

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/hockey_blast_common_lib/aggregate_skater_stats.py

@@ -6,17 +6,28 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from datetime import datetime, timedelta
 import sqlalchemy
 
-from hockey_blast_common_lib.models import Game, Goal, Penalty, GameRoster
-from hockey_blast_common_lib.stats_models import OrgStatsSkater, DivisionStatsSkater, OrgStatsWeeklySkater, OrgStatsDailySkater, DivisionStatsWeeklySkater, DivisionStatsDailySkater
+from hockey_blast_common_lib.models import Game, Goal, Penalty, GameRoster, Organization, Division, Human, Level
+from hockey_blast_common_lib.stats_models import OrgStatsSkater, DivisionStatsSkater, OrgStatsWeeklySkater, OrgStatsDailySkater, DivisionStatsWeeklySkater, DivisionStatsDailySkater, LevelStatsSkater
 from hockey_blast_common_lib.db_connection import create_session
 from sqlalchemy.sql import func, case
-from hockey_blast_common_lib.options import not_human_names, parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS
-from hockey_blast_common_lib.utils import get_org_id_from_alias, get_human_ids_by_names, get_division_ids_for_last_season_in_all_leagues
+from hockey_blast_common_lib.options import not_human_names, parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS
+from hockey_blast_common_lib.utils import get_org_id_from_alias, get_human_ids_by_names, get_division_ids_for_last_season_in_all_leagues, get_all_division_ids_for_org
 from sqlalchemy import func, case, and_
+from collections import defaultdict
 
-def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_filter_out, filter_human_id=None, aggregation_window=None):
+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)
 
+    # Get the name of the aggregation, for debug purposes
+    if aggregation_type == 'org':
+        aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+    elif aggregation_type == 'division':
+        aggregation_name = session.query(Division).filter(Division.id == aggregation_id).first().level
+    elif aggregation_type == 'level':
+        aggregation_name = session.query(Level).filter(Level.id == aggregation_id).first().level_name
+    else:
+        aggregation_name = "Unknown"
+
     if aggregation_type == 'org':
         if aggregation_window == 'Daily':
             StatsModel = OrgStatsDailySkater
@@ -35,6 +46,14 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
             StatsModel = DivisionStatsSkater
         min_games = MIN_GAMES_FOR_DIVISION_STATS
         filter_condition = Game.division_id == aggregation_id
+    elif aggregation_type == 'level':
+        StatsModel = LevelStatsSkater
+        min_games = MIN_GAMES_FOR_LEVEL_STATS
+        filter_condition = Division.level_id == aggregation_id
+        # 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
+        # filter_condition = filter_condition & level_window_filter
     else:
         raise ValueError("Invalid aggregation type")
 
@@ -59,8 +78,8 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
 
     # Filter for specific human_id if provided
     human_filter = []
-    if filter_human_id:
-        human_filter = [GameRoster.human_id == filter_human_id]
+    # if debug_human_id:
+    #     human_filter = [GameRoster.human_id == debug_human_id]
 
     # Aggregate games played for each human in each division, excluding goalies
     games_played_stats = session.query(
@@ -68,7 +87,7 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         GameRoster.human_id,
         func.count(Game.id).label('games_played'),
         func.array_agg(Game.id).label('game_ids')
-    ).join(GameRoster, Game.id == GameRoster.game_id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, GameRoster.human_id).all()
+    ).join(GameRoster, Game.id == GameRoster.game_id).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, GameRoster.human_id).all()
 
     # Aggregate goals for each human in each division, excluding goalies
     goals_stats = session.query(
@@ -76,7 +95,7 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         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)).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, 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)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, Goal.goal_scorer_id).all()
 
     # Aggregate assists for each human in each division, excluding goalies
     assists_stats = session.query(
@@ -84,14 +103,14 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         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)).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, Goal.assist_1_id).all()
+    ).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(Game.org_id, Goal.assist_1_id).all()
 
     assists_stats_2 = session.query(
         Game.org_id,
         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)).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, 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)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, Goal.assist_2_id).all()
 
     # Aggregate penalties for each human in each division, excluding goalies
     penalties_stats = session.query(
@@ -99,7 +118,7 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         Penalty.penalized_player_id.label('human_id'),
         func.count(Penalty.id).label('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)).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, 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)).join(Division, Game.division_id == Division.id).filter(filter_condition, ~GameRoster.role.ilike('g'), *human_filter).group_by(Game.org_id, Penalty.penalized_player_id).all()
 
     # Combine the results
     stats_dict = {}
@@ -107,6 +126,8 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         if stat.human_id in human_ids_to_filter:
             continue
         key = (aggregation_id, stat.human_id)
+        if stat.games_played < min_games:
+            continue
         stats_dict[key] = {
             'games_played': stat.games_played,
             'goals': 0,
@@ -123,94 +144,26 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         }
 
     for stat in goals_stats:
-        if stat.human_id in human_ids_to_filter:
-            continue
         key = (aggregation_id, stat.human_id)
-        if key not in stats_dict:
-            stats_dict[key] = {
-                'games_played': 0,
-                'goals': stat.goals,
-                'assists': 0,
-                'penalties': 0,
-                'points': stat.goals,  # Initialize points with goals
-                'goals_per_game': 0.0,
-                'points_per_game': 0.0,
-                'assists_per_game': 0.0,
-                'penalties_per_game': 0.0,
-                'game_ids': [],
-                'first_game_id': None,
-                'last_game_id': None
-            }
-        else:
+        if key in stats_dict:
             stats_dict[key]['goals'] += stat.goals
             stats_dict[key]['points'] += stat.goals  # Update points
 
     for stat in assists_stats:
-        if stat.human_id in human_ids_to_filter:
-            continue
         key = (aggregation_id, stat.human_id)
-        if key not in stats_dict:
-            stats_dict[key] = {
-                'games_played': 0,
-                'goals': 0,
-                'assists': stat.assists,
-                'penalties': 0,
-                'points': stat.assists,  # Initialize points with assists
-                'goals_per_game': 0.0,
-                'points_per_game': 0.0,
-                'assists_per_game': 0.0,
-                'penalties_per_game': 0.0,
-                'game_ids': [],
-                'first_game_id': None,
-                'last_game_id': None
-            }
-        else:
+        if key in stats_dict:
             stats_dict[key]['assists'] += stat.assists
             stats_dict[key]['points'] += stat.assists  # Update points
 
     for stat in assists_stats_2:
-        if stat.human_id in human_ids_to_filter:
-            continue
         key = (aggregation_id, stat.human_id)
-        if key not in stats_dict:
-            stats_dict[key] = {
-                'games_played': 0,
-                'goals': 0,
-                'assists': stat.assists,
-                'penalties': 0,
-                'points': stat.assists,  # Initialize points with assists
-                'goals_per_game': 0.0,
-                'points_per_game': 0.0,
-                'assists_per_game': 0.0,
-                'penalties_per_game': 0.0,
-                'game_ids': [],
-                'first_game_id': None,
-                'last_game_id': None
-            }
-        else:
+        if key in stats_dict:
             stats_dict[key]['assists'] += stat.assists
             stats_dict[key]['points'] += stat.assists  # Update points
 
     for stat in penalties_stats:
-        if stat.human_id in human_ids_to_filter:
-            continue
         key = (aggregation_id, stat.human_id)
-        if key not in stats_dict:
-            stats_dict[key] = {
-                'games_played': 0,
-                'goals': 0,
-                'assists': 0,
-                'penalties': stat.penalties,
-                'points': 0,  # Initialize points
-                'goals_per_game': 0.0,
-                'points_per_game': 0.0,
-                'assists_per_game': 0.0,
-                'penalties_per_game': 0.0,
-                'game_ids': [],
-                'first_game_id': None,
-                'last_game_id': None
-            }
-        else:
+        if key in stats_dict:
             stats_dict[key]['penalties'] += stat.penalties
 
     # Calculate per game stats
@@ -233,20 +186,10 @@ 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
 
-    # Debug output for totals if filter_human_id is provided
-    if filter_human_id:
-        for key, stat in stats_dict.items():
-            if key[1] == filter_human_id:
-                print(f"Human ID: {filter_human_id}")
-                print(f"Total Games Played: {stat['games_played']}")
-                print(f"Total Goals: {stat['goals']}")
-                print(f"Total Assists: {stat['assists']}")
-                print(f"Total Penalties: {stat['penalties']}")
-
     # Calculate total_in_rank
     total_in_rank = len(stats_dict)
 
-    # Assign ranks
+    # Assign ranks within each level
     def assign_ranks(stats_dict, field):
         sorted_stats = sorted(stats_dict.items(), key=lambda x: x[1][field], reverse=True)
         for rank, (key, stat) in enumerate(sorted_stats, start=1):
@@ -262,13 +205,22 @@ 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')
 
+    # Debug output for specific human
+    if debug_human_id:
+        if any(key[1] == debug_human_id for key in stats_dict):
+            human = session.query(Human).filter(Human.id == debug_human_id).first()
+            human_name = f"{human.first_name} {human.last_name}" if human else "Unknown"
+            print(f"For Human {debug_human_id} ({human_name}) for {aggregation_type} {aggregation_id} ({aggregation_name}) , total_in_rank {total_in_rank} and window {aggregation_window}:")
+            for key, stat in stats_dict.items():
+                if key[1] == debug_human_id:
+                    for k, v in stat.items():
+                        print(f"{k}: {v}")
+
     # Insert aggregated stats into the appropriate table with progress output
     total_items = len(stats_dict)
     batch_size = 1000
     for i, (key, stat) in enumerate(stats_dict.items(), 1):
         aggregation_id, human_id = key
-        if stat['games_played'] < min_games:
-            continue
         goals_per_game = stat['goals'] / stat['games_played'] if stat['games_played'] > 0 else 0.0
         points_per_game = (stat['goals'] + stat['assists']) / stat['games_played'] if stat['games_played'] > 0 else 0.0
         assists_per_game = stat['assists'] / stat['games_played'] if stat['games_played'] > 0 else 0.0
@@ -302,25 +254,47 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         # Commit in batches
         if i % batch_size == 0:
             session.commit()
-            print(f"\r{i}/{total_items} ({(i/total_items)*100:.2f}%)", end="")
+            if debug_human_id is None:
+                print(f"\r{i}/{total_items} ({(i/total_items)*100:.2f}%)", end="")
+            
     session.commit()
-    print(f"\r{total_items}/{total_items} (100.00%)")
-    print("\nDone.")
+    if debug_human_id is None:
+        print(f"\r{total_items}/{total_items} (100.00%)")
 
-# Example usage
 if __name__ == "__main__":
-    args = parse_args()
-    org_alias = args.org
     session = create_session("boss")
-    org_id = get_org_id_from_alias(session, org_alias)
+    human_id_to_debug = 117076
 
-    division_ids = get_division_ids_for_last_season_in_all_leagues(session, org_id)
-    print(f"Aggregating skater stats for {len(division_ids)} divisions in {org_alias}...")
-    for division_id in division_ids:
-        aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, filter_human_id=None)
-        aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, filter_human_id=None, aggregation_window='Weekly')
-        aggregate_skater_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, filter_human_id=None, aggregation_window='Daily')
+    # Get all org_id present in the Organization table
+    org_ids = session.query(Organization.id).all()
+    org_ids = [org_id[0] for org_id in org_ids]
 
-    aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, filter_human_id=None)
-    aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, filter_human_id=None, aggregation_window='Weekly')
-    aggregate_skater_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, filter_human_id=None, aggregation_window='Daily')
+    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')
+        
+        # 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)

hockey_blast_common_lib-0.1.31/hockey_blast_common_lib/assign_skater_skill.py

@@ -0,0 +1,46 @@
+import sys, os
+
+# 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 Human, LevelStatsSkater
+from hockey_blast_common_lib.db_connection import create_session
+from sqlalchemy.sql import func
+
+def calculate_skater_skill_value(human_id, level_stats):
+    max_skill_value = 0
+
+    for stat in level_stats:
+        level_skill_value = stat.level.skill_value
+        if level_skill_value < 0:
+            continue
+        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
+
+def assign_skater_skill_values():
+    session = create_session("boss")
+
+    humans = session.query(Human).all()
+    total_humans = len(humans)
+    processed_humans = 0
+
+    for human in humans:
+        level_stats = session.query(LevelStatsSkater).filter(LevelStatsSkater.human_id == human.id).all()
+        if level_stats:
+            skater_skill_value = calculate_skater_skill_value(human.id, 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="")
+
+    print("\nSkater skill values have been assigned to all humans.")
+
+if __name__ == "__main__":
+    assign_skater_skill_values()

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/hockey_blast_common_lib/models.py

@@ -18,9 +18,8 @@ class Division(db.Model):
     league_number = db.Column(db.Integer) # TODO: Deprecate usage and remove (get this info through Season->League)
     season_number = db.Column(db.Integer) # TODO: Deprecate usage and remove (get this info from Season by season_id)
     season_id = db.Column(db.Integer, db.ForeignKey('seasons.id'))
-    level = db.Column(db.String(100))
-    skill_value = db.Column(db.Float)
-    skill_propagation_sequence = db.Column(db.Integer, nullable=True, default=-1)
+    level = db.Column(db.String(100)) # Obsolete, use skill_id instead
+    level_id = db.Column(db.Integer, db.ForeignKey('levels.id')) # New field
     org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
     __table_args__ = (
         db.UniqueConstraint('org_id', 'league_number', 'season_number', 'level', name='_org_league_season_level_uc'),
@@ -154,14 +153,15 @@ class League(db.Model):
         db.UniqueConstraint('org_id', 'league_number', name='_org_league_number_uc'),
     )
 
-class Skill(db.Model):
-    __tablename__ = 'skills'
+class Level(db.Model):
+    __tablename__ = 'levels'
     id = db.Column(db.Integer, primary_key=True)
     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), unique=True)
     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)
     __table_args__ = (
         db.UniqueConstraint('org_id', 'level_name', name='_org_level_name_uc'),
     )

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/hockey_blast_common_lib/options.py

@@ -4,6 +4,7 @@ MAX_HUMAN_SEARCH_RESULTS = 25
 MAX_TEAM_SEARCH_RESULTS = 25
 MIN_GAMES_FOR_ORG_STATS = 1
 MIN_GAMES_FOR_DIVISION_STATS = 1
+MIN_GAMES_FOR_LEVEL_STATS = 20
 
 orgs = {'caha', 'sharksice', 'tvice'}
 

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/hockey_blast_common_lib/skills_in_divisions.py

@@ -5,7 +5,7 @@ from collections import defaultdict
 # Add the project root 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, Division, Skill, Season, League
+from hockey_blast_common_lib.models import Game, Division, Level, Season, League
 from hockey_blast_common_lib.db_connection import create_session
 
 def analyze_levels(org):
@@ -47,65 +47,27 @@ def analyze_levels(org):
 
     session.close()
 
-def reset_skill_values_in_divisions():
-    session = create_session("boss")
-
-    # Fetch all records from the Division table
-    divisions = session.query(Division).all()
-
-    for division in divisions:
-        # Look up the Skill table using the level from Division
-        div_level = division.level
-
-        # Query to find the matching Skill
-        skill = session.query(Skill).filter(Skill.org_id == division.org_id, Skill.level_name == div_level).one_or_none()
-
-        if not skill:
-            # If no match found, check each alternative name individually
-            skills = session.query(Skill).filter(Skill.org_id == division.org_id).all()
-            for s in skills:
-                alternative_names = s.level_alternative_name.split(',')
-                if div_level in alternative_names:
-                    skill = s
-                    break
-
-        if skill:
-            # Assign the skill_value and set skill_propagation_sequence to 0
-            division.skill_value = skill.skill_value
-            division.skill_propagation_sequence = 0
-            print(f"Assigned Skill {skill.skill_value} for Division with name {division.level}")
-        else:
-            # Assign -1 to skill_value and skill_propagation_sequence
-            division.skill_value = -1
-            division.skill_propagation_sequence = -1
-            print(f"No matching Skill found for Division with name {division.level}, assigned default values")
-
-        # Commit the changes to the Division
-        session.commit()
-
-    print("Skill values and propagation sequences have been populated into the Division table.")
-
 def fill_seed_skills():
     session = create_session("boss")
 
     # List of Skill objects based on the provided comments
     skills = [
-        Skill(is_seed=True, org_id=1, skill_value=10.0, level_name='Adult Division 1', level_alternative_name='Senior A'),
-        Skill(is_seed=True, org_id=1, skill_value=20.0, level_name='Adult Division 2', level_alternative_name='Senior B'),
-        Skill(is_seed=True, org_id=1, skill_value=30.0, level_name='Adult Division 3A', level_alternative_name='Senior BB'),
-        Skill(is_seed=True, org_id=1, skill_value=35.0, level_name='Adult Division 3B', level_alternative_name='Senior C'),
-        Skill(is_seed=True, org_id=1, skill_value=40.0, level_name='Adult Division 4A', level_alternative_name='Senior CC'),
-        Skill(is_seed=True, org_id=1, skill_value=45.0, level_name='Adult Division 4B', level_alternative_name='Senior CCC,Senior CCCC'),
-        Skill(is_seed=True, org_id=1, skill_value=50.0, level_name='Adult Division 5A', level_alternative_name='Senior D,Senior DD'),
-        Skill(is_seed=True, org_id=1, skill_value=55.0, level_name='Adult Division 5B', level_alternative_name='Senior DDD'),
-        Skill(is_seed=True, org_id=1, skill_value=60.0, level_name='Adult Division 6A', level_alternative_name='Senior DDDD'),
-        Skill(is_seed=True, org_id=1, skill_value=65.0, level_name='Adult Division 6B', level_alternative_name='Senior DDDDD'),
-        Skill(is_seed=True, org_id=1, skill_value=70.0, level_name='Adult Division 7A', level_alternative_name='Senior E'),
-        Skill(is_seed=True, org_id=1, skill_value=75.0, level_name='Adult Division 7B', level_alternative_name='Senior EE'),
-        Skill(is_seed=True, org_id=1, skill_value=80.0, level_name='Adult Division 8', level_alternative_name='Senior EEE'),
-        Skill(is_seed=True, org_id=1, skill_value=80.0, level_name='Adult Division 8A', level_alternative_name='Senior EEE'),
-        Skill(is_seed=True, org_id=1, skill_value=85.0, level_name='Adult Division 8B', level_alternative_name='Senior EEEE'),
-        Skill(is_seed=True, org_id=1, skill_value=90.0, level_name='Adult Division 9', level_alternative_name='Senior EEEEE')
+        Level(is_seed=True, org_id=1, skill_value=10.0, level_name='Adult Division 1', level_alternative_name='Senior A'),
+        Level(is_seed=True, org_id=1, skill_value=20.0, level_name='Adult Division 2', level_alternative_name='Senior B'),
+        Level(is_seed=True, org_id=1, skill_value=30.0, level_name='Adult Division 3A', level_alternative_name='Senior BB'),
+        Level(is_seed=True, org_id=1, skill_value=35.0, level_name='Adult Division 3B', level_alternative_name='Senior C'),
+        Level(is_seed=True, org_id=1, skill_value=40.0, level_name='Adult Division 4A', level_alternative_name='Senior CC'),
+        Level(is_seed=True, org_id=1, skill_value=45.0, level_name='Adult Division 4B', level_alternative_name='Senior CCC,Senior CCCC'),
+        Level(is_seed=True, org_id=1, skill_value=50.0, level_name='Adult Division 5A', level_alternative_name='Senior D,Senior DD'),
+        Level(is_seed=True, org_id=1, skill_value=55.0, level_name='Adult Division 5B', level_alternative_name='Senior DDD'),
+        Level(is_seed=True, org_id=1, skill_value=60.0, level_name='Adult Division 6A', level_alternative_name='Senior DDDD'),
+        Level(is_seed=True, org_id=1, skill_value=65.0, level_name='Adult Division 6B', level_alternative_name='Senior DDDDD'),
+        Level(is_seed=True, org_id=1, skill_value=70.0, level_name='Adult Division 7A', level_alternative_name='Senior E'),
+        Level(is_seed=True, org_id=1, skill_value=75.0, level_name='Adult Division 7B', level_alternative_name='Senior EE'),
+        Level(is_seed=True, org_id=1, skill_value=80.0, level_name='Adult Division 8', level_alternative_name='Senior EEE'),
+        Level(is_seed=True, org_id=1, skill_value=80.0, level_name='Adult Division 8A', level_alternative_name='Senior EEE'),
+        Level(is_seed=True, org_id=1, skill_value=85.0, level_name='Adult Division 8B', level_alternative_name='Senior EEEE'),
+        Level(is_seed=True, org_id=1, skill_value=90.0, level_name='Adult Division 9', level_alternative_name='Senior EEEEE')
     ]
 
     for skill in skills:
@@ -116,9 +78,9 @@ def fill_seed_skills():
 
 def get_fake_skill(session):
     # Create a special fake Skill with org_id == -1 and skill_value == -1
-    fake_skill = session.query(Skill).filter_by(org_id=1, level_name='Fake Skill').first()
+    fake_skill = session.query(Level).filter_by(org_id=1, level_name='Fake Skill').first()
     if not fake_skill:
-        fake_skill = Skill(
+        fake_skill = Level(
             org_id=1,
             skill_value=-1,
             level_name='Fake Skill',
@@ -143,7 +105,7 @@ def delete_all_skills():
     fake_skill = get_fake_skill(session)
     assign_fake_skill_to_divisions(session, fake_skill)
     # Delete all Skill records except the fake skill
-    session.query(Skill).filter(Skill.id != fake_skill.id).delete(synchronize_session=False)
+    session.query(Level).filter(Level.id != fake_skill.id).delete(synchronize_session=False)
     session.commit()
     print("All Skill records except the fake skill have been deleted.")
 
@@ -177,7 +139,7 @@ def populate_league_ids():
 
 if __name__ == "__main__":
     # delete_all_skills()
-    # fill_seed_skills()
+    #fill_seed_skills()
     reset_skill_values_in_divisions()
     #populate_season_ids()  # Call the function to populate season_ids
     #populate_league_ids()  # Call the new function to populate league_ids

hockey_blast_common_lib-0.1.31/hockey_blast_common_lib/skills_propagation.py

@@ -0,0 +1,368 @@
+import sys
+import os
+from collections import defaultdict
+import numpy as np
+
+# Add the project root 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 Level, Division
+from hockey_blast_common_lib.stats_models import LevelsGraphEdge, LevelStatsSkater, SkillValuePPGRatio
+from hockey_blast_common_lib.db_connection import create_session
+from sqlalchemy import func
+
+import numpy as np
+
+class Config:
+    MIN_GAMES_PLAYED_FOR_EDGE = 10
+    MIN_PPG_FOR_EDGE = 0.5
+    MIN_HUMANS_FOR_EDGE = 2
+    MAX_PROPAGATION_SEQUENCE = 4
+    MIN_CONNECTIONS_FOR_CORRELATION = 20
+    MIN_CONNECTIONS_FOR_PROPAGATION = 5
+    MAX_SKILL_DIFF_IN_EDGE = 30
+
+    @staticmethod
+    def discard_outliers(data, m=2):
+        """
+        Discard outliers from the data using the modified Z-score method.
+        :param data: List of data points
+        :param m: Threshold for the modified Z-score
+        :return: List of data points with outliers removed
+        """
+        if len(data) == 0:
+            return data
+        median = np.median(data)
+        diff = np.abs(data - median)
+        med_abs_deviation = np.median(diff)
+        if med_abs_deviation == 0:
+            return data
+        modified_z_score = 0.6745 * diff / med_abs_deviation
+        return data[modified_z_score < m]
+
+def reset_skill_values_in_divisions():
+    session = create_session("boss")
+
+    # Fetch all records from the Division table
+    divisions = session.query(Division).all()
+
+    for division in divisions:
+        # Look up the Skill table using the level from Division
+        div_level = division.level
+        # Query to find the matching Skill
+        level = session.query(Level).filter(Level.org_id == division.org_id, Level.level_name == div_level).one_or_none()
+
+        if not level:
+            # 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 level:
+            # Assign the skill_value and set skill_propagation_sequence to 0
+            division.level_id = level.id
+            if level.is_seed:
+                level.skill_propagation_sequence = 0
+            else:
+                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}")
+
+        # Commit the changes to the Division
+        session.commit()
+
+    print("Level values and propagation sequences have been populated into the Division table.")
+
+def build_levels_graph_edges():
+    # Creates unique edges from levelA to levelB (there is no reverse edge levelB to levelA)
+    session = create_session("boss")
+
+    # Delete all existing edges
+    session.query(LevelsGraphEdge).delete()
+    session.commit()
+
+    # Query to get all level stats
+    level_stats = session.query(LevelStatsSkater).all()
+
+    # Dictionary to store stats by level and human
+    level_human_stats = defaultdict(lambda: defaultdict(dict))
+
+    for stat in level_stats:
+        if stat.games_played >= Config.MIN_GAMES_PLAYED_FOR_EDGE and stat.points_per_game >= Config.MIN_PPG_FOR_EDGE:
+            level_human_stats[stat.level_id][stat.human_id] = {
+                'games_played': stat.games_played,
+                'points_per_game': stat.points_per_game
+            }
+
+    # Dictionary to store edges
+    edges = {}
+
+    # Build edges
+    total_levels = len(level_human_stats)
+    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()
+        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:
+                continue
+
+            common_humans = set(from_humans.keys()) & set(to_humans.keys())
+            n_connections = len(common_humans)
+            n_games = 0
+
+            if n_connections < Config.MIN_HUMANS_FOR_EDGE:
+                continue
+
+            ppg_ratios = []
+            # if from_level.id == 223 and to_level.id == 219: #216
+            #     print(f"Debug: From Level ID: {from_level.id}, To Level ID: {to_level.id}")
+            for human_id in common_humans:
+                from_ppg = from_humans[human_id]['points_per_game']
+                to_ppg = to_humans[human_id]['points_per_game']
+                from_games = from_humans[human_id]['games_played']
+                to_games = to_humans[human_id]['games_played']
+                min_games = min(from_games, to_games)
+                n_games += min_games
+
+                # if from_level.id == 223 and to_level.id == 219: #216
+                #     print(f"Human {human_id} From PPG: {from_ppg}, To PPG: {to_ppg}, Min Games: {min_games} n_games: {n_games}")
+
+                if from_ppg > 0 and to_ppg > 0:
+                    ppg_ratios.append(to_ppg / from_ppg)
+
+            if not ppg_ratios:
+                continue
+
+            # Discard outliers
+            ppg_ratios = Config.discard_outliers(np.array(ppg_ratios))
+
+            if len(ppg_ratios) == 0:
+                continue
+
+            avg_ppg_ratio = float(sum(ppg_ratios) / len(ppg_ratios))
+
+            # if sorted([from_level.id, to_level.id]) == [219, 223]:
+            #     print(f"From {from_level_id} to {to_level_id} n_connections {n_connections} n_games: {n_games}")
+
+            edge = LevelsGraphEdge(
+                from_level_id=from_level_id,
+                to_level_id=to_level_id,
+                n_connections=n_connections,
+                ppg_ratio=avg_ppg_ratio,
+                n_games=n_games  # Store the number of games
+            )
+            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="")
+
+    # Insert edges into the database
+    for edge in edges.values():
+        session.add(edge)
+    session.commit()
+
+    print("\nLevels graph edges have been populated into the database.")
+
+def propagate_skill_levels(propagation_sequence):
+    min_skill_value = float('inf')
+    max_skill_value = float('-inf')
+
+    session = create_session("boss")
+
+    if propagation_sequence == 0:
+        # Delete all existing correlation data
+        session.query(SkillValuePPGRatio).delete()
+        session.commit()
+
+        # Build and save the correlation data
+        levels = session.query(Level).filter(Level.skill_propagation_sequence == 0).all()
+        level_ids = {level.id for level in levels}
+        correlation_data = defaultdict(list)
+
+        for level in levels:
+            if level.skill_value == -1:
+                continue
+
+            edges = session.query(LevelsGraphEdge).filter(
+                (LevelsGraphEdge.from_level_id == level.id) |
+                (LevelsGraphEdge.to_level_id == level.id)
+            ).all()
+
+            for edge in edges:
+                if edge.n_connections < Config.MIN_CONNECTIONS_FOR_CORRELATION:
+                    continue
+
+                if edge.from_level_id == level.id:
+                    target_level_id = edge.to_level_id
+                    ppg_ratio_edge = edge.ppg_ratio
+                else:
+                    # We go over same edge twice in this logic, let's skip the reverse edge
+                    continue
+
+                if target_level_id not in level_ids:
+                    continue
+
+                target_level = session.query(Level).filter_by(id=target_level_id).first()
+                if target_level:
+                    skill_value_from = level.skill_value
+                    skill_value_to = target_level.skill_value
+
+                    # Same skill value - no correlation
+                    if skill_value_from == skill_value_to:
+                        continue
+
+
+                    # Since we go over all levels in the sequence 0, we will see each edge twice
+                    # This condition eliminates duplicates
+                    if abs(skill_value_from - skill_value_to) > Config.MAX_SKILL_DIFF_IN_EDGE:
+                        continue
+
+                    # Debug prints
+                    # print(f"From Skill  {level.skill_value} to {target_level.skill_value} ratio: {ppg_ratio}")
+
+                    # Ensure INCREASING SKILL VALUES for the correlation data!
+                    if skill_value_from > skill_value_to:
+                        skill_value_from, skill_value_to = skill_value_to, skill_value_from
+                        ppg_ratio_edge = 1 / ppg_ratio_edge
+
+                    correlation_data[(skill_value_from, skill_value_to)].append(
+                        (ppg_ratio_edge, edge.n_games)
+                    )
+
+        # Save correlation data to the database
+        for (skill_value_from, skill_value_to), ppg_ratios in correlation_data.items():
+            ppg_ratios = [(ppg_ratio, n_games) for ppg_ratio, n_games in ppg_ratios]
+            ppg_ratios_array = np.array(ppg_ratios, dtype=[('ppg_ratio', float), ('n_games', int)])
+            ppg_ratios_filtered = Config.discard_outliers(ppg_ratios_array['ppg_ratio'])
+            if len(ppg_ratios_filtered) > 0:
+                avg_ppg_ratio = float(sum(ppg_ratio * n_games for ppg_ratio, n_games in ppg_ratios if ppg_ratio in ppg_ratios_filtered) / sum(n_games for ppg_ratio, n_games in ppg_ratios if ppg_ratio in ppg_ratios_filtered))
+                total_n_games = sum(n_games for ppg_ratio, n_games in ppg_ratios if ppg_ratio in ppg_ratios_filtered)
+                correlation = SkillValuePPGRatio(
+                    from_skill_value=skill_value_from,
+                    to_skill_value=skill_value_to,
+                    ppg_ratio=avg_ppg_ratio,
+                    n_games=total_n_games  # Store the sum of games
+                )
+                session.add(correlation)
+                session.commit()
+                # Update min and max skill values
+                min_skill_value = min(min_skill_value, skill_value_from, skill_value_to)
+                max_skill_value = max(max_skill_value, skill_value_from, skill_value_to)
+
+    # Propagate skill levels
+    levels = session.query(Level).filter(Level.skill_propagation_sequence == propagation_sequence).all()
+    suggested_skill_values = defaultdict(list)
+
+    for level in levels:
+        edges = session.query(LevelsGraphEdge).filter(
+            (LevelsGraphEdge.from_level_id == level.id) |
+            (LevelsGraphEdge.to_level_id == level.id)
+        ).all()
+
+        for edge in edges:
+            if edge.n_connections < Config.MIN_CONNECTIONS_FOR_PROPAGATION:
+                continue
+
+            if edge.from_level_id == level.id:
+                target_level_id = edge.to_level_id
+                ppg_ratio_edge = edge.ppg_ratio
+            else:
+                target_level_id = edge.from_level_id
+                ppg_ratio_edge = 1 / edge.ppg_ratio
+
+            target_level = session.query(Level).filter_by(id=target_level_id).first()
+            if target_level and target_level.skill_propagation_sequence == -1:
+                correlations = session.query(SkillValuePPGRatio).filter(
+                    (SkillValuePPGRatio.from_skill_value <= level.skill_value) &
+                    (SkillValuePPGRatio.to_skill_value >= level.skill_value)
+                ).all()
+
+                if correlations:
+                    weighted_skill_values = []
+                    for correlation in correlations:
+                        # Skill value always increases in the correlation data
+                        # Let's avoid extrapolating from the end of the edge and away from the edge!
+
+                        # Check left side of the edge
+                        if (level.skill_value == correlation.from_skill_value and level.skill_value > min_skill_value):
+                            if ppg_ratio_edge < 1:
+                                continue
+                        # Check right side of the edge
+                        if (level.skill_value == correlation.to_skill_value and level.skill_value < max_skill_value):
+                            if ppg_ratio_edge > 1:
+                                continue
+
+                        
+                        # 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
+                            ppg_ratio_range = 1 / correlation.ppg_ratio
+                        else:
+                            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
+                        if ppg_ratio_edge < 1:
+                            ppg_ratio_for_extrapolation = 1 / ppg_ratio_edge
+                            ppg_ratio_range = 1 / ppg_ratio_range
+                        else:
+                            ppg_ratio_for_extrapolation = ppg_ratio_edge
+                        
+                        # Interpolate or extrapolate skill value
+                        skill_value_range = to_skill_value - from_skill_value
+                        skill_value_diff = (ppg_ratio_for_extrapolation / ppg_ratio_range) * skill_value_range
+                        new_skill_value = level.skill_value + skill_value_diff
+                        weighted_skill_values.append((new_skill_value, correlation.n_games))
+                        # if target_level.id == 229:
+                        #     print(f"Debug: From Level ID: {level.id}, To Level ID: {target_level.id}")
+                        #     print(f"Debug: From Skill Value: {level.skill_value} PPG Ratio: {ppg_ratio_for_extrapolation}, PPG Ratio Range: {ppg_ratio_range}")
+                        #     print(f"Debug: Skill Value Range: {skill_value_range}, Skill Value Diff: {skill_value_diff}")
+                        #     print(f"Debug: New Skill Value: {new_skill_value}")
+
+                    # Calculate weighted average of new skill values
+                    total_n_games = sum(n_games for _, n_games in weighted_skill_values)
+                    weighted_avg_skill_value = sum(skill_value * n_games for skill_value, n_games in weighted_skill_values) / total_n_games
+                    suggested_skill_values[target_level_id].append(weighted_avg_skill_value)
+
+    # Update skill values for target levels
+    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:
+            avg_skill_value = float(sum(skill_values) / len(skill_values))
+            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
+            })
+    session.commit()
+
+    print(f"Skill levels have been propagated for sequence {propagation_sequence}.")
+
+if __name__ == "__main__":
+    reset_skill_values_in_divisions()
+    build_levels_graph_edges()
+
+    for sequence in range(Config.MAX_PROPAGATION_SEQUENCE + 1):
+        propagate_skill_levels(sequence)

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/hockey_blast_common_lib/stats_models.py

@@ -222,6 +222,20 @@ class DivisionStatsSkater(BaseStatsSkater):
     def get_aggregation_column(cls):
         return 'division_id'
 
+class LevelStatsSkater(BaseStatsSkater):
+    __tablename__ = 'level_stats_skater'
+    level_id = db.Column(db.Integer, db.ForeignKey('levels.id'), nullable=False)
+    aggregation_id = synonym('level_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'level'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'level_id'
+
+
 class OrgStatsGoalie(BaseStatsGoalie):
     __tablename__ = 'org_stats_goalie'
     org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
@@ -561,3 +575,40 @@ class DivisionStatsWeeklyScorekeeper(BaseStatsScorekeeper):
     @classmethod
     def get_aggregation_column(cls):
         return 'division_id'
+
+class LevelsGraphEdge(db.Model):
+    __tablename__ = 'levels_graph_edges'
+    id = db.Column(db.Integer, primary_key=True)
+    from_level_id = db.Column(db.Integer, db.ForeignKey('levels.id'), nullable=False)
+    to_level_id = db.Column(db.Integer, db.ForeignKey('levels.id'), nullable=False)
+    n_connections = db.Column(db.Integer, nullable=False)
+    ppg_ratio = db.Column(db.Float, nullable=False)
+    n_games = db.Column(db.Integer, nullable=False)  # New field to store the number of games
+
+    __table_args__ = (
+        db.UniqueConstraint('from_level_id', 'to_level_id', name='_from_to_level_uc'),
+    )
+
+class SkillPropagationCorrelation(db.Model):
+    __tablename__ = 'skill_propagation_correlation'
+    id = db.Column(db.Integer, primary_key=True)
+    skill_value_from = db.Column(db.Float, nullable=False)
+    skill_value_to = db.Column(db.Float, nullable=False)
+    ppg_ratio = db.Column(db.Float, nullable=False)
+
+    __table_args__ = (
+        db.UniqueConstraint('skill_value_from', 'skill_value_to', 'ppg_ratio', name='_skill_value_ppg_ratio_uc'),
+    )
+
+# How PPG changes with INCREASING SKILL VALUES
+class SkillValuePPGRatio(db.Model):
+    __tablename__ = 'skill_value_ppg_ratios'
+    id = db.Column(db.Integer, primary_key=True)
+    from_skill_value = db.Column(db.Float, nullable=False)
+    to_skill_value = db.Column(db.Float, nullable=False)
+    ppg_ratio = db.Column(db.Float, nullable=False)
+    n_games = db.Column(db.Integer, nullable=False)  # New field to store the sum of games
+
+    __table_args__ = (
+        db.UniqueConstraint('from_skill_value', 'to_skill_value', name='_from_to_skill_value_uc'),
+    )

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/hockey_blast_common_lib.egg-info/PKG-INFO

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

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/hockey_blast_common_lib.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ hockey_blast_common_lib/aggregate_goalie_stats.py
 hockey_blast_common_lib/aggregate_human_stats.py
 hockey_blast_common_lib/aggregate_referee_stats.py
 hockey_blast_common_lib/aggregate_skater_stats.py
+hockey_blast_common_lib/assign_skater_skill.py
 hockey_blast_common_lib/db_connection.py
 hockey_blast_common_lib/dump_sample_db.sh
 hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz
@@ -13,6 +14,7 @@ hockey_blast_common_lib/models.py
 hockey_blast_common_lib/options.py
 hockey_blast_common_lib/restore_sample_db.sh
 hockey_blast_common_lib/skills_in_divisions.py
+hockey_blast_common_lib/skills_propagation.py
 hockey_blast_common_lib/stats_models.py
 hockey_blast_common_lib/utils.py
 hockey_blast_common_lib/wsgi.py

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.31}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='hockey-blast-common-lib',  # The name of your package
-    version='0.1.28',
+    version='0.1.31',
     description='Common library for shared functionality and DB models',
     author='Pavel Kletskov',
     author_email='kletskov@gmail.com',