hockey-blast-common-lib 0.1.55__py3-none-any.whl → 0.1.57__py3-none-any.whl

hockey_blast_common_lib/aggregate_all_stats.py

@@ -7,6 +7,7 @@ from hockey_blast_common_lib.aggregate_human_stats import run_aggregate_human_st
 from hockey_blast_common_lib.aggregate_skater_stats import run_aggregate_skater_stats
 from hockey_blast_common_lib.aggregate_goalie_stats import run_aggregate_goalie_stats
 from hockey_blast_common_lib.aggregate_referee_stats import run_aggregate_referee_stats
+from hockey_blast_common_lib.aggregate_scorekeeper_stats import run_aggregate_scorekeeper_stats
 
 if __name__ == "__main__":
     print("Running aggregate_skater_stats...", flush=True)
@@ -21,6 +22,10 @@ if __name__ == "__main__":
     run_aggregate_referee_stats()
     print("Finished running aggregate_referee_stats\n")
 
+    print("Running aggregate_scorekeeper_stats...", flush=True)
+    run_aggregate_scorekeeper_stats()
+    print("Finished running aggregate_scorekeeper_stats\n")
+
     print("Running aggregate_human_stats...", flush=True)
     run_aggregate_human_stats()
     print("Finished running aggregate_human_stats\n")

hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -6,15 +6,13 @@ 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, Organization, Division, Human, Level
+from hockey_blast_common_lib.models import Game, Organization, Division, Human, GoalieSaves
 from hockey_blast_common_lib.stats_models import OrgStatsGoalie, DivisionStatsGoalie, OrgStatsWeeklyGoalie, OrgStatsDailyGoalie, DivisionStatsWeeklyGoalie, DivisionStatsDailyGoalie, LevelStatsGoalie
 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, 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, get_start_datetime
+from sqlalchemy.sql import func
+from hockey_blast_common_lib.options import not_human_names, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, MIN_GAMES_FOR_LEVEL_STATS
+from hockey_blast_common_lib.utils import get_human_ids_by_names, get_all_division_ids_for_org, get_start_datetime
 from hockey_blast_common_lib.utils import assign_ranks
-from sqlalchemy import func, case, and_
-from collections import defaultdict
 from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
 from hockey_blast_common_lib.progress_utils import create_progress_tracker
 
@@ -73,19 +71,20 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
             return
 
 
+    # Aggregate games played, goals allowed, and shots faced for each goalie using GoalieSaves table
+    query = session.query(
+        GoalieSaves.goalie_id.label('human_id'),
+        func.count(GoalieSaves.game_id).label('games_played'),
+        func.sum(GoalieSaves.goals_allowed).label('goals_allowed'),
+        func.sum(GoalieSaves.shots_against).label('shots_faced'),
+        func.array_agg(GoalieSaves.game_id).label('game_ids')
+    ).join(Game, GoalieSaves.game_id == Game.id).join(Division, Game.division_id == Division.id).filter(filter_condition)
+
     # Filter for specific human_id if provided
-    human_filter = []
-    # if debug_human_id:
-    #     human_filter = [GameRoster.human_id == debug_human_id]
-
-    # Aggregate games played, goals allowed, and shots faced for each goalie
-    goalie_stats = session.query(
-        GameRoster.human_id,
-        func.count(Game.id).label('games_played'),
-        func.sum(case((GameRoster.team_id == Game.home_team_id, Game.visitor_final_score), else_=Game.home_final_score)).label('goals_allowed'),
-        func.sum(case((GameRoster.team_id == Game.home_team_id, Game.visitor_period_1_shots + Game.visitor_period_2_shots + Game.visitor_period_3_shots + Game.visitor_ot_shots + Game.visitor_so_shots), else_=Game.home_period_1_shots + Game.home_period_2_shots + Game.home_period_3_shots + Game.home_ot_shots + Game.home_so_shots)).label('shots_faced'),
-        func.array_agg(Game.id).label('game_ids')
-    ).join(Game, GameRoster.game_id == Game.id).join(Division, Game.division_id == Division.id).filter(filter_condition, GameRoster.role.ilike('g')).group_by(GameRoster.human_id).all()
+    if debug_human_id:
+        query = query.filter(GoalieSaves.goalie_id == debug_human_id)
+
+    goalie_stats = query.group_by(GoalieSaves.goalie_id).all()
 
     # Combine the results
     stats_dict = {}
