hockey-blast-common-lib 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

hockey_blast_common_lib/stats_models.py

@@ -0,0 +1,563 @@
+from models import db
+from sqlalchemy.ext.declarative import declared_attr
+from sqlalchemy.orm import synonym
+
+class BaseStatsHuman(db.Model):
+    __abstract__ = True
+    id = db.Column(db.Integer, primary_key=True)
+    human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    games_total = db.Column(db.Integer, default=0)
+    games_total_rank = db.Column(db.Integer, default=0)
+    games_skater = db.Column(db.Integer, default=0)
+    games_skater_rank = db.Column(db.Integer, default=0)
+    games_referee = db.Column(db.Integer, default=0)
+    games_referee_rank = db.Column(db.Integer, default=0)
+    games_scorekeeper = db.Column(db.Integer, default=0)
+    games_scorekeeper_rank = db.Column(db.Integer, default=0)
+    games_goalie = db.Column(db.Integer, default=0)
+    games_goalie_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'))
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            db.UniqueConstraint('human_id', cls.get_aggregation_column(), name=f'_human_{cls.aggregation_type}_stats_uc1'),
+            db.Index(f'idx_{cls.aggregation_type}_games_total1', cls.get_aggregation_column(), 'games_total'),
+            db.Index(f'idx_{cls.aggregation_type}_games_skater1', cls.get_aggregation_column(), 'games_skater'),
+            db.Index(f'idx_{cls.aggregation_type}_games_referee1', cls.get_aggregation_column(), 'games_referee'),
+            db.Index(f'idx_{cls.aggregation_type}_games_scorekeeper1', cls.get_aggregation_column(), 'games_scorekeeper'),
+            db.Index(f'idx_{cls.aggregation_type}_games_goalie1', cls.get_aggregation_column(), 'games_goalie')
+        )
+
+    @classmethod
+    def get_aggregation_column(cls):
+        raise NotImplementedError("Subclasses should implement this method to return the aggregation column name.")
+
+
+class BaseStatsSkater(db.Model):
+    __abstract__ = True
+    id = db.Column(db.Integer, primary_key=True)
+    human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    games_played = db.Column(db.Integer, default=0)
+    games_played_rank = db.Column(db.Integer, default=0)
+    goals = db.Column(db.Integer, default=0)
+    goals_rank = db.Column(db.Integer, default=0)
+    assists = db.Column(db.Integer, default=0)
+    assists_rank = db.Column(db.Integer, default=0)
+    points = db.Column(db.Integer, default=0)
+    points_rank = db.Column(db.Integer, default=0)
+    penalties = db.Column(db.Integer, default=0)
+    penalties_rank = db.Column(db.Integer, default=0)
+    goals_per_game = db.Column(db.Float, default=0.0)
+    goals_per_game_rank = db.Column(db.Integer, default=0)
+    points_per_game = db.Column(db.Float, default=0.0)
+    points_per_game_rank = db.Column(db.Integer, default=0)
+    assists_per_game = db.Column(db.Float, default=0.0)
+    assists_per_game_rank = db.Column(db.Integer, default=0)
+    penalties_per_game = db.Column(db.Float, default=0.0)
+    penalties_per_game_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'))
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            db.UniqueConstraint('human_id', cls.get_aggregation_column(), name=f'_human_{cls.aggregation_type}_uc_skater1'),
+            db.Index(f'idx_{cls.aggregation_type}_goals_per_game3', cls.get_aggregation_column(), 'goals_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_points_per_game3', cls.get_aggregation_column(), 'points_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_assists_per_game3', cls.get_aggregation_column(), 'assists_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_penalties_per_game3', cls.get_aggregation_column(), 'penalties_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_games_played3', cls.get_aggregation_column(), 'games_played')
+        )
+
+    @classmethod
+    def get_aggregation_column(cls):
+        raise NotImplementedError("Subclasses should implement this method to return the aggregation column name.")
+
+class BaseStatsGoalie(db.Model):
+    __abstract__ = True
+    id = db.Column(db.Integer, primary_key=True)
+    human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    games_played = db.Column(db.Integer, default=0)
+    games_played_rank = db.Column(db.Integer, default=0)
+    goals_allowed = db.Column(db.Integer, default=0)
+    goals_allowed_rank = db.Column(db.Integer, default=0)
+    goals_allowed_per_game = db.Column(db.Float, default=0.0)
+    goals_allowed_per_game_rank = db.Column(db.Integer, default=0)
+    shots_faced = db.Column(db.Integer, default=0)
+    shots_faced_rank = db.Column(db.Integer, default=0)
+    save_percentage = db.Column(db.Float, default=0.0)
+    save_percentage_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'))
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            db.UniqueConstraint('human_id', cls.get_aggregation_column(), name=f'_human_{cls.aggregation_type}_uc_goalie1'),
+            db.Index(f'idx_{cls.aggregation_type}_goals_allowed_per_game1', cls.get_aggregation_column(), 'goals_allowed_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_save_percentage1', cls.get_aggregation_column(), 'save_percentage'),
+            db.Index(f'idx_{cls.aggregation_type}_shots_faced1', cls.get_aggregation_column(), 'shots_faced'),
+            db.Index(f'idx_{cls.aggregation_type}_games_played_goalie1', cls.get_aggregation_column(), 'games_played'),
+            db.Index(f'idx_{cls.aggregation_type}_goals_allowed1', cls.get_aggregation_column(), 'goals_allowed')
+        )
+
+    @classmethod
+    def get_aggregation_column(cls):
+        raise NotImplementedError("Subclasses should implement this method to return the aggregation column name.")
+
+class BaseStatsReferee(db.Model):
+    __abstract__ = True
+    id = db.Column(db.Integer, primary_key=True)
+    human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    games_reffed = db.Column(db.Integer, default=0)
+    games_reffed_rank = db.Column(db.Integer, default=0)
+    penalties_given = db.Column(db.Integer, default=0)
+    penalties_given_rank = db.Column(db.Integer, default=0)
+    penalties_per_game = db.Column(db.Float, default=0.0)
+    penalties_per_game_rank = db.Column(db.Integer, default=0)
+    gm_given = db.Column(db.Integer, default=0)
+    gm_given_rank = db.Column(db.Integer, default=0)
+    gm_per_game = db.Column(db.Float, default=0.0)
+    gm_per_game_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'))
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            db.UniqueConstraint('human_id', cls.get_aggregation_column(), name=f'_human_{cls.aggregation_type}_uc_referee1'),
+            db.Index(f'idx_{cls.aggregation_type}_games_reffed1', cls.get_aggregation_column(), 'games_reffed'),
+            db.Index(f'idx_{cls.aggregation_type}_penalties_given1', cls.get_aggregation_column(), 'penalties_given'),
+            db.Index(f'idx_{cls.aggregation_type}_penalties_per_game1', cls.get_aggregation_column(), 'penalties_per_game'),
+            db.Index(f'idx_{cls.aggregation_type}_gm_given1', cls.get_aggregation_column(), 'gm_given'),
+            db.Index(f'idx_{cls.aggregation_type}_gm_per_game1', cls.get_aggregation_column(), 'gm_per_game')
+        )
+
+    @classmethod
+    def get_aggregation_column(cls):
+        raise NotImplementedError("Subclasses should implement this method to return the aggregation column name.")
+
+class BaseStatsScorekeeper(db.Model):
+    __abstract__ = True
+    id = db.Column(db.Integer, primary_key=True)
+    human_id = db.Column(db.Integer, db.ForeignKey('humans.id'), nullable=False)
+    games_recorded = db.Column(db.Integer, default=0)
+    games_recorded_rank = db.Column(db.Integer, default=0)
+    sog_given = db.Column(db.Integer, default=0)
+    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)
+    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'))
+
+    @declared_attr
+    def __table_args__(cls):
+        return (
+            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')
+        )
+
+    @classmethod
+    def get_aggregation_column(cls):
+        raise NotImplementedError("Subclasses should implement this method to return the aggregation column name.")
+
+class OrgStatsHuman(BaseStatsHuman):
+    __tablename__ = 'org_stats_human'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class DivisionStatsHuman(BaseStatsHuman):
+    __tablename__ = 'division_stats_human'
+    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 OrgStatsSkater(BaseStatsSkater):
+    __tablename__ = 'org_stats_skater'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class DivisionStatsSkater(BaseStatsSkater):
+    __tablename__ = 'division_stats_skater'
+    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 OrgStatsGoalie(BaseStatsGoalie):
+    __tablename__ = 'org_stats_goalie'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class DivisionStatsGoalie(BaseStatsGoalie):
+    __tablename__ = 'division_stats_goalie'
+    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 OrgStatsReferee(BaseStatsReferee):
+    __tablename__ = 'org_stats_referee'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class DivisionStatsReferee(BaseStatsReferee):
+    __tablename__ = 'division_stats_referee'
+    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 OrgStatsScorekeeper(BaseStatsScorekeeper):
+    __tablename__ = 'org_stats_scorekeeper'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org'
+
+    @classmethod
+    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'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+    
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_daily'
+
+class OrgStatsWeeklyHuman(BaseStatsHuman):
+    __tablename__ = 'org_stats_weekly_human'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_weekly'
+
+class DivisionStatsDailyHuman(BaseStatsHuman):
+    __tablename__ = 'division_stats_daily_human'
+    division_id = db.Column(db.Integer, db.ForeignKey('divisions.id'), nullable=False)
+    aggregation_id = synonym('division_id')
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'division_id'
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'division_daily'
+
+class DivisionStatsWeeklyHuman(BaseStatsHuman):
+    __tablename__ = 'division_stats_weekly_human'
+    division_id = db.Column(db.Integer, db.ForeignKey('divisions.id'), nullable=False)
+    aggregation_id = synonym('division_id')
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'division_id'
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'division_weekly'
+
+class OrgStatsDailySkater(BaseStatsSkater):
+    __tablename__ = 'org_stats_daily_skater'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_daily'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class OrgStatsWeeklySkater(BaseStatsSkater):
+    __tablename__ = 'org_stats_weekly_skater'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_weekly'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class DivisionStatsDailySkater(BaseStatsSkater):
+    __tablename__ = 'division_stats_daily_skater'
+    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 DivisionStatsWeeklySkater(BaseStatsSkater):
+    __tablename__ = 'division_stats_weekly_skater'
+    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 OrgStatsDailyGoalie(BaseStatsGoalie):
+    __tablename__ = 'org_stats_daily_goalie'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_daily'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class OrgStatsWeeklyGoalie(BaseStatsGoalie):
+    __tablename__ = 'org_stats_weekly_goalie'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_weekly'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class DivisionStatsDailyGoalie(BaseStatsGoalie):
+    __tablename__ = 'division_stats_daily_goalie'
+    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 DivisionStatsWeeklyGoalie(BaseStatsGoalie):
+    __tablename__ = 'division_stats_weekly_goalie'
+    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 OrgStatsDailyReferee(BaseStatsReferee):
+    __tablename__ = 'org_stats_daily_referee'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_daily'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class OrgStatsWeeklyReferee(BaseStatsReferee):
+    __tablename__ = 'org_stats_weekly_referee'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_weekly'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class DivisionStatsDailyReferee(BaseStatsReferee):
+    __tablename__ = 'division_stats_daily_referee'
+    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 DivisionStatsWeeklyReferee(BaseStatsReferee):
+    __tablename__ = 'division_stats_weekly_referee'
+    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 OrgStatsDailyScorekeeper(BaseStatsScorekeeper):
+    __tablename__ = 'org_stats_daily_scorekeeper'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_daily'
+
+    @classmethod
+    def get_aggregation_column(cls):
+        return 'org_id'
+
+class OrgStatsWeeklyScorekeeper(BaseStatsScorekeeper):
+    __tablename__ = 'org_stats_weekly_scorekeeper'
+    org_id = db.Column(db.Integer, db.ForeignKey('organizations.id'), nullable=False)
+    aggregation_id = synonym('org_id')
+
+    @declared_attr
+    def aggregation_type(cls):
+        return 'org_weekly'
+
+    @classmethod
+    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'

