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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hockey-blast-common-lib
-Version: 0.1.28
+Version: 0.1.29
 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.29}/hockey_blast_common_lib/aggregate_skater_stats.py

@@ -6,12 +6,12 @@ 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
+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_
 
 def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_filter_out, filter_human_id=None, aggregation_window=None):
@@ -35,6 +35,10 @@ 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
     else:
         raise ValueError("Invalid aggregation type")
 
@@ -307,20 +311,38 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     print(f"\r{total_items}/{total_items} (100.00%)")
     print("\nDone.")
 
-# 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)
 
-    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, 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')
+        #     processed_divisions += 1
+        #     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, 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')
+        
+        # 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
+        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, filter_human_id=None)
+    print("\nDone.")

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.29}/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.29}/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 = 10
 
 orgs = {'caha', 'sharksice', 'tvice'}
 

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.29}/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):
@@ -56,56 +56,67 @@ def reset_skill_values_in_divisions():
     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()
+        level = session.query(Level).filter(Level.org_id == division.org_id, Level.level_name == div_level).one_or_none()
 
-        if not skill:
+        if not level:
             # If no match found, check each alternative name individually
-            skills = session.query(Skill).filter(Skill.org_id == division.org_id).all()
+            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:
-                    skill = s
+                    level = s
                     break
 
-        if skill:
+        if level:
             # 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}")
+            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:
-            # 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")
+            # 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("Skill values and propagation sequences have been populated into the Division table.")
+    print("Level 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 +127,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 +154,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 +188,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.29/hockey_blast_common_lib/skills_propagation.py

@@ -0,0 +1,251 @@
+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, Season
+from hockey_blast_common_lib.stats_models import LevelsGraphEdge, LevelStatsSkater, SkillPropagationCorrelation
+from hockey_blast_common_lib.db_connection import create_session
+from sqlalchemy import func
+
+import numpy as np
+
+class Config:
+    MIN_GAMES_PLAYED = 10
+    MIN_PPG = 0.3
+    MIN_HUMANS_FOR_EDGE = 5
+    MAX_START_DATE_DIFF_MONTHS = 15
+    MAX_PROPAGATION_SEQUENCE = 0
+    MIN_CONNECTIONS_FOR_CORRELATION = 40
+    MIN_CONNECTIONS_FOR_PROPAGATION = 3
+
+    @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 build_levels_graph_edges():
+    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 and stat.points_per_game >= Config.MIN_PPG:
+            level_human_stats[stat.aggregation_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()
+        from_season = session.query(Season).filter_by(id=from_level.season_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()
+            to_season = session.query(Season).filter_by(id=to_level.season_id).first()
+
+            if from_level.skill_value >= to_level.skill_value:
+                continue
+
+            # TMP DEBUG HACK
+            if from_level.skill_value != 10 and to_level.skill_value != 30:
+                continue
+
+            # Check if the start dates are within the allowed difference
+            if abs((from_season.start_date - to_season.start_date).days) > Config.MAX_START_DATE_DIFF_MONTHS * 30:
+                continue
+
+            common_humans = set(from_humans.keys()) & set(to_humans.keys())
+            n_connections = len(common_humans)
+
+            if n_connections < Config.MIN_HUMANS_FOR_EDGE:
+                continue
+
+            ppg_ratios = []
+            for human_id in common_humans:
+                from_ppg = from_humans[human_id]['points_per_game']
+                to_ppg = to_humans[human_id]['points_per_game']
+                if from_level.skill_value == 10 and to_level.skill_value == 30:
+                    print(f"Human {human_id} From PPG: {from_ppg}, To PPG: {to_ppg}")
+                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 avg_ppg_ratio < 1.0:
+                avg_ppg_ratio = 1 / avg_ppg_ratio
+                from_level_id, to_level_id = to_level_id, from_level_id
+
+            edge = LevelsGraphEdge(
+                from_level_id=from_level_id,
+                to_level_id=to_level_id,
+                n_connections=n_connections,
+                ppg_ratio=avg_ppg_ratio
+            )
+            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):
+    session = create_session("boss")
+
+    if propagation_sequence == 0:
+        # Delete all existing correlation data
+        session.query(SkillPropagationCorrelation).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.ppg_ratio
+                else:
+                    target_level_id = edge.from_level_id
+                    ppg_ratio = 1 / edge.ppg_ratio
+
+                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
+
+                    # Since we go over all levels in the sequence 0, we will see each edge twice
+                    # This condition eliminates duplicates
+                    if skill_value_from >= skill_value_to:
+                        continue
+
+                    # Debug prints
+                    print(f"From Skill  {level.skill_value} to {target_level.skill_value} ratio: {ppg_ratio}")
+
+                    correlation_data[(skill_value_from, skill_value_to)].append(
+                        ppg_ratio
+                    )
+
+        # Save correlation data to the database
+        for (skill_value_from, skill_value_to), ppg_ratios in correlation_data.items():
+            ppg_ratios = Config.discard_outliers(np.array(ppg_ratios))
+            if len(ppg_ratios) > 0:
+                avg_ppg_ratio = float(sum(ppg_ratios) / len(ppg_ratios))
+                correlation = SkillPropagationCorrelation(
+                    skill_value_from=skill_value_from,
+                    skill_value_to=skill_value_to,
+                    ppg_ratio=avg_ppg_ratio
+                )
+                session.add(correlation)
+                session.commit()
+
+    return
+    # 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.ppg_ratio
+            else:
+                target_level_id = edge.from_level_id
+                ppg_ratio = 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:
+                correlation = session.query(SkillPropagationCorrelation).filter_by(
+                    skill_value_from=min(level.skill_value, target_level.skill_value),
+                    skill_value_to=max(level.skill_value, target_level.skill_value),
+                    ppg_ratio=ppg_ratio if level.skill_value < target_level.skill_value else 1 / ppg_ratio
+                ).first()
+
+                if correlation:
+                    suggested_skill_values[target_level_id].append(correlation.skill_value_to)
+
+    # 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))
+            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__":
+    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.29}/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,26 @@ 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)
+
+    __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'),
+    )

{hockey_blast_common_lib-0.1.28 → hockey_blast_common_lib-0.1.29}/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.29
 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.29}/hockey_blast_common_lib.egg-info/SOURCES.txt

@@ -13,6 +13,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.29}/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.29',
     description='Common library for shared functionality and DB models',
     author='Pavel Kletskov',
     author_email='kletskov@gmail.com',