@@ -152,7 +151,6 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
                         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

hockey_blast_common_lib/aggregate_scorekeeper_stats.py

@@ -0,0 +1,222 @@
+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 datetime import datetime, timedelta
+import sqlalchemy
+
+from hockey_blast_common_lib.models import Game, ScorekeeperSaveQuality
+from hockey_blast_common_lib.stats_models import OrgStatsScorekeeper, OrgStatsWeeklyScorekeeper, OrgStatsDailyScorekeeper
+from hockey_blast_common_lib.db_connection import create_session
+from sqlalchemy.sql import func, case
+from hockey_blast_common_lib.options import parse_args, MIN_GAMES_FOR_ORG_STATS, MIN_GAMES_FOR_DIVISION_STATS, not_human_names
+from hockey_blast_common_lib.utils import get_org_id_from_alias, get_human_ids_by_names
+from hockey_blast_common_lib.utils import assign_ranks
+from hockey_blast_common_lib.utils import get_start_datetime
+from hockey_blast_common_lib.stats_utils import ALL_ORGS_ID
+from hockey_blast_common_lib.progress_utils import create_progress_tracker
+
+def calculate_quality_score(avg_max_saves_5sec, avg_max_saves_20sec, peak_max_saves_5sec, peak_max_saves_20sec):
+    """
+    Calculate a quality score based on excessive clicking patterns.
+    Lower scores are better (less problematic clicking).
+
+    Logic:
+    - Penalize high average clicking rates in windows
+    - Heavily penalize peak clicking incidents
+    - Score ranges from 0 (perfect) to higher values (problematic)
+    """
+    # Convert to float to handle Decimal types from database
+    avg_max_saves_5sec = float(avg_max_saves_5sec or 0.0)
+    avg_max_saves_20sec = float(avg_max_saves_20sec or 0.0)
+    peak_max_saves_5sec = float(peak_max_saves_5sec or 0)
+    peak_max_saves_20sec = float(peak_max_saves_20sec or 0)
+
+    if avg_max_saves_5sec == 0 and avg_max_saves_20sec == 0:
+        return 0.0
+
+    # Weight factors (can be tuned based on analysis)
+    avg_5sec_weight = 2.0    # Average clicking in 5sec windows
+    avg_20sec_weight = 1.0   # Average clicking in 20sec windows
+    peak_5sec_weight = 5.0   # Peak 5sec incidents are heavily penalized
+    peak_20sec_weight = 3.0  # Peak 20sec incidents are moderately penalized
+
+    score = (
+        (avg_max_saves_5sec * avg_5sec_weight) +
+        (avg_max_saves_20sec * avg_20sec_weight) +
+        (peak_max_saves_5sec * peak_5sec_weight) +
+        (peak_max_saves_20sec * peak_20sec_weight)
+    )
+
+    return round(score, 2)
+
+def aggregate_scorekeeper_stats(session, aggregation_type, aggregation_id, names_to_filter_out, aggregation_window=None):
+    human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
+
+    if aggregation_type == 'org':
+        # Only process scorekeeper stats for ALL_ORGS_ID - skip individual organizations
+        if aggregation_id != ALL_ORGS_ID:
+            return  # Skip processing for individual organization IDs
+
+        aggregation_name = "All Orgs"
+        filter_condition = sqlalchemy.true()  # No filter for organization
+        print(f"Aggregating scorekeeper stats for {aggregation_name} with window {aggregation_window}...")
+        if aggregation_window == 'Daily':
+            StatsModel = OrgStatsDailyScorekeeper
+        elif aggregation_window == 'Weekly':
+            StatsModel = OrgStatsWeeklyScorekeeper
+        else:
+            StatsModel = OrgStatsScorekeeper
+        min_games = MIN_GAMES_FOR_ORG_STATS
+    else:
+        raise ValueError("Invalid aggregation type")
+
+    # Delete existing items from the stats table
+    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
+    session.commit()
+
+    # Apply aggregation window filter
+    if aggregation_window:
+        last_game_datetime_str = session.query(func.max(func.concat(Game.date, ' ', Game.time))).filter(filter_condition, Game.status.like('Final%')).scalar()
+        start_datetime = get_start_datetime(last_game_datetime_str, aggregation_window)
+        if start_datetime:
+            game_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP).between(start_datetime, last_game_datetime_str)
+            filter_condition = filter_condition & game_window_filter
+        else:
+            return
+
+
+    # Aggregate scorekeeper quality data for each human
+    scorekeeper_quality_stats = session.query(
+        ScorekeeperSaveQuality.scorekeeper_id.label('human_id'),
+        func.count(ScorekeeperSaveQuality.game_id).label('games_recorded'),
+        func.sum(ScorekeeperSaveQuality.total_saves_recorded).label('total_saves_recorded'),
+        func.avg(ScorekeeperSaveQuality.total_saves_recorded).label('avg_saves_per_game'),
+        func.avg(ScorekeeperSaveQuality.max_saves_per_5sec).label('avg_max_saves_per_5sec'),
+        func.avg(ScorekeeperSaveQuality.max_saves_per_20sec).label('avg_max_saves_per_20sec'),
+        func.max(ScorekeeperSaveQuality.max_saves_per_5sec).label('peak_max_saves_per_5sec'),
+        func.max(ScorekeeperSaveQuality.max_saves_per_20sec).label('peak_max_saves_per_20sec'),
+        func.array_agg(ScorekeeperSaveQuality.game_id).label('game_ids')
+    ).join(Game, Game.id == ScorekeeperSaveQuality.game_id)
+
+
+    scorekeeper_quality_stats = scorekeeper_quality_stats.filter(filter_condition).group_by(ScorekeeperSaveQuality.scorekeeper_id).all()
+
+    # Combine the results
+    stats_dict = {}
+    for stat in scorekeeper_quality_stats:
+        if stat.human_id in human_ids_to_filter or stat.human_id is None:
+            continue
+        key = (aggregation_id, stat.human_id)
+
+        # Calculate quality score
+        quality_score = calculate_quality_score(
+            stat.avg_max_saves_per_5sec or 0.0,
+            stat.avg_max_saves_per_20sec or 0.0,
+            stat.peak_max_saves_per_5sec or 0,
+            stat.peak_max_saves_per_20sec or 0
+        )
+
+        stats_dict[key] = {
+            'games_recorded': stat.games_recorded,
+            'sog_given': stat.total_saves_recorded,  # Legacy field name mapping
+            'sog_per_game': stat.avg_saves_per_game or 0.0,  # Legacy field name mapping
+            'total_saves_recorded': stat.total_saves_recorded,
+            'avg_saves_per_game': stat.avg_saves_per_game or 0.0,
+            'avg_max_saves_per_5sec': stat.avg_max_saves_per_5sec or 0.0,
+            'avg_max_saves_per_20sec': stat.avg_max_saves_per_20sec or 0.0,
+            'peak_max_saves_per_5sec': stat.peak_max_saves_per_5sec or 0,
+            'peak_max_saves_per_20sec': stat.peak_max_saves_per_20sec or 0,
+            'quality_score': quality_score,
+            'game_ids': stat.game_ids,
+            'first_game_id': None,
+            'last_game_id': None
+        }
+
+    # Filter out entries with games_recorded less than min_games
+    stats_dict = {key: value for key, value in stats_dict.items() if value['games_recorded'] >= min_games}
+
+    # Populate first_game_id and last_game_id
+    for key, stat in stats_dict.items():
+        all_game_ids = stat['game_ids']
+        if all_game_ids:
+            first_game = session.query(Game).filter(Game.id.in_(all_game_ids)).order_by(Game.date, Game.time).first()
+            last_game = session.query(Game).filter(Game.id.in_(all_game_ids)).order_by(Game.date.desc(), Game.time.desc()).first()
+            stat['first_game_id'] = first_game.id if first_game else None
+            stat['last_game_id'] = last_game.id if last_game else None
+
+    # Calculate total_in_rank
+    total_in_rank = len(stats_dict)
+
+    # Assign ranks - note: for quality metrics, lower values are better (reverse_rank=True for avg and peak clicking)
+    assign_ranks(stats_dict, 'games_recorded')
+    assign_ranks(stats_dict, 'sog_given')  # Legacy field
+    assign_ranks(stats_dict, 'sog_per_game')  # Legacy field
+    assign_ranks(stats_dict, 'total_saves_recorded')
+    assign_ranks(stats_dict, 'avg_saves_per_game')
+    assign_ranks(stats_dict, 'avg_max_saves_per_5sec', reverse_rank=True)  # Lower is better (less clicking)
+    assign_ranks(stats_dict, 'avg_max_saves_per_20sec', reverse_rank=True)  # Lower is better
+    assign_ranks(stats_dict, 'peak_max_saves_per_5sec', reverse_rank=True)  # Lower is better
+    assign_ranks(stats_dict, 'peak_max_saves_per_20sec', reverse_rank=True)  # Lower is better
+    assign_ranks(stats_dict, 'quality_score', reverse_rank=True)  # Lower is better (less problematic)
+
+    # 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
+        scorekeeper_stat = StatsModel(
+            aggregation_id=aggregation_id,
+            human_id=human_id,
+            games_recorded=stat['games_recorded'],
+            sog_given=stat['sog_given'],  # Legacy field mapping
+            sog_per_game=stat['sog_per_game'],  # Legacy field mapping
+            total_saves_recorded=stat['total_saves_recorded'],
+            total_saves_recorded_rank=stat['total_saves_recorded_rank'],
+            avg_saves_per_game=stat['avg_saves_per_game'],
+            avg_saves_per_game_rank=stat['avg_saves_per_game_rank'],
+            avg_max_saves_per_5sec=stat['avg_max_saves_per_5sec'],
+            avg_max_saves_per_5sec_rank=stat['avg_max_saves_per_5sec_rank'],
+            avg_max_saves_per_20sec=stat['avg_max_saves_per_20sec'],
+            avg_max_saves_per_20sec_rank=stat['avg_max_saves_per_20sec_rank'],
+            peak_max_saves_per_5sec=stat['peak_max_saves_per_5sec'],
+            peak_max_saves_per_5sec_rank=stat['peak_max_saves_per_5sec_rank'],
+            peak_max_saves_per_20sec=stat['peak_max_saves_per_20sec'],
+            peak_max_saves_per_20sec_rank=stat['peak_max_saves_per_20sec_rank'],
+            quality_score=stat['quality_score'],
+            quality_score_rank=stat['quality_score_rank'],
+            games_recorded_rank=stat['games_recorded_rank'],
+            sog_given_rank=stat['sog_given_rank'],  # Legacy field
+            sog_per_game_rank=stat['sog_per_game_rank'],  # Legacy field
+            total_in_rank=total_in_rank,
+            first_game_id=stat['first_game_id'],
+            last_game_id=stat['last_game_id']
+        )
+        session.add(scorekeeper_stat)
+        # Commit in batches
+        if i % batch_size == 0:
+            session.commit()
+    session.commit()
+
+def run_aggregate_scorekeeper_stats():
+    session = create_session("boss")
+    human_id_to_debug = None
+
+    # Process ALL_ORGS scorekeeper stats only (cross-organizational)
+    # Scorekeeper quality should be measured across all organizations they work for
+    if human_id_to_debug is None:
+        org_progress = create_progress_tracker(3, f"Processing cross-organizational scorekeeper stats")
+        aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=ALL_ORGS_ID, names_to_filter_out=not_human_names)
+        org_progress.update(1)
+        aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=ALL_ORGS_ID, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+        org_progress.update(2)
+        aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=ALL_ORGS_ID, names_to_filter_out=not_human_names, aggregation_window='Daily')
+        org_progress.update(3)
+    else:
+        aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=ALL_ORGS_ID, names_to_filter_out=not_human_names)
+        aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=ALL_ORGS_ID, names_to_filter_out=not_human_names, aggregation_window='Weekly')
+        aggregate_scorekeeper_stats(session, aggregation_type='org', aggregation_id=ALL_ORGS_ID, names_to_filter_out=not_human_names, aggregation_window='Daily')
+
+if __name__ == "__main__":
+    run_aggregate_scorekeeper_stats()