hockey_blast_common_lib/utils.py

@@ -0,0 +1,65 @@
+import sys
+import os
+from datetime import datetime, timedelta
+
+
+from models import Organization, Human, Division
+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"}
+    ]
+
+    # Check if the organization exists
+    organization = session.query(Organization).filter_by(alias=org_alias).first()
+    if organization:
+        return organization.id
+    else:
+        # Insert predefined organizations if they do not exist
+        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"])
+                session.add(new_org)
+        session.commit()
+
+        # Retry to get the organization after inserting predefined organizations
+        organization = session.query(Organization).filter_by(alias=org_alias).first()
+        if organization:
+            return organization.id
+        else:
+            raise ValueError(f"Organization with alias '{org_alias}' not found.")
+
+def get_human_ids_by_names(session, names):
+    human_ids = set()
+    for first_name, middle_name, last_name in names:
+        query = session.query(Human.id)
+        if first_name:
+            query = query.filter(Human.first_name == first_name)
+        if middle_name:
+            query = query.filter(Human.middle_name == middle_name)
+        if last_name:
+            query = query.filter(Human.last_name == last_name)
+        results = query.all()
+        human_ids.update([result.id for result in results])
+    return human_ids
+
+def get_division_ids_for_last_season_in_all_leagues(session, org_id):
+    # # TODO = remove tmp hack
+    # return get_all_division_ids_for_org(session, org_id)
+    league_numbers = session.query(Division.league_number).filter(Division.org_id == org_id).distinct().all()
+    division_ids = []
+    for league_number, in league_numbers:
+        max_season_number = session.query(func.max(Division.season_number)).filter_by(league_number=league_number, org_id=org_id).scalar()
+        division_ids_for_league = session.query(Division.id).filter_by(league_number=league_number, season_number=max_season_number, org_id=org_id).all()
+        division_ids.extend([division_id.id for division_id in division_ids_for_league])
+    return division_ids
+
+def get_all_division_ids_for_org(session, org_id):
+    division_ids_for_org = session.query(Division.id).filter_by(org_id=org_id).all()
+    return [division_id.id for division_id in division_ids_for_org]

