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

hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -56,6 +56,10 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
     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()
@@ -63,10 +67,10 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
         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:
+            #print(f"Warning: No valid start datetime for aggregation window '{aggregation_window}' for {aggregation_name}. No games will be included.")
+            return
 
-    # Delete existing items from the stats table
-    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
-    session.commit()
 
     # Filter for specific human_id if provided
     human_filter = []

hockey_blast_common_lib/aggregate_h2h_stats.py

@@ -0,0 +1,230 @@
+import sys, os
+from datetime import datetime
+
+# Add the package directory to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from hockey_blast_common_lib.models import Game, GameRoster, Goal, Penalty
+from hockey_blast_common_lib.h2h_models import H2HStats, H2HStatsMeta
+from hockey_blast_common_lib.db_connection import create_session
+from sqlalchemy.sql import func
+from sqlalchemy import types
+
+# Max games to process (set to None to process all)
+MAX_GAMES_TO_PROCESS = None  # Set to None to process all games
+
+def aggregate_h2h_stats():
+    session = create_session("boss")
+    meta = None #session.query(H2HStatsMeta).order_by(H2HStatsMeta.id.desc()).first()
+    h2h_stats_dict = {}  # (h1, h2) -> H2HStats instance
+    if meta is None or meta.last_run_timestamp is None or meta.last_processed_game_id is None:
+        # Full run: delete all existing stats and process all games
+        session.query(H2HStats).delete()
+        session.commit()
+        games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
+        print("No previous run found, deleted all existing H2H stats, processing all games...")
+    else:
+        # Incremental: only process games after last processed
+        # Load all existing stats into memory
+        for stat in session.query(H2HStats).all():
+            h2h_stats_dict[(stat.human1_id, stat.human2_id)] = stat
+        last_game = session.query(Game).filter(Game.id == meta.last_processed_game_id).first()
+        if last_game:
+            last_dt = datetime.combine(last_game.date, last_game.time)
+            games_query = session.query(Game).filter(
+                func.cast(func.concat(Game.date, ' ', Game.time), types.TIMESTAMP()) > last_dt
+            ).order_by(Game.date, Game.time, Game.id)
+            print(f"Resuming from game after id {meta.last_processed_game_id} ({last_dt})...")
+        else:
+            games_query = session.query(Game).order_by(Game.date, Game.time, Game.id)
+            print("Previous game id not found, processing all games...")
+
+    total_games = games_query.count()
+    print(f"Total games to process: {total_games}")
+    processed = 0
+    latest_game_id = None
+    for game in games_query:
+        if MAX_GAMES_TO_PROCESS is not None and processed >= MAX_GAMES_TO_PROCESS:
+            break
+        # --- Gather all relevant data for this game ---
+        # Get all GameRoster entries for this game
+        rosters = session.query(GameRoster).filter(GameRoster.game_id == game.id).all()
+        # Map: team_id -> set of human_ids (players)
+        team_to_players = {}
+        human_roles = {}  # human_id -> set of roles in this game
+        for roster in rosters:
+            team_to_players.setdefault(roster.team_id, set()).add(roster.human_id)
+            human_roles.setdefault(roster.human_id, set()).add(roster.role)
+        # Get all human_ids in this game
+        all_humans = set(human_roles.keys())
+        # Add goalies from Game table (home/visitor)
+        if game.home_goalie_id:
+            all_humans.add(game.home_goalie_id)
+            human_roles.setdefault(game.home_goalie_id, set()).add('G')
+        if game.visitor_goalie_id:
+            all_humans.add(game.visitor_goalie_id)
+            human_roles.setdefault(game.visitor_goalie_id, set()).add('G')
+        # Add referees from Game table (NOT from roster!)
+        if game.referee_1_id:
+            all_humans.add(game.referee_1_id)
+            human_roles.setdefault(game.referee_1_id, set()).add('R')
+        if game.referee_2_id:
+            all_humans.add(game.referee_2_id)
+            human_roles.setdefault(game.referee_2_id, set()).add('R')
+        # --- Build all pairs of humans in this game ---
+        all_humans = list(all_humans)
+        for i in range(len(all_humans)):
+            for j in range(i+1, len(all_humans)):
+                h1, h2 = sorted([all_humans[i], all_humans[j]])
+                key = (h1, h2)
+                h2h = h2h_stats_dict.get(key)
+                if not h2h:
+                    h2h = H2HStats(
+                        human1_id=h1,
+                        human2_id=h2,
+                        first_game_id=game.id,
+                        last_game_id=game.id,
+                        games_together=0,
+                        games_against=0,
+                        games_tied_together=0,
+                        games_tied_against=0,
+                        wins_together=0,
+                        losses_together=0,
+                        h1_wins_vs_h2=0,
+                        h2_wins_vs_h1=0,
+                        games_h1_goalie=0,
+                        games_h2_goalie=0,
+                        games_h1_ref=0,
+                        games_h2_ref=0,
+                        games_both_referees=0,
+                        goals_h1_when_together=0,
+                        goals_h2_when_together=0,
+                        assists_h1_when_together=0,
+                        assists_h2_when_together=0,
+                        penalties_h1_when_together=0,
+                        penalties_h2_when_together=0,
+                        gm_penalties_h1_when_together=0,
+                        gm_penalties_h2_when_together=0,
+                        h1_goalie_h2_scorer_goals=0,
+                        h2_goalie_h1_scorer_goals=0,
+                        shots_faced_h1_goalie_vs_h2=0,
+                        shots_faced_h2_goalie_vs_h1=0,
+                        goals_allowed_h1_goalie_vs_h2=0,
+                        goals_allowed_h2_goalie_vs_h1=0,
+                        save_percentage_h1_goalie_vs_h2=0.0,
+                        save_percentage_h2_goalie_vs_h1=0.0,
+                        h1_ref_h2_player_games=0,
+                        h2_ref_h1_player_games=0,
+                        h1_ref_penalties_on_h2=0,
+                        h2_ref_penalties_on_h1=0,
+                        h1_ref_gm_penalties_on_h2=0,
+                        h2_ref_gm_penalties_on_h1=0,
+                        penalties_given_both_refs=0,
+                        gm_penalties_given_both_refs=0,
+                        h1_shootout_attempts_vs_h2_goalie=0,
+                        h1_shootout_goals_vs_h2_goalie=0,
+                        h2_shootout_attempts_vs_h1_goalie=0,
+                        h2_shootout_goals_vs_h1_goalie=0
+                    )
+                    h2h_stats_dict[key] = h2h
+                # Update first/last game ids
+                if game.id < h2h.first_game_id:
+                    h2h.first_game_id = game.id
+                if game.id > h2h.last_game_id:
+                    h2h.last_game_id = game.id
+                # --- Determine roles and teams ---
+                h1_roles = human_roles.get(h1, set())
+                h2_roles = human_roles.get(h2, set())
+                h1_team = None
+                h2_team = None
+                for team_id, players in team_to_players.items():
+                    if h1 in players:
+                        h1_team = team_id
+                    if h2 in players:
+                        h2_team = team_id
+                # --- General stats ---
+                h2h.games_together += 1  # Both present in this game
+                if h1_team and h2_team:
+                    if h1_team == h2_team:
+                        h2h.wins_together += int(_is_win(game, h1_team))
+                        h2h.losses_together += int(_is_loss(game, h1_team))
+                        if _is_tie(game):
+                            h2h.games_tied_together += 1
+                    else:
+                        h2h.games_against += 1
+                        if _is_win(game, h1_team):
+                            h2h.h1_wins_vs_h2 += 1
+                        if _is_win(game, h2_team):
+                            h2h.h2_wins_vs_h1 += 1
+                        if _is_tie(game):
+                            h2h.games_tied_against += 1
+                # --- Role-specific stats ---
+                if 'G' in h1_roles:
+                    h2h.games_h1_goalie += 1
+                if 'G' in h2_roles:
+                    h2h.games_h2_goalie += 1
+                if 'R' in h1_roles:
+                    h2h.games_h1_ref += 1
+                if 'R' in h2_roles:
+                    h2h.games_h2_ref += 1
+                if 'R' in h1_roles and 'R' in h2_roles:
+                    h2h.games_both_referees += 1
+                # --- Goals, assists, penalties ---
+                # Goals
+                goals = session.query(Goal).filter(Goal.game_id == game.id).all()
+                for goal in goals:
+                    if goal.goal_scorer_id == h1 and (goal.assist_1_id == h2 or goal.assist_2_id == h2):
+                        h2h.goals_h1_when_together += 1
+                    if goal.goal_scorer_id == h2 and (goal.assist_1_id == h1 or goal.assist_2_id == h1):
+                        h2h.goals_h2_when_together += 1
+                # Penalties
+                penalties = session.query(Penalty).filter(Penalty.game_id == game.id).all()
+                for pen in penalties:
+                    if pen.penalized_player_id == h1:
+                        h2h.penalties_h1_when_together += 1
+                        if pen.penalty_minutes and 'GM' in pen.penalty_minutes:
+                            h2h.gm_penalties_h1_when_together += 1
+                    if pen.penalized_player_id == h2:
+                        h2h.penalties_h2_when_together += 1
+                        if pen.penalty_minutes and 'GM' in pen.penalty_minutes:
+                            h2h.gm_penalties_h2_when_together += 1
+                # --- TODO: Add more detailed logic for goalie/skater, referee/player, shootouts, etc. ---
+        latest_game_id = game.id
+        processed += 1
+        if processed % 10 == 0 or processed == total_games:
+            print(f"\rProcessed {processed}/{total_games} games ({(processed/total_games)*100:.2f}%)", end="")
+            sys.stdout.flush()
+    # Commit all stats at once
+    session.query(H2HStats).delete()
+    session.add_all(list(h2h_stats_dict.values()))
+    session.commit()
+    print(f"\rProcessed {processed}/{total_games} games (100.00%)")
+    # Save/update meta
+    meta = H2HStatsMeta(
+        last_run_timestamp=datetime.utcnow(),
+        last_processed_game_id=latest_game_id
+    )
+    session.add(meta)
+    session.commit()
+    print("H2H aggregation complete.")
+
+# --- Helper functions for win/loss/tie ---
+def _is_win(game, team_id):
+    if team_id == game.home_team_id:
+        return (game.home_final_score or 0) > (game.visitor_final_score or 0)
+    if team_id == game.visitor_team_id:
+        return (game.visitor_final_score or 0) > (game.home_final_score or 0)
+    return False
+
+def _is_loss(game, team_id):
+    if team_id == game.home_team_id:
+        return (game.home_final_score or 0) < (game.visitor_final_score or 0)
+    if team_id == game.visitor_team_id:
+        return (game.visitor_final_score or 0) < (game.home_final_score or 0)
+    return False
+
+def _is_tie(game):
+    return (game.home_final_score is not None and game.visitor_final_score is not None and game.home_final_score == game.visitor_final_score)
+
+if __name__ == "__main__":
+    aggregate_h2h_stats()