hockey_blast_common_lib/models.py

@@ -104,14 +104,18 @@ class Goal(db.Model):
 class Human(db.Model):
     __tablename__ = 'humans'
     id = db.Column(db.Integer, primary_key=True)
-    first_name = db.Column(db.String(100))
-    middle_name = db.Column(db.String(100))
-    last_name = db.Column(db.String(100))
+    # All name components now declared non-nullable at the ORM level. Ensure data cleanup
+    # (convert existing NULLs to '') BEFORE applying a DB migration that enforces NOT NULL.
+    # middle_name and suffix may be logically "empty" but must not be NULL; use '' for absence.
+    first_name = db.Column(db.String(100), nullable=False, default='')
+    middle_name = db.Column(db.String(100), nullable=False, default='')
+    last_name = db.Column(db.String(100), nullable=False, default='')
+    suffix = db.Column(db.String(100), nullable=False, default='')
     first_date = db.Column(db.Date)
     last_date = db.Column(db.Date)
     skater_skill_value = db.Column(db.Float, nullable=True)
     __table_args__ = (
-        db.UniqueConstraint('first_name', 'middle_name', 'last_name', name='_human_name_uc'),
+        db.UniqueConstraint('first_name', 'middle_name', 'last_name', 'suffix', name='_human_name_uc'),
     )
 
 class HumanAlias(db.Model):
