hockey-blast-common-lib 0.1.33__tar.gz → 0.1.34__tar.gz

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/PKG-INFO

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

hockey_blast_common_lib-0.1.34/hockey_blast_common_lib/aggregate_all_stats.py

@@ -0,0 +1,26 @@
+import sys, os
+
+# Add the package directory to the Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from hockey_blast_common_lib.aggregate_human_stats import run_aggregate_human_stats
+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
+
+if __name__ == "__main__":
+    print("Running aggregate_human_stats...")
+    run_aggregate_human_stats()
+    print("Finished running aggregate_human_stats\n")
+
+    print("Running aggregate_skater_stats...")
+    run_aggregate_skater_stats()
+    print("Finished running aggregate_skater_stats\n")
+
+    print("Running aggregate_goalie_stats...")
+    run_aggregate_goalie_stats()
+    print("Finished running aggregate_goalie_stats\n")
+
+    print("Running aggregate_referee_stats...")
+    run_aggregate_referee_stats()
+    print("Finished running aggregate_referee_stats\n")

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/hockey_blast_common_lib/aggregate_goalie_stats.py

@@ -11,8 +11,8 @@ from hockey_blast_common_lib.stats_models import OrgStatsGoalie, DivisionStatsGo
 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
-from hockey_blast_common_lib.stats_utils import assign_ranks
+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 hockey_blast_common_lib.utils import assign_ranks
 from sqlalchemy import func, case, and_
 from collections import defaultdict
 
@@ -61,18 +61,11 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
 
     # Apply aggregation window filter
     if aggregation_window:
-        last_game_datetime = session.query(func.max(func.concat(Game.date, ' ', Game.time))).filter(filter_condition, Game.status.like('Final%')).scalar()
-        if last_game_datetime:
-            last_game_datetime = datetime.strptime(last_game_datetime, '%Y-%m-%d %H:%M:%S')
-            if aggregation_window == 'Daily':
-                start_datetime = last_game_datetime - timedelta(days=1)
-            elif aggregation_window == 'Weekly':
-                start_datetime = last_game_datetime - timedelta(weeks=1)
-            else:
-                start_datetime = None
-            if start_datetime:
-                game_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP).between(start_datetime, last_game_datetime)
-                filter_condition = filter_condition & game_window_filter
+        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
 
     # Delete existing items from the stats table
     session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
@@ -180,7 +173,7 @@ def aggregate_goalie_stats(session, aggregation_type, aggregation_id, names_to_f
             session.commit()
     session.commit()
 
-if __name__ == "__main__":
+def run_aggregate_goalie_stats():
     session = create_session("boss")
     human_id_to_debug = None
 
@@ -216,4 +209,7 @@ if __name__ == "__main__":
         if human_id_to_debug is None:
             print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
         processed_levels += 1
-        aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+        aggregate_goalie_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+
+if __name__ == "__main__":
+    run_aggregate_goalie_stats()

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/hockey_blast_common_lib/aggregate_human_stats.py

@@ -12,7 +12,8 @@ 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, MIN_GAMES_FOR_LEVEL_STATS, not_human_names
 from hockey_blast_common_lib.utils import get_fake_human_for_stats, 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 hockey_blast_common_lib.stats_utils import assign_ranks
+from hockey_blast_common_lib.utils import assign_ranks
+from hockey_blast_common_lib.utils import get_start_datetime
 
 def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_filter_out, human_id_filter=None, aggregation_window=None):
     human_ids_to_filter = get_human_ids_by_names(session, names_to_filter_out)
@@ -50,18 +51,11 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
 
     # Apply aggregation window filter
     if aggregation_window:
-        last_game_datetime = session.query(func.max(func.concat(Game.date, ' ', Game.time))).filter(filter_condition, Game.status.like('Final%')).scalar()
-        if last_game_datetime:
-            last_game_datetime = datetime.strptime(last_game_datetime, '%Y-%m-%d %H:%M:%S')
-            if aggregation_window == 'Daily':
-                start_datetime = last_game_datetime - timedelta(days=1)
-            elif aggregation_window == 'Weekly':
-                start_datetime = last_game_datetime - timedelta(weeks=1)
-            else:
-                start_datetime = None
-            if start_datetime:
-                game_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP).between(start_datetime, last_game_datetime)
-                filter_condition = filter_condition & game_window_filter
+        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
 
     # Delete existing items from the stats table
     session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
