Abstract Classes for each api

Author: Nick Shorter

lib/sports/apisports/apisports.py

@@ -0,0 +1,44 @@
+from lib.sports.sportbase import SportBase
+from lib.sports.apisports.baseball.baseball import Baseball
+from lib.sports.apisports.basketball.basketball import Basketball
+from lib.sports.apisports.hockey.hockey import Hockey
+from lib.sports.apisports.football.football import Football
+import json
+import sys
+import os
+
+class ApiSports(SportBase):
+    def __init__(self, config):
+        self.config = config
+        self.sport = self.config['sport']
+        try:
+            if "sport_token" in self.config['basic']:
+                self.token = self.config['basic'].get('sport_token')
+            else:
+                self.token = os.environ['SPORTTOKEN']
+        except KeyError:
+            self.logger.critical("No Sport Token")
+            sys.exit("No Sport Token")
+        self.headers = {'x-apisports-key': 'ebb2c44c416b9a9a0b538e2d73c7dbe6'}
+
+    async def run_api_sports(self):
+        sport_data = {"Sport": {}}
+        if 'football' == self.sport.get('sport').lower():
+            self.logger.debug("Running football data")
+            football = Football(self.token, self.config['sport'], self.headers)
+            football_return = await football.run()
+            sport_data['Sport'].update({'football': football_return})
+        elif 'baseball' == self.sport.get('sport').lower():
+            self.logger.debug('Running baseball data')
+            baseball = Baseball(self.token, self.config['sport'], self.headers)
+            sport_data = await baseball.run()
+        elif 'basketball' == self.sport.get('sport').lower():
+            self.logger.debug('Got basketball in config')
+            basketball = Basketball(self.token, self.config['sport'], self.headers)
+            basketball_return = await basketball.run()
+            sport_data['Sport'].update({'basketball': basketball_return})
+        elif 'hockey' == self.sport.get('sport').lower():
+            self.logger.debug('Got Hockey from Config')
+            hockey = Hockey(self.token, self.config['sport'], self.headers)
+            sport_data = await hockey.run()
+        return sport_data

lib/sports/apisports/baseball/baseball.py

@@ -1,5 +1,6 @@
 from lib.run import Runner
 from datetime import datetime
+from lib.sports.apisports.result import SportApiResult
 
 class Baseball(Runner):
     def __init__(self, token, config, headers):
@@ -33,4 +34,5 @@ async def run(self):
         api_data = {}
         for section, url in self.url_builder(parsed).items():
             api_data.update({section: await self.get_data(url, self.headers)})
-        return api_data
+        api_data['sport'] = 'baseball'
+        return SportApiResult(api_data)

lib/sports/apisports/basketball/basketball.py

@@ -35,4 +35,5 @@ async def run(self):
         api_data = {}
         for section, url in self.url_builder(parsed).items():
             api_data.update({section: await self.get_data(url, self.headers)})
+        api_data['sport'] = 'basketball'
         return api_data

lib/sports/apisports/football/__init__.py

@@ -1,5 +1,6 @@
 from lib.run import Runner
 from datetime import datetime
+from lib.sports.apisports.result import SportApiResult
 
 class Hockey(Runner):
     def __init__(self, token, config, headers):
@@ -29,10 +30,11 @@ def url_builder(self, args):
             urls.update({'next_game': base + f"games?team={self.config.getint('team_id')}&league=57&season=2020&timezone=America/Chicago"})
         return urls
 
-    async def run(self):
+    async def run(self) -> SportApiResult:
         self.logger.info('Running Hockey API')
         parsed = self.parse_args()
         api_data = {}
         for section, url in self.url_builder(parsed).items():
             api_data.update({section: await self.get_data(url, self.headers)})
-        return api_data
+        api_data['sport'] = 'hockey'
+        return SportApiResult(api_data)

lib/sports/apisports/hockey/hockey.py