@@ -121,10 +125,11 @@ class HumanAlias(db.Model):
     first_name = db.Column(db.String(100))
     middle_name = db.Column(db.String(100))
     last_name = db.Column(db.String(100))
+    suffix = db.Column(db.String(100))
     first_date = db.Column(db.Date)
     last_date = db.Column(db.Date)
     __table_args__ = (
-        db.UniqueConstraint('human_id', 'first_name', 'middle_name', 'last_name', name='_human_alias_uc'),
+        db.UniqueConstraint('human_id', 'first_name', 'middle_name', 'last_name', 'suffix', name='_human_alias_uc'),
     )
 
 class HumanInTTS(db.Model):

hockey_blast_common_lib/options.py

@@ -15,7 +15,9 @@ not_human_names = [
     (None, "Unknown", None),
     ("Not", None , None),
     (None , None, "Goalie"),
-    ("Unassigned",None , None)
+    ("Unassigned",None , None),
+    # Critical addition - primary cause of 93.4% of roster insertion errors
+    ("Not", "Signed", "In")
 ]
 
 def parse_args():

hockey_blast_common_lib/stats_models.py

@@ -176,6 +176,23 @@ class BaseStatsScorekeeper(db.Model):
     sog_given_rank = db.Column(db.Integer, default=0)
     sog_per_game = db.Column(db.Float, default=0.0)
     sog_per_game_rank = db.Column(db.Integer, default=0)