@@ -415,30 +409,30 @@ def aggregate_human_stats(session, aggregation_type, aggregation_id, names_to_fi
     session.add(overall_human_stat)
     session.commit()
 
-if __name__ == "__main__":
+def run_aggregate_human_stats():
     session = create_session("boss")
     human_id_to_debug = None
 
-    # 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]
-
-    # for org_id in org_ids:
-    #     division_ids = get_all_division_ids_for_org(session, org_id)
-    #     print(f"Aggregating human 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_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
-    #         aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
-    #         aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
-    #         processed_divisions += 1
-    #         if human_id_to_debug is None:
-    #             print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
-    #     print("")
-    #     aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
-    #     aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
-    #     aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+    # Aggregate by Org and Division inside Org
+    org_ids = session.query(Organization.id).all()
+    org_ids = [org_id[0] for org_id in org_ids]
+
+    for org_id in org_ids:
+        division_ids = get_all_division_ids_for_org(session, org_id)
+        print(f"Aggregating human 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_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+            aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+            aggregate_human_stats(session, aggregation_type='division', aggregation_id=division_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
+            processed_divisions += 1
+            if human_id_to_debug is None:
+                print(f"\rProcessed {processed_divisions}/{total_divisions} divisions ({(processed_divisions/total_divisions)*100:.2f}%)", end="")
+        print("")
+        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Weekly')
+        aggregate_human_stats(session, aggregation_type='org', aggregation_id=org_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug, aggregation_window='Daily')
         
         # Aggregate by level
     level_ids = session.query(Division.level_id).distinct().all()
@@ -451,4 +445,7 @@ if __name__ == "__main__":
         if human_id_to_debug is None:
             print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
         processed_levels += 1
-        aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+        aggregate_human_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, human_id_filter=human_id_to_debug)
+
+if __name__ == "__main__":
+    run_aggregate_human_stats()

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/hockey_blast_common_lib/aggregate_referee_stats.py

@@ -12,7 +12,8 @@ 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, MIN_GAMES_FOR_LEVEL_STATS, not_human_names
 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 hockey_blast_common_lib.stats_utils import assign_ranks
+from hockey_blast_common_lib.utils import assign_ranks
+from hockey_blast_common_lib.utils import get_start_datetime
 
 def aggregate_referee_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)
@@ -50,18 +51,11 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
 
     # Apply aggregation window filter
     if aggregation_window:
-        last_game_datetime = session.query(func.max(func.concat(Game.date, ' ', Game.time))).filter(filter_condition, Game.status.like('Final%')).scalar()
-        if last_game_datetime:
-            last_game_datetime = datetime.strptime(last_game_datetime, '%Y-%m-%d %H:%M:%S')
-            if aggregation_window == 'Daily':
-                start_datetime = last_game_datetime - timedelta(days=1)
-            elif aggregation_window == 'Weekly':
-                start_datetime = last_game_datetime - timedelta(weeks=1)
-            else:
-                start_datetime = None
-            if start_datetime:
-                game_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP).between(start_datetime, last_game_datetime)
-                filter_condition = filter_condition & game_window_filter
+        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
 
     # Delete existing items from the stats table
     session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
@@ -197,12 +191,9 @@ def aggregate_referee_stats(session, aggregation_type, aggregation_id, names_to_
         # Commit in batches
         if i % batch_size == 0:
             session.commit()
-            print(f"\r{i}/{total_items} ({(i/total_items)*100:.2f}%)", end="")
     session.commit()
-    print(f"\r{total_items}/{total_items} (100.00%)")
-    print("\nDone.")
 
-if __name__ == "__main__":
+def run_aggregate_referee_stats():
     session = create_session("boss")
     human_id_to_debug = None
 
@@ -238,4 +229,7 @@ if __name__ == "__main__":
         if human_id_to_debug is None:
             print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
         processed_levels += 1
-        aggregate_referee_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names)
+        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()

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/hockey_blast_common_lib/aggregate_skater_stats.py

@@ -12,6 +12,7 @@ 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
+from hockey_blast_common_lib.utils import get_start_datetime
 from sqlalchemy import func, case, and_
 from collections import defaultdict
 
@@ -21,6 +22,9 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
     # Get the name of the aggregation, for debug purposes
     if aggregation_type == 'org':
         aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
+        print(f"Aggregating skater stats for {aggregation_name} with window {aggregation_window}...")
+
+        aggregation_name = session.query(Organization).filter(Organization.id == aggregation_id).first().organization_name
     elif aggregation_type == 'division':
         aggregation_name = session.query(Division).filter(Division.id == aggregation_id).first().level
     elif aggregation_type == 'level':
@@ -59,18 +63,11 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
 
     # Apply aggregation window filter
     if aggregation_window:
-        last_game_datetime = session.query(func.max(func.concat(Game.date, ' ', Game.time))).filter(filter_condition, Game.status.like('Final%')).scalar()
-        if last_game_datetime:
-            last_game_datetime = datetime.strptime(last_game_datetime, '%Y-%m-%d %H:%M:%S')
-            if aggregation_window == 'Daily':
-                start_datetime = last_game_datetime - timedelta(days=1)
-            elif aggregation_window == 'Weekly':
-                start_datetime = last_game_datetime - timedelta(weeks=1)
-            else:
-                start_datetime = None
-            if start_datetime:
-                game_window_filter = func.cast(func.concat(Game.date, ' ', Game.time), sqlalchemy.types.TIMESTAMP).between(start_datetime, last_game_datetime)
-                filter_condition = filter_condition & game_window_filter
+        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
 
     # Delete existing items from the stats table
     session.query(StatsModel).filter(StatsModel.aggregation_id == aggregation_id).delete()