hockey_blast_common_lib/aggregate_human_stats.py

@@ -54,6 +54,10 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
     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()
@@ -61,10 +65,9 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
         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
-
-    # Delete existing items from the stats table
-    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
-    session.commit()
+        else:
+            #print(f"Warning: No valid start datetime for aggregation window '{aggregation_window}' for {aggregation_name}. No games will be included.")
+            return
 
     # Filter for specific human_id if provided
     human_filter = []

hockey_blast_common_lib/aggregate_referee_stats.py

@@ -48,12 +48,16 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
         min_games = MIN_GAMES_FOR_LEVEL_STATS
         filter_condition = Division.level_id == aggregation_id
         # Add filter to only include games for the last 5 years
-        five_years_ago = datetime.now() - timedelta(days=5*365)
-        level_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP) >= five_years_ago
-        filter_condition = filter_condition & level_window_filter
+        # five_years_ago = datetime.now() - timedelta(days=5*365)
+        # level_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP) >= five_years_ago
+        # filter_condition = filter_condition & level_window_filter
     else:
         raise ValueError("Invalid aggregation type")
 
+    # 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()
@@ -61,11 +65,11 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
         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:
+            #print(f"Warning: No valid start datetime for aggregation window '{aggregation_window}' for {aggregation_name}. No games will be included.")
+            return
 