+
+    # Quality metrics fields
+    total_saves_recorded = db.Column(db.Integer, default=0)
+    total_saves_recorded_rank = db.Column(db.Integer, default=0)
+    avg_saves_per_game = db.Column(db.Float, default=0.0)
+    avg_saves_per_game_rank = db.Column(db.Integer, default=0)
+    avg_max_saves_per_5sec = db.Column(db.Float, default=0.0)
+    avg_max_saves_per_5sec_rank = db.Column(db.Integer, default=0)
+    avg_max_saves_per_20sec = db.Column(db.Float, default=0.0)
+    avg_max_saves_per_20sec_rank = db.Column(db.Integer, default=0)
+    peak_max_saves_per_5sec = db.Column(db.Integer, default=0)
+    peak_max_saves_per_5sec_rank = db.Column(db.Integer, default=0)
+    peak_max_saves_per_20sec = db.Column(db.Integer, default=0)
+    peak_max_saves_per_20sec_rank = db.Column(db.Integer, default=0)
+    quality_score = db.Column(db.Float, default=0.0)
+    quality_score_rank = db.Column(db.Integer, default=0)
+
     total_in_rank = db.Column(db.Integer, default=0)
     first_game_id = db.Column(db.Integer, db.ForeignKey('games.id'))
     last_game_id = db.Column(db.Integer, db.ForeignKey('games.id'))
@@ -186,7 +203,14 @@ class BaseStatsScorekeeper(db.Model):
             db.UniqueConstraint('human_id', cls.get_aggregation_column(), name=f'_human_{cls.aggregation_type}_uc_scorekeeper1'),
             db.Index(f'idx_{cls.aggregation_type}_games_recorded1', cls.get_aggregation_column(), 'games_recorded'),
             db.Index(f'idx_{cls.aggregation_type}_sog_given1', cls.get_aggregation_column(), 'sog_given'),
