hockey-blast-common-lib 0.1.27__py3-none-any.whl → 0.1.29__py3-none-any.whl

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/models.py

@@ -15,10 +15,11 @@ class Comment(db.Model):
 class Division(db.Model):
     __tablename__ = 'divisions'
     id = db.Column(db.Integer, primary_key=True)
-    league_number = db.Column(db.Integer)
-    season_number = db.Column(db.Integer)
-    level = db.Column(db.String(100))  # UNIQUE LEVEL NAME
-    skill_id = db.Column(db.Integer, db.ForeignKey('skills.id'))  # SKILL LEVEL
+    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)) # 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'),
@@ -152,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'),
     )
@@ -295,7 +297,8 @@ class Season(db.Model):
     season_name = db.Column(db.String(100))
     start_date = db.Column(db.Date)
     end_date = db.Column(db.Date)
-    league_number = db.Column(db.Integer)
+    league_number = db.Column(db.Integer)  # TODO: Deprecate usage and remove (get this info from League by league_id)
+    league_id = db.Column(db.Integer, db.ForeignKey('leagues.id'))
     org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
     __table_args__ = (
         db.UniqueConstraint('org_id', 'league_number', 'season_number', name='_org_league_season_uc'),

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/skills_in_divisions.py

@@ -0,0 +1,194 @@
+import sys
+import os
+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, Level, Season, League
+from hockey_blast_common_lib.db_connection import create_session
+
+def analyze_levels(org):
+    session = create_session(org)
+
+    # Query to get games and their divisions for season_number 33 and 35 with league_number 1
+    games_season_33 = session.query(Game.home_team_id, Game.visitor_team_id, Division.level).join(Division, Game.division_id == Division.id).filter(Division.season_number == 33, Division.league_number == 1).all()
+    games_season_35 = session.query(Game.home_team_id, Game.visitor_team_id, Division.level).join(Division, Game.division_id == Division.id).filter(Division.season_number == 35, Division.league_number == 1).all()
+
+    # Dictionary to store levels for each team by season
+    team_levels_season_33 = defaultdict(set)
+    team_levels_season_35 = defaultdict(set)
+
+    # Populate the dictionaries
+    for home_team_id, visitor_team_id, level in games_season_33:
+        team_levels_season_33[home_team_id].add(level)
+        team_levels_season_33[visitor_team_id].add(level)
+
+    for home_team_id, visitor_team_id, level in games_season_35:
+        team_levels_season_35[home_team_id].add(level)
+        team_levels_season_35[visitor_team_id].add(level)
+
+    # Dictionary to store level name connections
+    level_connections = defaultdict(lambda: defaultdict(int))
+
+    # Analyze the level name connections
+    for team_id in team_levels_season_33:
+        if team_id in team_levels_season_35:
+            for old_level in team_levels_season_33[team_id]:
+                for new_level in team_levels_season_35[team_id]:
+                    level_connections[new_level][old_level] += 1
+
+    # Output the results
+    for new_level in sorted(level_connections.keys()):
+        connections = level_connections[new_level]
+        connections_list = sorted(connections.items(), key=lambda x: x[0])
+        connections_str = ", ".join([f"{old_level}: {count}" for old_level, count in connections_list])
+        print(f"{new_level}: {connections_str}")
+
+    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
+        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 fill_seed_skills():
+    session = create_session("boss")
+
+    # List of Skill objects based on the provided comments
+    skills = [
+        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:
+        session.add(skill)
+        session.commit()
+
+    print("Seed skills have been populated into the database.")
+
+def get_fake_skill(session):
+    # Create a special fake Skill with org_id == -1 and skill_value == -1
+    fake_skill = session.query(Level).filter_by(org_id=1, level_name='Fake Skill').first()
+    if not fake_skill:
+        fake_skill = Level(
+            org_id=1,
+            skill_value=-1,
+            level_name='Fake Skill',
+            level_alternative_name='',
+            is_seed=False
+        )
+        session.add(fake_skill)
+        session.commit()
+        print("Created special fake Skill record.")
+    return fake_skill
+
+def assign_fake_skill_to_divisions(session, fake_skill):
+    # Assign the special fake Skill to every existing Division
+    divisions = session.query(Division).all()
+    for division in divisions:
+        division.skill_id = fake_skill.id
+    session.commit()
+    print("Assigned special fake Skill to all Division records.")
+
+def delete_all_skills():
+    session = create_session("boss")
+    fake_skill = get_fake_skill(session)
+    assign_fake_skill_to_divisions(session, fake_skill)
+    # Delete all Skill records except the fake skill
+    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.")
+
+def populate_season_ids():
+    session = create_session("boss")
+    divisions = session.query(Division).all()
+    for division in divisions:
+        # Find the Season record that matches the season_number
+        season = session.query(Season).filter_by(season_number=division.season_number, org_id=division.org_id, league_number=division.league_number).first()
+        if season:
+            division.season_id = season.id
+            print(f"Assigned season_id {season.id} for Division with season_number {division.season_number}")
+        else:
+            print(f"Season not found for Division with season_number {division.season_number}")
+    session.commit()
+    print("Season IDs have been populated into the Division table.")
+
+def populate_league_ids():
+    session = create_session("boss")
+    seasons = session.query(Season).all()
+    for season in seasons:
+        # Find the League record that matches the league_number and org_id
+        league = session.query(League).filter_by(league_number=season.league_number, org_id=season.org_id).first()
+        if league:
+            season.league_id = league.id
+            print(f"Assigned league_id {league.id} for Season with league_number {season.league_number}")
+        else:
+            print(f"League not found for Season with league_number {season.league_number}")
+    session.commit()
+    print("League IDs have been populated into the Season table.")
+
+if __name__ == "__main__":
+    # delete_all_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/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/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.27.dist-info → hockey_blast_common_lib-0.1.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hockey-blast-common-lib
-Version: 0.1.27
+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.27.dist-info → hockey_blast_common_lib-0.1.29.dist-info}/RECORD

@@ -2,17 +2,19 @@ hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=d2qav46Rg2DNIYRj_Ubj1kpQmoPUJHKiwEWOVU25nD4,8742
 hockey_blast_common_lib/aggregate_human_stats.py,sha256=88OMhTgQjzc9xIakf6kW9_lZwbSXkpsZy8C0pX-Wlq8,14229
 hockey_blast_common_lib/aggregate_referee_stats.py,sha256=A0PTyEbPUjqfXxlJCDOVioFaQk9AyjjhiWEuRuu35v0,11036
-hockey_blast_common_lib/aggregate_skater_stats.py,sha256=37fhgej9trukr8cGaK7DT1HoxBcp95qwsypYCCziqqc,15563
+hockey_blast_common_lib/aggregate_skater_stats.py,sha256=H_RPz26erdvKXz6w8NjSfQAZgcpXitFKsuhmrYYqWyg,16839
 hockey_blast_common_lib/db_connection.py,sha256=HvPxDvOj7j5H85RfslGvHVNevfg7mKCd0syJ6NX21mU,1890
 hockey_blast_common_lib/dump_sample_db.sh,sha256=MHPA-Ciod7wsvAlMbRtXFiyajgnEqU1xR59sJQ9UWR0,738
-hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=UBbPuU8WzHmxIQScT1uXIbTpjWkkt3gu-FS2LNjBx2A,1033691
-hockey_blast_common_lib/models.py,sha256=3sZan04IpaDpUX6h84gHO_Qyf-fF32QMpcLXgR3cCfc,15472
-hockey_blast_common_lib/options.py,sha256=-LtEX8duw5Pl3CSpjFlLM5FPvrZuTAxTfSlDPa7H6mQ,761
+hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=DcRvR7oyP2gbVU7fYUP8-Z9R79kl0jWt4zgFyNECstk,1033685
+hockey_blast_common_lib/models.py,sha256=2YkFHgzvxLSU2-fURsyIqdaXjcQwZ_wjauYR9wWQtDw,15924
+hockey_blast_common_lib/options.py,sha256=S545jnyw14GUiqDyVbwHlNlb3WStpJpsqmRqJ9-mBA0,792
 hockey_blast_common_lib/restore_sample_db.sh,sha256=u2zKazC6vNMULkpYzI64nlneCWaGUtDHPBAU-gWgRbw,1861
-hockey_blast_common_lib/stats_models.py,sha256=PI-mL1jmjCHLAvaATxSsjHEn05g9L_reA_YpsITPWjQ,21047
+hockey_blast_common_lib/skills_in_divisions.py,sha256=BDoA9sGHH86chErTFLmK3oYMiZJwrfUtvKV7kf6pthg,9427
+hockey_blast_common_lib/skills_propagation.py,sha256=tFUXETJJNvV_kq_JTs85LhbS8mRLHKa6ZpW9foYRfI8,9779
+hockey_blast_common_lib/stats_models.py,sha256=W2NbVqQgUucbRsM0uA3tCy7ee7C4ElJ-UOlVDuhBFZM,22388
 hockey_blast_common_lib/utils.py,sha256=odDJWCK0BgbResXeoUzxbVChjaxcXr168ZxbrAw3L_8,3752
 hockey_blast_common_lib/wsgi.py,sha256=7LGUzioigviJp-EUhSEaQcd4jBae0mxbkyBscQfZhlc,730
-hockey_blast_common_lib-0.1.27.dist-info/METADATA,sha256=9McZBCPSrHLzYxACOj_c4ty-B-rDYqOnjswg_OYLJ1c,318
-hockey_blast_common_lib-0.1.27.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.27.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.27.dist-info/RECORD,,
+hockey_blast_common_lib-0.1.29.dist-info/METADATA,sha256=Dhg1VvioCggFoPw2GqvIP0DSOIU0VswxuKbxCs5IYQo,318
+hockey_blast_common_lib-0.1.29.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.29.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.29.dist-info/RECORD,,