-    # Delete existing items from the stats table
-    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
-    session.commit()
-
+    filter_condition = filter_condition & (Division.id == Game.division_id)
     # Aggregate games reffed for each referee
     games_reffed_stats = session.query(
         Game.referee_1_id.label('human_id'),
@@ -239,4 +243,4 @@ def run_aggregate_referee_stats():
         aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names)
 
 if __name__ == "__main__":
-    run_aggregate_referee_stats()
+    run_aggregate_referee_stats()

hockey_blast_common_lib/aggregate_skater_stats.py

@@ -65,6 +65,10 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     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()
@@ -72,11 +76,10 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         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
-
-    # Delete existing items from the stats table
-    session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
-    session.commit()
-
+        else:
+            #print(f"Warning: No valid start datetime for aggregation window '{aggregation_window}' for {aggregation_name}. No games will be included.")
+            return
+        
     # Filter for specific human_id if provided
     human_filter = []
     # if debug_human_id:

hockey_blast_common_lib/h2h_models.py

@@ -0,0 +1,77 @@
+from hockey_blast_common_lib.models import db
+
+class H2HStats(db.Model):
+    __tablename__ = 'h2h_stats'
+    id = db.Column(db.Integer, primary_key=True)
+    human1_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    human2_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    # Always store with human1_id < human2_id for uniqueness
+    __table_args__ = (
+        db.UniqueConstraint('human1_id', 'human2_id', name='_h2h_human_pair_uc'),
+        db.Index('ix_h2h_human_pair', 'human1_id', 'human2_id'),  # Composite index for fast lookup
+    )
+
+    # General
+    games_together = db.Column(db.Integer, default=0, nullable=False)  # Games where both played (any role, any team)
+    games_against = db.Column(db.Integer, default=0, nullable=False)   # Games where both played on opposing teams
+    games_tied_together = db.Column(db.Integer, default=0, nullable=False)
+    games_tied_against = db.Column(db.Integer, default=0, nullable=False)   # Games against each other that ended in a tie
+    wins_together = db.Column(db.Integer, default=0, nullable=False)   # Games both played on same team and won
+    losses_together = db.Column(db.Integer, default=0, nullable=False) # Games both played on same team and lost
+    h1_wins_vs_h2 = db.Column(db.Integer, default=0, nullable=False)   # Games h1's team won vs h2's team
+    h2_wins_vs_h1 = db.Column(db.Integer, default=0, nullable=False)   # Games h2's team won vs h1's team
+
+    # Role-specific counts
+    games_h1_goalie = db.Column(db.Integer, default=0, nullable=False)  # Games where h1 was a goalie and h2 played
+    games_h2_goalie = db.Column(db.Integer, default=0, nullable=False)  # Games where h2 was a goalie and h1 played
+    games_h1_ref = db.Column(db.Integer, default=0, nullable=False)     # Games where h1 was a referee and h2 played
+    games_h2_ref = db.Column(db.Integer, default=0, nullable=False)     # Games where h2 was a referee and h1 played
+    games_both_referees = db.Column(db.Integer, default=0, nullable=False) # Games where both were referees
+
+    # Goals/Assists/Penalties (when both played)
+    goals_h1_when_together = db.Column(db.Integer, default=0, nullable=False)    # Goals by h1 when both played
+    goals_h2_when_together = db.Column(db.Integer, default=0, nullable=False)    # Goals by h2 when both played
+    assists_h1_when_together = db.Column(db.Integer, default=0, nullable=False)  # Assists by h1 when both played
+    assists_h2_when_together = db.Column(db.Integer, default=0, nullable=False)  # Assists by h2 when both played
+    penalties_h1_when_together = db.Column(db.Integer, default=0, nullable=False) # Penalties on h1 when both played
+    penalties_h2_when_together = db.Column(db.Integer, default=0, nullable=False) # Penalties on h2 when both played
+    gm_penalties_h1_when_together = db.Column(db.Integer, default=0, nullable=False) # GM penalties on h1 when both played
+    gm_penalties_h2_when_together = db.Column(db.Integer, default=0, nullable=False) # GM penalties on h2 when both played
+
+    # Goalie/Skater head-to-head (when one is goalie, other is skater on opposing team)
+    h1_goalie_h2_scorer_goals = db.Column(db.Integer, default=0, nullable=False) # Goals scored by h2 against h1 as goalie
+    h2_goalie_h1_scorer_goals = db.Column(db.Integer, default=0, nullable=False) # Goals scored by h1 against h2 as goalie
+    shots_faced_h1_goalie_vs_h2 = db.Column(db.Integer, default=0, nullable=False) # Shots faced by h1 as goalie vs h2 as skater
+    shots_faced_h2_goalie_vs_h1 = db.Column(db.Integer, default=0, nullable=False) # Shots faced by h2 as goalie vs h1 as skater
+    goals_allowed_h1_goalie_vs_h2 = db.Column(db.Integer, default=0, nullable=False) # Goals allowed by h1 as goalie vs h2 as skater
+    goals_allowed_h2_goalie_vs_h1 = db.Column(db.Integer, default=0, nullable=False) # Goals allowed by h2 as goalie vs h1 as skater
+    save_percentage_h1_goalie_vs_h2 = db.Column(db.Float, default=0.0, nullable=False) # Save % by h1 as goalie vs h2 as skater
+    save_percentage_h2_goalie_vs_h1 = db.Column(db.Float, default=0.0, nullable=False) # Save % by h2 as goalie vs h1 as skater
+
+    # Referee/Player
+    h1_ref_h2_player_games = db.Column(db.Integer, default=0, nullable=False)    # Games h1 was referee, h2 was player
+    h2_ref_h1_player_games = db.Column(db.Integer, default=0, nullable=False)    # Games h2 was referee, h1 was player
+    h1_ref_penalties_on_h2 = db.Column(db.Integer, default=0, nullable=False)    # Penalties given by h1 (as ref) to h2
+    h2_ref_penalties_on_h1 = db.Column(db.Integer, default=0, nullable=False)    # Penalties given by h2 (as ref) to h1
+    h1_ref_gm_penalties_on_h2 = db.Column(db.Integer, default=0, nullable=False) # GM penalties given by h1 (as ref) to h2
+    h2_ref_gm_penalties_on_h1 = db.Column(db.Integer, default=0, nullable=False) # GM penalties given by h2 (as ref) to h1
+
+    # Both referees (when both are referees in the same game)
+    penalties_given_both_refs = db.Column(db.Integer, default=0, nullable=False)     # Total penalties given by both
+    gm_penalties_given_both_refs = db.Column(db.Integer, default=0, nullable=False)  # Total GM penalties given by both
+
+    # Shootouts
+    h1_shootout_attempts_vs_h2_goalie = db.Column(db.Integer, default=0, nullable=False) # h1 shootout attempts vs h2 as goalie
+    h1_shootout_goals_vs_h2_goalie = db.Column(db.Integer, default=0, nullable=False)    # h1 shootout goals vs h2 as goalie
+    h2_shootout_attempts_vs_h1_goalie = db.Column(db.Integer, default=0, nullable=False) # h2 shootout attempts vs h1 as goalie
+    h2_shootout_goals_vs_h1_goalie = db.Column(db.Integer, default=0, nullable=False)    # h2 shootout goals vs h1 as goalie
+
+    # First and last game IDs where both were present
+    first_game_id = db.Column(db.Integer, nullable=False)  # Game.id of the first game where both were present
+    last_game_id = db.Column(db.Integer, nullable=False)   # Game.id of the most recent game where both were present
+
+class H2HStatsMeta(db.Model):
+    __tablename__ = 'h2h_stats_meta'
+    id = db.Column(db.Integer, primary_key=True)
+    last_run_timestamp = db.Column(db.DateTime, nullable=True)  # When the h2h stats were last updated
+    last_processed_game_id = db.Column(db.Integer, nullable=True)  # Game.id of the latest processed game