-            db.Index(f'idx_{cls.aggregation_type}_sog_per_game1', cls.get_aggregation_column(), 'sog_per_game')
+            db.Index(f'idx_{cls.aggregation_type}_sog_per_game1', cls.get_aggregation_column(), 'sog_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_total_saves_recorded1', cls.get_aggregation_column(), 'total_saves_recorded'),
+            db.Index(f'idx_{cls.aggregation_type}_avg_saves_per_game1', cls.get_aggregation_column(), 'avg_saves_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_avg_max_saves_per_5sec1', cls.get_aggregation_column(), 'avg_max_saves_per_5sec'),
+            db.Index(f'idx_{cls.aggregation_type}_avg_max_saves_per_20sec1', cls.get_aggregation_column(), 'avg_max_saves_per_20sec'),
+            db.Index(f'idx_{cls.aggregation_type}_peak_max_saves_per_5sec1', cls.get_aggregation_column(), 'peak_max_saves_per_5sec'),
+            db.Index(f'idx_{cls.aggregation_type}_peak_max_saves_per_20sec1', cls.get_aggregation_column(), 'peak_max_saves_per_20sec'),
+            db.Index(f'idx_{cls.aggregation_type}_quality_score1', cls.get_aggregation_column(), 'quality_score')
         )
 
     @classmethod
@@ -365,18 +389,6 @@ class OrgStatsScorekeeper(BaseStatsScorekeeper):
     def get_aggregation_column(cls):
         return 'org_id'
 
-class DivisionStatsScorekeeper(BaseStatsScorekeeper):
-    __tablename__ = 'division_stats_scorekeeper'
-    division_id = db.Column(db.Integer, db.ForeignKey('divisions.id'), nullable=False)
-    aggregation_id = synonym('division_id')
-
-    @declared_attr
-    def aggregation_type(cls):
-        return 'division'
-
-    @classmethod
-    def get_aggregation_column(cls):
-        return 'division_id'
 
 class OrgStatsDailyHuman(BaseStatsHuman):
     __tablename__ = 'org_stats_daily_human'
@@ -612,31 +624,7 @@ class OrgStatsWeeklyScorekeeper(BaseStatsScorekeeper):
     def get_aggregation_column(cls):
         return 'org_id'
 
-class DivisionStatsDailyScorekeeper(BaseStatsScorekeeper):
-    __tablename__ = 'division_stats_daily_scorekeeper'
-    division_id = db.Column(db.Integer, db.ForeignKey('divisions.id'), nullable=False)
-    aggregation_id = synonym('division_id')
-
-    @declared_attr
-    def aggregation_type(cls):
-        return 'division_daily'
-
-    @classmethod
-    def get_aggregation_column(cls):
-        return 'division_id'
-
-class DivisionStatsWeeklyScorekeeper(BaseStatsScorekeeper):
-    __tablename__ = 'division_stats_weekly_scorekeeper'
-    division_id = db.Column(db.Integer, db.ForeignKey('divisions.id'), nullable=False)
-    aggregation_id = synonym('division_id')
-
-    @declared_attr
-    def aggregation_type(cls):
-        return 'division_weekly'
 
-    @classmethod
-    def get_aggregation_column(cls):
-        return 'division_id'
 
 class LevelsGraphEdge(db.Model):
     __tablename__ = 'levels_graph_edges'

{hockey_blast_common_lib-0.1.55.dist-info → hockey_blast_common_lib-0.1.57.dist-info}/METADATA

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

{hockey_blast_common_lib-0.1.55.dist-info → hockey_blast_common_lib-0.1.57.dist-info}/RECORD

@@ -1,27 +1,28 @@
 hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hockey_blast_common_lib/aggregate_all_stats.py,sha256=2bOj2BW0k3ZPQR1NH04upnkIfO9SastzTz7XwO3ujYo,1104
-hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=0pJOT6nKgFYmSTWA3HY-BKARgc7l6czqvzWfwNQMad0,14346
+hockey_blast_common_lib/aggregate_all_stats.py,sha256=QhuSvGjuk4jVywNRcgxB-9ooJAoAbZRkaLjLe9Q1hEM,1363
+hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=lJE5TMBtJLqLeG9jxHV5xUcudusZ4t8yHQN6TvPK_0k,13804
 hockey_blast_common_lib/aggregate_h2h_stats.py,sha256=dC5TcJZGkpIQTiq3z40kOX6EjEhFbGv5EL0P1EClBQ0,11117
 hockey_blast_common_lib/aggregate_human_stats.py,sha256=ku42TAjUIj49822noM8fEeB8GS4vFeCCNrLupTWmqzg,26043
 hockey_blast_common_lib/aggregate_referee_stats.py,sha256=mUcTVQH9K4kwmIfgfGsnh_3AqX6Ia3RjfukkYuQas3I,13938
 hockey_blast_common_lib/aggregate_s2s_stats.py,sha256=urYN0Q06twwLO-XWGlSMVAVOTVR_D2AWdmoGsxIYHXE,6737
