Merge pull request vuejs#2 from American-Soccer-Analysis/python-package

Use dataframes instead of dictionaries to perform ID lookup

Author: bgrnwd

.github/workflows/python-tests.yml

@@ -7,7 +7,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.6, 3.7, 3.8, 3.9]
+        python-version: [3.7, 3.8, 3.9]
 
     steps:
       - uses: actions/checkout@v2
@@ -22,8 +22,8 @@ jobs:
           if [ -f requirements.dev.txt ]; then pip install -r requirements.dev.txt; fi
       - name: Test with pytest
         run: |
-          pytest tests/python/
+          pytest python-package/tests/
       - name: Behave tests
         run: |
-          cd tests
+          cd python-package/tests
           behave

README.md

@@ -1,3 +1,3 @@
-# asa-package
+# itscalledsoccer
 
 R and Python packages that wrap the ASA API

python-package/itscalledsoccer/client.py

@@ -1,9 +1,9 @@
-from os import name
-import re
 import requests
 from typing import Dict, List, Any, Union
 from cachecontrol import CacheControl
 from fuzzywuzzy import fuzz, process
+import pandas as pd
+import json
 
 
 class AmericanSoccerAnalysis:
@@ -20,34 +20,31 @@ def __init__(self) -> None:
 
         self.session = CACHE_SESSION
         self.base_url = self.BASE_URL
-        self.players = self._get_all_ids("player")
-        self.teams = self._get_all_ids("team")
-        self.stadia = self._get_all_ids("stadia")
-        self.managers = self._get_all_ids("manager")
-        self.referees = self._get_all_ids("referee")
-
-    def _get_all_ids(self, type: str) -> Dict[str, str]:
-        """Creates a dictionary where keys are names and values
-        are corresponding ids.
-
-        :param type: type of ids to get
-        :returns: dictionary
+        self.players = self._get_all("player")
+        self.teams = self._get_all("team")
+        self.stadia = self._get_all("stadia")
+        self.managers = self._get_all("manager")
+        self.referees = self._get_all("referee")
+
+    def _get_all(self, type: str) -> pd.DataFrame:
+        """Gets all the data for a specific type and
+        stores it in a dataframe.
+
+        :param type: type of data to get
+        :returns: dataframe
         """
-        all_ids = {}
+        df = pd.DataFrame([])
         for league in self.LEAGUES:
             if type == "stadia":
-                url = f"{self.BASE_URL}{league}/{type}"
-                type = "stadium"
+                url = f"{self.BASE_URL}{league}/stadia"
             else:
                 url = f"{self.BASE_URL}{league}/{type}s"
             response = self.session.get(url).json()
-            for resp in response:
-                name = resp.get(f"{type}_name", "None")
-                name_id = resp.get(f"{type}_id", "None")
-                all_ids.update({name: name_id})
-            if type == "stadium":
-                type = "stadia"
-        return all_ids
+            # Convert list of objects to JSON
+            resp_df = pd.read_json(json.dumps(response, default=lambda x: x.__dict__))
+            resp_df = resp_df.assign(competition=league)
+            df = df.append(resp_df)
+        return df
 
     def _convert_name_to_id(self, type: str, name: str) -> Union[str, int]:
         """Converts the name of a player, manager, stadium, referee or team
@@ -60,31 +57,31 @@ def _convert_name_to_id(self, type: str, name: str) -> Union[str, int]:
         min_score = 70
         if type == "player":
             lookup = self.players
-            names = self.players.keys()
+            names = self.players["player_name"].to_list()
         elif type == "manager":
             lookup = self.managers
-            names = self.managers.keys()
+            names = self.managers["manager_name"].to_list()
         elif type == "stadium":
             lookup = self.stadia
-            names = self.stadia.keys()
+            names = self.stadia["stadium_name"].to_list()
         elif type == "referee":
             lookup = self.referees
-            names = self.referees.keys()
+            names = self.referees["referee_name"].to_list()
         elif type == "team":
             lookup = self.teams
-            names = self.teams.keys()
+            names = self.teams["team_name"].to_list()
 
         matches = process.extractOne(name, names, scorer=fuzz.partial_ratio)
         if matches:
-            if matches[1] > min_score:
-                lookup_id = matches[0]
+            if matches[1] >= min_score:
+                name = matches[0]
             else:
-                print(f"No match found for {name}")
+                print(f"No match found for {name} due to score")
                 return ""
         else:
             print(f"No match found for {name}")
             return ""