hockey_blast_common_lib/utils.py

@@ -85,13 +85,22 @@ def get_fake_human_for_stats(session):
     return human.id
 
 def get_start_datetime(last_game_datetime_str, aggregation_window):
+    if aggregation_window == 'Weekly':
+        if last_game_datetime_str:
+            last_game_datetime = datetime.strptime(last_game_datetime_str, '%Y-%m-%d %H:%M:%S')
+            # Check if the last game datetime is over 1 week from now
+            if datetime.now() - last_game_datetime > timedelta(weeks=1):
+                return None
+        # Use current time as the start of the weekly window
+        return datetime.now() - timedelta(weeks=1)
     if last_game_datetime_str:
         last_game_datetime = datetime.strptime(last_game_datetime_str, '%Y-%m-%d %H:%M:%S')
         if aggregation_window == 'Daily':
+            # Check if the last game datetime is over 24 hours from now
+            if datetime.now() - last_game_datetime > timedelta(hours=24):
+                return None
             # From 10AM till midnight, 14 hours to avoid last day games
             return last_game_datetime - timedelta(hours=14)
-        elif aggregation_window == 'Weekly':
-            return last_game_datetime - timedelta(weeks=1)
     return None
 
 def assign_ranks(stats_dict, field, reverse_rank=False):