+hockey_blast_common_lib/aggregate_scorekeeper_stats.py,sha256=bE7pjSgMi35r9hX6qqsH_r38zJ0DXSr9unb1nyL2Jlw,11722
 hockey_blast_common_lib/aggregate_skater_stats.py,sha256=pA_2pDOGcJyEywISg2ySG8gFCuoLWwqw6a3Gm2wHLyo,23302
 hockey_blast_common_lib/assign_skater_skill.py,sha256=Asq6iRMPsCMDnvuNSd-M3s4Gee4kDocP9Eznwju_9kA,2749
 hockey_blast_common_lib/db_connection.py,sha256=HvPxDvOj7j5H85RfslGvHVNevfg7mKCd0syJ6NX21mU,1890
 hockey_blast_common_lib/dump_sample_db.sh,sha256=MY3lnzTXBoWd76-ZlZr9nWsKMEVgyRsUn-LZ2d1JWZs,810
 hockey_blast_common_lib/h2h_models.py,sha256=0st4xoJO0U6ONfx3BV03BQvHjZE31e_PqZfphAJMoSU,7968
-hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=hWju95cPNMukwns66g0CTK3XUFShrMDN-FzRjpzqLPQ,4648902
-hockey_blast_common_lib/models.py,sha256=NBF0u4wTAwxFe5UaUObFo-L9Az2jLPXbKejtcJRuGQ0,18440
-hockey_blast_common_lib/options.py,sha256=alOXCYF7Jmw4Z97ae6tAsDIS0VNideV_-GKJ4-v4Pjo,1689
+hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=B7MqFsTHYSi1HTIb5jV7xuIu1TTFlvoeMu7_lC-6n9E,4648905
+hockey_blast_common_lib/models.py,sha256=JMwQE1QgNkuWuKakxuHIlbEHfk8Z7GAYktCppCWA6LE,18928
+hockey_blast_common_lib/options.py,sha256=rQaLRYYcaxXrpZoXfUpmvsahC23oVGPEOzEpqtthbIQ,1794
 hockey_blast_common_lib/progress_utils.py,sha256=H_zRFOsb2qQQpGw56wJghZ1nUe_m6zqGeR9hZ33Y1Uo,3229
 hockey_blast_common_lib/restore_sample_db.sh,sha256=7W3lzRZeu9zXIu1Bvtnaw8EHc1ulHmFM4mMh86oUQJo,2205
 hockey_blast_common_lib/skills_in_divisions.py,sha256=m-UEwMwn1KM7wOYvDstgsOEeH57M9V6yrkBoghzGYKE,7005
 hockey_blast_common_lib/skills_propagation.py,sha256=nUxntyK8M4xWjHpkfze8f0suaBeunxicgDCduGmNJ-A,18468
-hockey_blast_common_lib/stats_models.py,sha256=uBNQSqCMXurzS-tD13OoV5WqurYYGHMZMHk1CeA5jgI,26104
+hockey_blast_common_lib/stats_models.py,sha256=64sUq_iWhNXi_b_V_1INuQ1RusKaTASjurkRo5gQOs4,26703
 hockey_blast_common_lib/stats_utils.py,sha256=DXsPO4jw8XsdRUN46TGF_IiBAfz3GCIVBswCGp5ELDk,284
 hockey_blast_common_lib/utils.py,sha256=PduHp6HoI4sfr5HvJfQAaz7170dy5kTFVdIfWvBR-Jg,5874
 hockey_blast_common_lib/wsgi.py,sha256=y3NxoJfWjdzX3iP7RGvDEer6zcnPyCanpqSgW1BlXgg,779
-hockey_blast_common_lib-0.1.55.dist-info/METADATA,sha256=fl85rh700VSbNViKgFuvQFhsvJbJUq3BwYlzQeTzko8,318
-hockey_blast_common_lib-0.1.55.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.55.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.55.dist-info/RECORD,,
+hockey_blast_common_lib-0.1.57.dist-info/METADATA,sha256=JDBDQSrlR8qwho-9RInI8J9XosXE_D5ZlISRqfyhSlU,318
+hockey_blast_common_lib-0.1.57.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.57.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.57.dist-info/RECORD,,