@@ -0,0 +1,163 @@
+from lib.sports.sportbase import SportResultBase
+
+import json
+
+class SportApiResult(SportResultBase):
+    def __init__(self, api) -> None:
+        super().__init__()
+        self.api_type = ""
+        self.api = api
+        self.main_sport = api
+        self._sport = api['sport']
+        if len(self.main_sport['standings']['errors']) != 0:
+            self._error = self.set_error()
+        else:
+            self._error = self.set_error()
+            if 'standings' in self.main_sport:
+                self.standings = self.build_standings()
+                self._length = len(self.standings)
+                self._positions = [(team.get('name'), team.get('position')) for team in self.standings]
+                self._leagues =  [(team.get('name'), team.get('league')) for team in self.standings]
+                self._games_played = [(team.get('name'), team.get('games').get('played')) for team in self.standings]
+                self._wins = [(team.get('name'), team['games']['win']['total']) for team in self.standings]
+                self._wins_percentage = [(team.get('name'), team['games']['win']['percentage']) for team in self.standings]
+                self._losses = [(team.get('name'), team['games']['lose']['total']) for team in self.standings]
+                self._loss_percentage = [(team.get('name'), team['games']['lose']['percentage']) for team in self.standings]
+            if 'next_game' in self.main_sport:
+                self.next_game = self.build_nextgame()
+                self._game_ids = [game.get('game_id') for game in self.next_game]
+                self._timestamps = [(game.get('game_id'), game.get('timestamp')) for game in self.next_game]
+                self._teams = [(game.get('game_id'), game.get('teams')) for game in self.next_game]
+                self._vs = [(game.get('game_id'), (game['teams']['home']['name'], game['teams']['away']['name'])) for game in self.next_game]
+                self._status = [(game.get('game_id'), game.get('status')) for game in self.next_game]
+                self._game_result = {game.get('game_id'): game.get('score') for game in self.next_game}
+
+    def __repr__(self):
+        attrs = [
+            f"length={self._length}",
+            f"positions={json.dumps(self._positions, indent=2)}",
+            f'leagues={json.dumps(self._leagues, indent=2)}',
+            f"games_played={json.dumps(self._games_played, indent=2)}",
+            f"wins={json.dumps(self._wins, indent=2)}",
+            f"wins_percentage={json.dumps(self._wins_percentage, indent=2)}",
+            f"losses={json.dumps(self._losses, indent=2)}",
+            f"loss_percentage={json.dumps(self._loss_percentage, indent=2)}",
+            f"game_ids={json.dumps(self._game_ids, indent=2)}",
+            f"timestamps={json.dumps(self._timestamps, indent=2)}",
+            f"teams={json.dumps(self._teams, indent=2)}",
+            f"vs={json.dumps(self._vs, indent=2)}",
+            f"status={json.dumps(self._status, indent=2)}",
+            f"game_result={json.dumps(self._game_result, indent=2)}"
+        ]
+        joined = "\t\n".join(attrs)
+        return f"Sport(\n{joined})"
+
+    def build_standings(self):
+        #counter = 0
+        position = []
+        regular_season_check = (
+            "MLB - Regular Season", 
+            "NBA - Regular Season",
+            "NHL - Regular Season",
+            "NFL - Regular Season"
+        )
+        # Can Be Empty Must try and except for that
+        for pos in self.main_sport['standings'].get('response')[0]:
+            if not pos.get('stage') in regular_season_check:
+                continue
+            position.append({'name': pos.get('team').get('name'),
+                    'position': pos.get('position'),
+                    'league': pos.get('group').get('name'),
+                    'games': pos.get('games')
+                    })
+        return position
+
+    def build_nextgame(self):
+        main = []
+        for game in self.main_sport['next_game'].get('response'):
+            main.append({
+                'game_id': game.get('id'),
+                'timestamp': game.get('timestamp'),
+                'status': game['status']['short'],
+                'teams': game['teams'],
+                'score': game['scores']
+            })
+        return main
+
+    def set_error(self):
+        if isinstance(self.main_sport['standings']['errors'], list):
+            return True, ""
+        else:
+            return False, self.main_sport['standings']['errors']['requests']
+    
+    @property
+    def get_sport(self):
+        return self._sport
+
+    @property
+    def get_error(self):
+        return self._error
+    
+    @property 
+    def get_length_position_teams(self):
+        return len(self.standings)
+    
+    @property
+    def get_standings(self):
+        return self.standings
+    
+    @property 
+    def get_position_teams(self):
+        return self._positions
+    
+    @property
+    def get_leagues(self):
+        return self._leagues
+    
+    @property
+    def get_games_played(self):
+        return self._games_played
+    
+    @property
+    def get_wins(self):
+        return self._wins
+    
+    @property
+    def get_wins_percentage(self):
+        return self._wins_percentage
+    
+    @property
+    def get_losses(self):
+        return self._losses
+    
+    @property
+    def get_loss_percentage(self):
+        return self._loss_percentage
+
+    @property 
+    def get_game_ids(self):
+        return self._game_ids
+    
+    @property
+    def get_timestamps(self):
+        return self._timestamps
+    
+    @property
+    def get_teams(self):
+        return self._teams
+    
+    @property
+    def get_versus(self):
+        return self._vs
+    
+    @property
+    def get_status(self):
+        return self._status
+    
+    @property
+    def get_scores(self):
+        return self._game_result
+    
+    def get_specific_score(self, game_id):
+        return self._game_result.get(game_id)
+    

lib/sports/apisports/result.py

@@ -0,0 +1,6 @@
+from lib.run import Runner, Caller
+
+class SportBase(Runner):
+    pass 
+class SportResultBase(Caller):
+    pass