@@ -254,16 +251,11 @@ def aggregate_skater_stats(session, aggregation_type, aggregation_id, names_to_f
         # Commit in batches
         if i % batch_size == 0:
             session.commit()
-            if debug_human_id is None:
-                print(f"\r{i}/{total_items} ({(i/total_items)*100:.2f}%)", end="")
-            
     session.commit()
-    if debug_human_id is None:
-        print(f"\r{total_items}/{total_items} (100.00%)")
 
-if __name__ == "__main__":
+def run_aggregate_skater_stats():
     session = create_session("boss")
-    human_id_to_debug = 117076
+    human_id_to_debug = None
 
     # Get all org_id present in the Organization table
     org_ids = session.query(Organization.id).all()
@@ -298,3 +290,6 @@ if __name__ == "__main__":
             print(f"\rProcessed {processed_levels}/{total_levels} levels ({(processed_levels/total_levels)*100:.2f}%)", end="")
         processed_levels += 1
         aggregate_skater_stats(session, aggregation_type='level', aggregation_id=level_id, names_to_filter_out=not_human_names, debug_human_id=human_id_to_debug)
+
+if __name__ == "__main__":
+    run_aggregate_skater_stats()

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/hockey_blast_common_lib/models.py

@@ -224,6 +224,7 @@ class Organization(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     alias = db.Column(db.String(100), unique=True)
     organization_name = db.Column(db.String(100), unique=True)
+    website = db.Column(db.String(100), nullable=True)  # New field for website
 
 class Penalty(db.Model):
     __tablename__ = 'penalties'

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/hockey_blast_common_lib/utils.py

@@ -1,5 +1,6 @@
 import sys
 import os
+from datetime import datetime, timedelta
 
 # Add the package directory to the Python path
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
@@ -11,9 +12,9 @@ from sqlalchemy.sql import func
 def get_org_id_from_alias(session, org_alias):
     # Predefined organizations
     predefined_organizations = [
-        {"id": 1, "organization_name": "Sharks Ice", "alias": "sharksice"},
-        {"id": 2, "organization_name": "TriValley Ice", "alias": "tvice"},
-        {"id": 3, "organization_name": "CAHA", "alias": "caha"}
+        {"id": 1, "organization_name": "Sharks Ice", "alias": "sharksice", "website": "https://www.sharksice.com"},
+        {"id": 2, "organization_name": "TriValley Ice", "alias": "tvice", "website": "https://www.trivalleyice.com"},
+        {"id": 3, "organization_name": "CAHA", "alias": "caha", "website": "https://www.caha.com"}
     ]
 
     # Check if the organization exists
@@ -25,7 +26,7 @@ def get_org_id_from_alias(session, org_alias):
         for org in predefined_organizations:
             existing_org = session.query(Organization).filter_by(id=org["id"]).first()
             if not existing_org:
-                new_org = Organization(id=org["id"], organization_name=org["organization_name"], alias=org["alias"])
+                new_org = Organization(id=org["id"], organization_name=org["organization_name"], alias=org["alias"], website=org["website"])
                 session.add(new_org)
         session.commit()
 
@@ -82,6 +83,21 @@ def get_fake_human_for_stats(session):
 
     return human.id
 
+def get_start_datetime(last_game_datetime_str, aggregation_window):
+    if last_game_datetime_str:
+        last_game_datetime = datetime.strptime(last_game_datetime_str, '%Y-%m-%d %H:%M:%S')
+        if aggregation_window == 'Daily':
+            # 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):
+    sorted_stats = sorted(stats_dict.items(), key=lambda x: x[1][field], reverse=not reverse_rank)
+    for rank, (key, stat) in enumerate(sorted_stats, start=1):
+        stats_dict[key][f'{field}_rank'] = rank
+
 #TEST DB CONNECTION, PERMISSIONS...
 # from hockey_blast_common_lib.db_connection import create_session
 # session = create_session("frontend")

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/hockey_blast_common_lib.egg-info/PKG-INFO

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

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/hockey_blast_common_lib.egg-info/SOURCES.txt

@@ -2,6 +2,7 @@ MANIFEST.in
 README.md
 setup.py
 hockey_blast_common_lib/__init__.py
+hockey_blast_common_lib/aggregate_all_stats.py
 hockey_blast_common_lib/aggregate_goalie_stats.py
 hockey_blast_common_lib/aggregate_human_stats.py
 hockey_blast_common_lib/aggregate_referee_stats.py

{hockey_blast_common_lib-0.1.33 → hockey_blast_common_lib-0.1.34}/setup.py

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

hockey_blast_common_lib-0.1.33/hockey_blast_common_lib/stats_utils.py

@@ -1,4 +0,0 @@
-def assign_ranks(stats_dict, field, reverse_rank=False):
-    sorted_stats = sorted(stats_dict.items(), key=lambda x: x[1][field], reverse=not reverse_rank)
-    for rank, (key, stat) in enumerate(sorted_stats, start=1):
-        stats_dict[key][f'{field}_rank'] = rank