-        matched_id = lookup.get(lookup_id)
+        matched_id = lookup.loc[lookup[f"{type}_name"] == name, f"{type}_id"].iloc[0]
         return matched_id
 
     def _convert_names_to_ids(
@@ -106,101 +103,161 @@ def _convert_names_to_ids(
                 ids.append(self._convert_name_to_id(type, n))
             return ids
 
+    def _check_leagues(self, leagues: Union[str, List[str]]):
+        """Validates the leagues parameter
+
+        :param leagues: league abbreviation or list of league abbreviations
+        """
+        if isinstance(leagues, list):
+            if not all(l in leagues for l in self.LEAGUES):
+                print(
+                    f"Leagues are limited only to the following options: {self.LEAGUES.join(',')}."
+                )
+                exit()
+        else:
+            if leagues not in self.LEAGUES:
+                print(
+                    f"Leagues are limited only to the following options: {self.LEAGUES.join(',')}."
+                )
+                exit()
+
+    def _check_ids_names(
+        self, ids: Union[str, List[str]], names: Union[str, List[str]]
+    ):
+        """Makes sure only ids or names are passed to a function and verifies
+        they are the right data type.
+
+        :param ids: a single id or list of ids
+        :param names: a single name or list of names
+        """
+        if ids and names:
+            print("Please specify only IDs or names, not both.")
+            exit()
+
+        if ids:
+            if not isinstance(ids, str) and not isinstance(ids, list):
+                print("IDs must be passed as a string or list of strings.")
+                exit()
+
+        if names:
+            if not isinstance(names, str) and not isinstance(names, list):
+                print("Names must be passed as a string or list of names.")
+                exit()
+
+    def _filter_entity(
+        self,
+        entity_all: pd.DataFrame,
+        entity_type: str,
+        leagues: Union[str, List[str]],
+        ids: Union[str, List[str]] = None,
+        names: Union[str, List[str]] = None,
+    ) -> List[Dict[str, Any]]:
+        """Filters a dataframe based on the arguments given.
+
+        :param entity_all: a dataframe containing the complete set of data
+        :param entity_type: the type of data
+        :param ids: a single id or list of ids
+        :param names: a single name or list of names
+        :returns: list of dictionaries, e.g. a dataframe converted to JSON
+        """
+        self._check_leagues(leagues)
+        self._check_ids_names(ids, names)
+
+        entity = entity_all
+
+        if names:
+            converted_ids = self._convert_names_to_ids(entity_type, names)
+        else:
+            converted_ids = ids
+
+        if isinstance(leagues, str):
+            leagues = [leagues]
+        if isinstance(converted_ids, str):
+            converted_ids = [converted_ids]
+
+        entity = entity[entity["competition"].isin(leagues)]
+
+        if converted_ids:
+            entity = entity[entity[f"{entity_type}_id"].isin(converted_ids)]
+
+        return entity.to_json(orient="records")
+
     def get_stadia(
-        self, league: str, names: Union[str, List[str]] = None
+        self,
+        leagues: Union[str, List[str]],
+        ids: Union[str, List[str]] = None,
+        names: Union[str, List[str]] = None,
     ) -> List[Dict[str, Any]]:
         """Get information associated with stadia
 
-        :param league: league abbreviation
+        :param leagues: league abbreviation or a list of league abbreviations
+        :param ids: a single stadium id or a list of stadia ids (optional)
         :param names: a single stadium name or a list of stadia names (optional)
         :returns: list of dictionaries
         """
-        ids = self._convert_names_to_ids("stadium", names)
-        if isinstance(ids, str):
-            stadia_url = f"{self.base_url}{league}/stadia?stadium_id={ids}"
-        elif isinstance(ids, list):
-            stadia_url = f"{self.base_url}{league}/stadia?stadium_id={','.join(ids)}"
-        else:
-            stadia_url = f"{self.base_url}{league}/stadia"
-        response = self.session.get(stadia_url)
-        return response.json()
+        stadia = self._filter_entity(self.stadia, "stadium", leagues, ids, names)
+        return stadia
 
     def get_referees(
-        self, league: str, names: Union[str, List[str]] = None
+        self,
+        leagues: Union[str, List[str]],
+        ids: Union[str, List[str]] = None,
+        names: Union[str, List[str]] = None,
     ) -> List[Dict[str, Any]]:
         """Get information associated with referees
 
-        :param league: league abbreviation
+        :param leagues: league abbreviation or a list of league abbreviations
+        :param ids: a single referee id or a list of referee ids (optional)
         :param names: a single referee name or a list of referee names (optional)
         :returns: list of dictionaries
         """
-        ids = self._convert_names_to_ids("referee", names)
-        if isinstance(ids, str):
-            referees_url = f"{self.base_url}{league}/referees?referee_id={ids}"
-        elif isinstance(ids, list):
-            referees_url = (
-                f"{self.base_url}{league}/referees?referee_id={','.join(ids)}"
-            )
-        else:
-            referees_url = f"{self.base_url}{league}/referees"
-        response = self.session.get(referees_url)
-        return response.json()
+        referees = self._filter_entity(self.referees, "referee", leagues, ids, names)
+        return referees
 
     def get_managers(
-        self, league: str, names: Union[str, List[str]] = None
+        self,
+        leagues: Union[str, List[str]],
+        ids: Union[str, List[str]] = None,
+        names: Union[str, List[str]] = None,
     ) -> List[Dict[str, Any]]:
         """Get information associated with managers
 
-        :param league: league abbreviation
-        :param names: a single manager name or list of manager names (optional)
+        :param leagues: league abbreviation or a list of league abbreviations
+        :param ids: a single referee id or a list of referee ids (optional)
+        :param names: a single referee name or a list of referee names (optional)
         :returns: list of dictionaries
         """
-        ids = self._convert_names_to_ids("manager", names)
-        if isinstance(ids, str):
-            managers_url = f"{self.base_url}{league}/managers?manager_id={ids}"
-        elif isinstance(ids, list):
-            managers_url = (
-                f"{self.base_url}{league}/managers?manager_id={','.join(ids)}"
-            )
-        else:
-            managers_url = f"{self.base_url}{league}/managers"
-        response = self.session.get(managers_url)
-        return response.json()
+        managers = self._filter_entity(self.managers, "manager", leagues, ids, names)
+        return managers
 
     def get_teams(
-        self, league: str, names: Union[str, List[str]]
+        self,
+        leagues: Union[str, List[str]],
+        ids: Union[str, List[str]] = None,
+        names: Union[str, List[str]] = None,
     ) -> List[Dict[str, Any]]:
         """Get information associated with teams
 
-        :param league: league abbreviation
-        :param names: a single team name or list of team names (optional)
+        :param leagues: league abbreviation or a list of league abbreviations
+        :param ids: a single team id or a list of team ids (optional)
+        :param names: a single team name or a list of team names (optional)
         :returns: list of dictionaries
         """
-        ids = self._convert_names_to_ids("team", names)
-        if isinstance(ids, str):
-            teams_url = f"{self.base_url}{league}/teams?team_id={ids}"
-        if isinstance(ids, list):
-            teams_url = f"{self.base_url}{league}/teams?team_id={','.join(ids)}"
-        else:
-            teams_url = f"{self.base_url}{league}/teams"
-        response = self.session.get(teams_url)
-        return response.json()
+        teams = self._filter_entity(self.teams, "team", leagues, ids, names)
+        return teams
 
     def get_players(
-        self, league: str, names: Union[str, List[str]]
+        self,
+        leagues: Union[str, List[str]],
+        ids: Union[str, List[str]] = None,
+        names: Union[str, List[str]] = None,
     ) -> List[Dict[str, Any]]:
         """Get information associated with players
 
-        :param league: league abbreviation
-        :param names: a single player name or list of player names (optional)
+        :param league: league abbreviation or a list of league abbreviations
+        :param ids: a single player id or a list of player ids (optional)
+        :param names: a single player name or a list of player names (optional)
         :returns: list of dictionaries
         """
-        ids = self._convert_names_to_ids("player", names)
-        if isinstance(ids, str):
-            players_url = f"{self.base_url}{league}/players?player_id={ids}"
-        if isinstance(ids, list):
-            players_url = f"{self.base_url}{league}/players?player_id={','.join(ids)}"
-        else:
-            players_url = f"{self.base_url}{league}/players"
-        response = self.session.get(players_url)
-        return response.json()
+        players = self._filter_entity(self.players, "player", leagues, ids, names)
+        return players

python-package/requirements.dev.txt

@@ -3,4 +3,5 @@ CacheControl==0.12.6
 fuzzywuzzy==0.18.0
 python-Levenshtein==0.12.2
 behave==1.2.6
-pytest==6.2.4
+pytest==6.2.4
+pandas==1.3.1

python-package/requirements.txt

@@ -1,4 +1,5 @@
 requests==2.25.1
 CacheControl==0.12.6
 fuzzywuzzy==0.18.0
-python-Levenshtein==0.12.2
+python-Levenshtein==0.12.2
+pandas==1.3.1

python-package/setup.py

@@ -10,13 +10,13 @@
     long_description=long_description,
     author="American Soccer Analysis",
     author_email="[email protected]",
-    url="https://github.com/American-Soccer-Analysis/asa-package",
+    url="https://github.com/American-Soccer-Analysis/itscalledsoccer",
     classifiers=[
         "Programming Language :: Python",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.6",
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
     ],
     python_requires=">=3.6",
     keywords="stats soccer api american machine learning football",