hockey_blast_common_lib/wsgi.py

@@ -0,0 +1,16 @@
+from flask_migrate import Migrate
+from flask import Flask
+from .models import *
+from .stats_models import *
+from .stats_models import db
+from .db_connection import get_db_params
+
+app = Flask(__name__)
+db_params = get_db_params("hockey-blast-radonly")
+db_url = f"postgresql://{db_params['user']}:{db_params['password']}@{db_params['host']}:{db_params['port']}/{db_params['dbname']}"
+app.config['SQLALCHEMY_DATABASE_URI'] = db_url
+
+db.init_app(app)
+migrate = Migrate(app, db)
+
+# Export db and migrate for flask cli

{hockey_blast_common_lib-0.1.6.dist-info → hockey_blast_common_lib-0.1.8.dist-info}/METADATA

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

hockey_blast_common_lib-0.1.8.dist-info/RECORD

@@ -0,0 +1,16 @@
+hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hockey_blast_common_lib/aggregate_goalie_stats.py,sha256=jfPmlb7dHLacPb2dNA3S4BuQpoNJFvcOoX7SijnHRFg,8515
+hockey_blast_common_lib/aggregate_human_stats.py,sha256=rY18_lfHaEYHhqpCYT5MEuhZLfB8kYSmw42VB3xGkHY,14002
+hockey_blast_common_lib/aggregate_referee_stats.py,sha256=RVgzhh0IajmG7YrxX5wOeFMUhGpIMHk7SUQUDx542d8,10789
+hockey_blast_common_lib/aggregate_skater_stats.py,sha256=1No-9saK8L30EQYrS7nEP6CbBR96tdA2aXQrtTMU6z0,15336
+hockey_blast_common_lib/db_connection.py,sha256=JJcYbBuGlstMfui7UwP5GxPRwzrh4PxtsZDpWsQPnqA,998
+hockey_blast_common_lib/db_utils.py,sha256=GjtcQsSilR55GlLuFAzIGhEVYG3cve7KBkUggW03tDo,767
+hockey_blast_common_lib/models.py,sha256=GqQIGpanmFub97BoYCuaqDov2MxM4LMesUTxZ2edpvw,15393
+hockey_blast_common_lib/options.py,sha256=-LtEX8duw5Pl3CSpjFlLM5FPvrZuTAxTfSlDPa7H6mQ,761
+hockey_blast_common_lib/stats_models.py,sha256=AsHnllpSRWU3-obf01ZFFycnqoRrC9jomwvsC5VPhtI,21023
+hockey_blast_common_lib/utils.py,sha256=_Lbovw3ygkSBk3vRsSvkunoFem9J_d46C0hzT_uXr-w,2875
+hockey_blast_common_lib/wsgi.py,sha256=Qpux4NpQQnZ2U3gOAsqualn-bv9cLjFaXQtFQinC0j4,513
+hockey_blast_common_lib-0.1.8.dist-info/METADATA,sha256=f2nMZVsDXbtoDN2DU0rrxGQVjT0jZqbFLhLM2kAhZFc,317
+hockey_blast_common_lib-0.1.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+hockey_blast_common_lib-0.1.8.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
+hockey_blast_common_lib-0.1.8.dist-info/RECORD,,

hockey_blast_common_lib-0.1.6.dist-info/RECORD

@@ -1,8 +0,0 @@
-hockey_blast_common_lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hockey_blast_common_lib/db_connection.py,sha256=4bN9pLynzOhd_9_u0bvQjgmE0qvkKHoOA95Ga3e_x7g,1361
-hockey_blast_common_lib/db_utils.py,sha256=GjtcQsSilR55GlLuFAzIGhEVYG3cve7KBkUggW03tDo,767
-hockey_blast_common_lib/models.py,sha256=Sfq1dwaDx4fQpfd66o1R_3AyRNKv34vjnvY4B-ebqg8,33910
-hockey_blast_common_lib-0.1.6.dist-info/METADATA,sha256=y5wsjzJGFDx-qdCYnAABIwIXdwPJcYgrj0zCuaUTOFE,317
-hockey_blast_common_lib-0.1.6.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-hockey_blast_common_lib-0.1.6.dist-info/top_level.txt,sha256=wIR4LIkE40npoA2QlOdfCYlgFeGbsHR8Z6r0h46Vtgc,24
-hockey_blast_common_lib-0.1.6.dist-info/RECORD,,