hockey_blast_common_lib/wsgi.py

@@ -6,6 +6,7 @@ sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from flask_migrate import Migrate
 from flask import Flask
 from hockey_blast_common_lib.models import *
+from hockey_blast_common_lib.h2h_models import *
 from hockey_blast_common_lib.stats_models import *
 from hockey_blast_common_lib.stats_models import db
 from hockey_blast_common_lib.db_connection import get_db_params

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

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

{hockey_blast_common_lib-0.1.49.dist-info → hockey_blast_common_lib-0.1.51.dist-info}/RECORD

@@ -1,13 +1,15 @@
 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=FcYL40NP0-sPY7UI7F8Ny_RaPKz3mfkmhQnPVbeRtOc,12178
-hockey_blast_common_lib/aggregate_human_stats.py,sha256=VmUAMbqtWRPFM64V8ECJ3eJjRXvblNbeVU9HFYNoPp0,23898
-hockey_blast_common_lib/aggregate_referee_stats.py,sha256=FszWLTygddDQNcUgbmevQ-eGPrW8Y0nXpRvUluPRKnU,11920
-hockey_blast_common_lib/aggregate_skater_stats.py,sha256=FBc6enJNnFXYg7mVPiXssleTA1vZRAXCTFUa-3eOGdo,17199
+hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=_9lP5xNX_QcIge-sHbqIlt7mKcFJBGVBbr33Rtf3LAY,12365
+hockey_blast_common_lib/aggregate_h2h_stats.py,sha256=Hqhca_OyA9BwLOLU488RcPuZZgpAW0gx4G8EhD7Noy8,11166
+hockey_blast_common_lib/aggregate_human_stats.py,sha256=uBNzXbFsK5PhPg-5wjH2iuJ7VPpA7MWKFHx90rMbhjQ,24084
+hockey_blast_common_lib/aggregate_referee_stats.py,sha256=dSl0LEpCzyzpD_tv8yw07NLBImo2RP_xuUQZK_p5kFs,12189
+hockey_blast_common_lib/aggregate_skater_stats.py,sha256=MU4ICUUtDDKhdeb4sc0UPzjREwSB0rFZuJqRtIDedDU,17393
 hockey_blast_common_lib/assign_skater_skill.py,sha256=p-0fbodGpM8BCjKHDpxNb7BH2FcIlBsJwON844KNrUY,1817
 hockey_blast_common_lib/db_connection.py,sha256=HvPxDvOj7j5H85RfslGvHVNevfg7mKCd0syJ6NX21mU,1890
 hockey_blast_common_lib/dump_sample_db.sh,sha256=MY3lnzTXBoWd76-ZlZr9nWsKMEVgyRsUn-LZ2d1JWZs,810
-hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=UXr0ka2t3NzBogn8a7J3QiAWaGnhcfyiJ59BbVoLi3E,1256782
+hockey_blast_common_lib/h2h_models.py,sha256=inB_QAm8Unkc0QRVibiw-Wf8yebNk8zhwxF9EZGMNKM,6350
+hockey_blast_common_lib/hockey_blast_sample_backup.sql.gz,sha256=6_atrXLDO31Qyc9CnangK-xywBHIAI3Ztvng-PZXe6U,4648905
 hockey_blast_common_lib/models.py,sha256=nbJjypa2OBO5_fwjAbWVgBp4WDCuE-RtaELzJ9cvqB4,16468
 hockey_blast_common_lib/options.py,sha256=2L4J9rKCKr58om34259D3_s7kbPdknMSwoo6IwTNnx0,849
 hockey_blast_common_lib/restore_sample_db.sh,sha256=7W3lzRZeu9zXIu1Bvtnaw8EHc1ulHmFM4mMh86oUQJo,2205
@@ -15,9 +17,9 @@ hockey_blast_common_lib/skills_in_divisions.py,sha256=m-UEwMwn1KM7wOYvDstgsOEeH5
 hockey_blast_common_lib/skills_propagation.py,sha256=x6yy7fJ6IX3YiHqiP_v7-p_S2Expb8JJ-mWuajEFBdY,16388
 hockey_blast_common_lib/stats_models.py,sha256=NWigeIowIJU6o1Sk1cP08kEy4t594LZpecKUnl-O6as,25552
 hockey_blast_common_lib/stats_utils.py,sha256=DXsPO4jw8XsdRUN46TGF_IiBAfz3GCIVBswCGp5ELDk,284
-hockey_blast_common_lib/utils.py,sha256=EORIX_yqvqAHdoP33yI4Uey3JoPg_CBHUL1xAhksRpY,5351
-hockey_blast_common_lib/wsgi.py,sha256=7LGUzioigviJp-EUhSEaQcd4jBae0mxbkyBscQfZhlc,730
-hockey_blast_common_lib-0.1.49.dist-info/METADATA,sha256=Ezd_kdOghO-mioTD3CtwTYsyIviEQiEVsH5PkP3W1fk,318
-hockey_blast_common_lib-0.1.49.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.49.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.49.dist-info/RECORD,,
+hockey_blast_common_lib/utils.py,sha256=PduHp6HoI4sfr5HvJfQAaz7170dy5kTFVdIfWvBR-Jg,5874
+hockey_blast_common_lib/wsgi.py,sha256=y3NxoJfWjdzX3iP7RGvDEer6zcnPyCanpqSgW1BlXgg,779
+hockey_blast_common_lib-0.1.51.dist-info/METADATA,sha256=wr1jHyXwbpWDlzqSguE3UWILsSlrcu3xgjwZ_IdoQ3A,318
+hockey_blast_common_lib-0.1.51.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.51.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.51.dist-info/RECORD,,