nhl-api-py 2.1.1__tar.gz → 2.2.4__tar.gz

{nhl_api_py-2.1.1 → nhl_api_py-2.2.4}/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.1
 Name: nhl-api-py
-Version: 2.1.1
+Version: 2.2.4
 Summary: NHL API.  For standings, team stats, outcomes, player information.  Contains each individual API endpoint as well as convience methods for easy data loading in Pandas or any ML applications.
 Home-page: https://github.com/coreyjs/nhl-api-py
 License: GPL-3.0-or-later
 Keywords: nhl,api,wrapper,hockey,sports
 Author: Corey Schaf
 Author-email: cschaf@gmail.com
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{nhl_api_py-2.1.1 → nhl_api_py-2.2.4}/nhlpy/_version.py

@@ -1,3 +1,3 @@
 # Should this be driven by the main pyproject.toml file? yes, is it super convoluted? yes, can it wait? sure
 
-__version__ = "2.1.1"
+__version__ = "2.2.4"

nhl_api_py-2.2.4/nhlpy/api/misc.py

@@ -0,0 +1,45 @@
+from typing import List
+
+from nhlpy.http_client import HttpClient
+
+
+class Misc:
+    def __init__(self, http_client: HttpClient) -> None:
+        self.client = http_client
+
+    def glossary(self) -> List[dict]:
+        """
+        Get the glossary for the NHL API.
+        :return: dict
+        """
+        return self.client.get_by_url(full_resource="https://api.nhle.com/stats/rest/en/glossary?sort=fullName").json()[
+            "data"
+        ]
+
+    def config(self) -> dict:
+        """
+        Seems to be various options for the filters?.
+        :return: dict
+        """
+        return self.client.get_by_url(full_resource="https://api.nhle.com/stats/rest/en/config").json()
+
+    def countries(self) -> List[dict]:
+        """
+        Get the countries for the NHL API.
+        :return: dict
+        """
+        return self.client.get_by_url(full_resource="https://api.nhle.com/stats/rest/en/country").json()["data"]
+
+    def season_specific_rules_and_info(self) -> List[dict]:
+        """
+        Get the season specific rules and info for the NHL API.
+        :return: dict
+        """
+        return self.client.get_by_url(full_resource="https://api.nhle.com/stats/rest/en/season").json()["data"]
+
+    def draft_year_and_rounds(self) -> List[dict]:
+        """
+        Get the draft year and rounds for the NHL API.  This only has "id", "draftYear" and "rounds count".
+        :return: dict
+        """
+        return self.client.get_by_url(full_resource="https://api.nhle.com/stats/rest/en/draft").json()["data"]

{nhl_api_py-2.1.1 → nhl_api_py-2.2.4}/nhlpy/api/schedule.py

@@ -29,13 +29,15 @@ class Schedule:
         resource = f"club-schedule/{team_abbr}/month/{month if month else 'now'}"
         return self.client.get(resource=resource).json()["games"]
 
-    def get_schedule_by_team_by_week(self, team_abbr: str) -> List[dict]:
+    def get_schedule_by_team_by_week(self, team_abbr: str, date: Optional[str] = None) -> List[dict]:
         """
-        This returns the schedule for the team (team_abbr) for the current week.
+        This returns the schedule for the team (team_abbr) for the week set or the current week if no week is specified.
+
+        :param date: Optional date, in which to search the week of.  In format YYYY-MM-DD.  Example "2024-02-10".
         :param team_abbr: The 3 letter abbreviation of the team.  BUF, TOR, etc
         :return:
         """
-        resource = f"club-schedule/{team_abbr}/week/now"
+        resource = f"club-schedule/{team_abbr}/week/{date if date else 'now'}"
         return self.client.get(resource=resource).json()["games"]
 
     def get_season_schedule(self, team_abbr: str, season: str) -> dict:

{nhl_api_py-2.1.1 → nhl_api_py-2.2.4}/nhlpy/api/standings.py

@@ -1,3 +1,5 @@
+import importlib.resources
+
 from typing import List, Optional
 
 
@@ -21,10 +23,9 @@ class Standings:
             if cache:
                 # load json from data/seasonal_information_manifest.json
                 import json
-                import os
 
-                with open(os.path.join(os.getcwd(), "nhlpy/data/seasonal_information_manifest.json"), "r") as f:
-                    seasons = json.load(f)["seasons"]
+                data_resource = importlib.resources.files("nhlpy") / "data"
+                seasons = json.loads((data_resource / "seasonal_information_manifest.json").read_text())["seasons"]
             else:
                 seasons = self.season_standing_manifest()
 

nhl_api_py-2.2.4/nhlpy/api/stats.py

@@ -0,0 +1,202 @@
+import urllib.parse
+import json
+from typing import List
+
+
+from nhlpy.http_client import HttpClient
+
+
+class Stats:
+    def __init__(self, http_client: HttpClient):
+        self.client = http_client
+
+    def club_stats_season(self, team_abbr: str) -> dict:
+        """
+        This seems to return gameTypes for every season the team was in existence.  Maybe its useful?
+        :param team_abbr: The 3 letter abbreviation of the team.  BUF, TOR, etc
+        :return: dict
+        """
+        return self.client.get(resource=f"club-stats-season/{team_abbr}").json()
+
+    def player_career_stats(self, player_id: int) -> dict:
+        """
+        This returns the career stats for a player as well as player information.
+
+        example: https://api-web.nhle.com/v1/player/8481528/landing
+
+        :param player_id: The player_id for the player you want the stats for.
+        :return: dict
+        """
+        return self.client.get(resource=f"player/{player_id}/landing").json()
+
+    def team_summary(
+        self,
+        start_season: str,
+        end_season: str,
+        game_type_id: int = 2,
+        is_game: bool = False,
+        is_aggregate: bool = False,
+        sort_expr: List[dict] = None,
+        start: int = 0,
+        limit: int = 50,
+        fact_cayenne_exp: str = "gamesPlayed>1",
+        default_cayenne_exp: str = None,
+    ) -> List[dict]:
+        """
+        Example: c.stats.team_summary(start_season="20202021", end_season="20212022", game_type_id=2)
+                 c.stats.team_summary(start_season="20202021", end_season="20212022")
+        :param start_season: Season id, in format 20202021, 20212022, etc, that will be the start of the range.  This
+            allows for searching over multiple season.  If you just want one season, set start_season and end_season.
+        :param end_season: Season id for the end range.
+        :param game_type_id: 2 is for regular season, 3 is for playoffs.  I think 1 is for preseason.
+        :param is_game: (dev notes: not sure what this is, its part of the api call)
+        :param is_aggregate:
+        :param sort_expr: A list of key/value pairs of properties and their sort direction.  For Example this defaults
+            to [
+            {"property":"points","direction":"DESC"},
+            {"property":"wins","direction":"DESC"},
+            {"property":"teamId","direction":"ASC"}
+            ]
+        :param start:
+        :param limit:
+        :param fact_cayenne_exp:  An expression used by apache cayenne.  This defaults to 'gamesPlayed>=1'.
+            You can experiment at will, this was taken from the nhl.com website.
+        :param default_cayenne_exp: Similar to above, I believe this provides a filter for the data returned.
+            This will look something like: "gameTypeId=2 and seasonId<=20232024 and seasonId>=20232024".
+
+            If this value is supplied, it will override a generated one, giving the user ability to experiment.
+        :return:
+        """
+        q_params = {
+            "isAggregate": is_aggregate,
+            "isGame": is_game,
+            "start": start,
+            "limit": limit,
+            "factCayenneExp": fact_cayenne_exp,
+        }
+
+        if not sort_expr:
+            sort_expr = [
+                {"property": "points", "direction": "DESC"},
+                {"property": "wins", "direction": "DESC"},
+                {"property": "teamId", "direction": "ASC"},
+            ]
+        q_params["sort"] = urllib.parse.quote(json.dumps(sort_expr))
+
+        if not default_cayenne_exp:
+            default_cayenne_exp = f"gameTypeId={game_type_id} and seasonId<={end_season} and seasonId>={start_season}"
+        q_params["cayenneExp"] = default_cayenne_exp
+
+        return self.client.get_by_url("https://api.nhle.com/stats/rest/en/team/summary", query_params=q_params).json()[
+            "data"
+        ]
+
+    def skater_stats_summary(
+        self,
+        start_season: str,
+        end_season: str,
+        franchise_id: int = None,
+        game_type_id: int = 2,
+        aggregate: bool = False,
+        sort_expr: List[dict] = None,
+        start: int = 0,
+        limit: int = 70,
+        fact_cayenne_exp: str = "gamesPlayed>=1",
+        default_cayenne_exp: str = None,
+    ) -> List[dict]:
+        """
+        Example: c.stats.skater_stats_summary(start_season="20232024", end_season="20232024")
+                 c.stats.skater_stats_summary(franchise_id=10, start_season="20232024", end_season="20232024")
+        :param start_season: Season id, in format 20202021, 20212022, etc, that will be the start of the range.
+        :param end_season: Season id for the end range.
+        :param franchise_id: The ID of the franchise.  Not to be confused with team_id found on other endpoints.
+            This seems to be specific to the /stats apis.
+        :param game_type_id: 2 is for regular season, 3 is for playoffs.  I think 1 is for preseason.
+        :param aggregate: If doing multiple years, you can choose to aggreate the date per player, or have separate
+            entries for each one.
+        :param sort_expr: Default sorting expresions.  Provided as an array of key/value pairs.  For example:
+            [
+                {"property": "points", "direction": "DESC"},
+                {"property": "gamesPlayed", "direction": "ASC"},
+                {"property": "playerId", "direction": "ASC"}
+            ]
+        :param start: Possibly start of the retrived data, based on limit.
+        :param limit: How many to return.
+        :param fact_cayenne_exp: An anchor expression almost, default criteria.  Only players with more than 1 game
+            played.  I default this to gamesPlayed>=1, which is what the nhl.com site uses.  But you can play with it.
+        :param default_cayenne_exp:
+        :return:
+        """
+        q_params = {
+            "isAggregate": aggregate,
+            "isGame": False,
+            "start": start,
+            "limit": limit,
+            "factCayenneExp": fact_cayenne_exp,
+        }
+
+        if not sort_expr:
+            sort_expr = [
+                {"property": "points", "direction": "DESC"},
+                {"property": "gamesPlayed", "direction": "ASC"},
+                {"property": "playerId", "direction": "ASC"},
+            ]
+        q_params["sort"] = urllib.parse.quote(json.dumps(sort_expr))
+
+        if not default_cayenne_exp:
+            default_cayenne_exp = f"gameTypeId={game_type_id} and seasonId<={end_season} and seasonId>={start_season}"
+            if franchise_id:
+                default_cayenne_exp = f"franchiseId={franchise_id} and {default_cayenne_exp}"
+        q_params["cayenneExp"] = default_cayenne_exp
+
+        return self.client.get_by_url("https://api.nhle.com/stats/rest/en/skater/summary", query_params=q_params).json()[
+            "data"
+        ]
+
+    def skater_stats_summary_by_expression(
+        self,
+        cayenne_exp: str,
+        sort_expr: List[dict],
+        aggregate: bool = False,
+        start: int = 0,
+        limit: int = 70,
+        fact_cayenne_exp: str = "gamesPlayed>=1",
+    ) -> dict:
+        """
+        A more bare bones / raw version of skater_stats_summary.  This allows for more flexibility in the query params.
+        You must supply your own cayenne expressions and sort expressions.
+
+        example:
+            sort_expr = [
+                {"property": "points", "direction": "DESC"},
+                {"property": "gamesPlayed", "direction": "ASC"},
+                {"property": "playerId", "direction": "ASC"}
+                ]
+            cayenne_exp = "gameTypeId=2 and seasonId<=20232024 and seasonId>=20232024"
+            client.stats.skater_stats_summary_by_expression(cayenne_exp=expr, sort_expr=sort_expr)
+
+        :param aggregate: bool - If doing multiple years, you can choose to aggreate the date per player,
+            or have separate entries for each one.
+        :param sort_expr: A list of key/value pairs for sort criteria.  As used in skater_stats_summary(), this is
+            in the format:
+            [
+                {"property": "points", "direction": "DESC"},
+                {"property": "gamesPlayed", "direction": "ASC"},
+                {"property": "playerId", "direction": "ASC"}
+            ]
+        :param start:
+        :param limit:
+        :param fact_cayenne_exp:
+        :param default_cayenne_exp:
+        :return:
+        """
+        q_params = {
+            "isAggregate": aggregate,
+            "isGame": False,
+            "start": start,
+            "limit": limit,
+            "factCayenneExp": fact_cayenne_exp,
+        }
+        q_params["sort"] = urllib.parse.quote(json.dumps(sort_expr))
+        q_params["cayenneExp"] = cayenne_exp
+        return self.client.get_by_url("https://api.nhle.com/stats/rest/en/skater/summary", query_params=q_params).json()

nhl_api_py-2.2.4/nhlpy/api/teams.py

@@ -0,0 +1,56 @@
+import json
+import importlib.resources
+from warnings import warn
+from typing import List
+
+from nhlpy.http_client import HttpClient
+
+
+class Teams:
+    def __init__(self, http_client: HttpClient) -> None:
+        self.client = http_client
+        self.base_url = "https://api.nhle.com"
+        self.api_ver = "/stats/rest/"
+
+    # todo deprecate this
+    def team_stats_summary(self, lang="en") -> List[dict]:
+        """
+        I really don't know what this endpoint does.  It returns a list of dicts with team stats.
+        :param lang: Language param.  'en' for English, 'fr' for French
+        :return:
+        """
+        warn(
+            "This endpoint will be deprecated in the future.  Use stats.team_summary() instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self.client.get_by_url(full_resource=f"{self.base_url}{self.api_ver}{lang}/team/summary").json()["data"]
+
+    def teams_info(self) -> dict:
+        """
+        Returns a list of dicts with all the teams info.  This is loaded via a harccoded json file.
+        :return: dict
+        """
+
+        # with importlib.resources.files("nhlpy.data", "teams_20232024.json") as f:
+        #     return json.load(f)['teams']
+
+        data_resource = importlib.resources.files("nhlpy") / "data"
+        teams_info = json.loads((data_resource / "teams_20232024.json").read_text())["teams"]
+        return teams_info
+
+    def roster(self, team_abbr: str, season: str) -> dict:
+        """
+        Returns the roster for the given team and season.
+        :param team_abbr: Team abbreviation.  BUF, TOR, etc
+        :param season: Season in format YYYYYYYY.  20202021, 20212022, etc
+        :return:
+        """
+        return self.client.get(resource=f"roster/{team_abbr}/{season}").json()
+
+    def all_franchises(self) -> List[dict]:
+        """
+        Returns a list of all past and current NHL franchises.  This includes ones long forgotten.
+        :return:
+        """
+        return self.client.get_by_url(full_resource="https://api.nhle.com/stats/rest/en/franchise").json()["data"]

nhl_api_py-2.2.4/nhlpy/data/team_stat_ids.json

@@ -0,0 +1,239 @@
+{
+	"data": [
+		{
+			"id": 1,
+			"fullName": "Montréal Canadiens",
+			"teamCommonName": "Canadiens",
+			"teamPlaceName": "Montréal"
+		},
+		{
+			"id": 2,
+			"fullName": "Montreal Wanderers",
+			"teamCommonName": "Wanderers",
+			"teamPlaceName": "Montreal"
+		},
+		{
+			"id": 3,
+			"fullName": "St. Louis Eagles",
+			"teamCommonName": "Eagles",
+			"teamPlaceName": "St. Louis"
+		},
+		{
+			"id": 4,
+			"fullName": "Hamilton Tigers",
+			"teamCommonName": "Tigers",
+			"teamPlaceName": "Hamilton"
+		},
+		{
+			"id": 5,
+			"fullName": "Toronto Maple Leafs",
+			"teamCommonName": "Maple Leafs",
+			"teamPlaceName": "Toronto"
+		},
+		{
+			"id": 6,
+			"fullName": "Boston Bruins",
+			"teamCommonName": "Bruins",
+			"teamPlaceName": "Boston"
+		},
+		{
+			"id": 7,
+			"fullName": "Montreal Maroons",
+			"teamCommonName": "Maroons",
+			"teamPlaceName": "Montreal"
+		},
+		{
+			"id": 8,
+			"fullName": "Brooklyn Americans",
+			"teamCommonName": "Americans",
+			"teamPlaceName": "Brooklyn"
+		},
+		{
+			"id": 9,
+			"fullName": "Philadelphia Quakers",
+			"teamCommonName": "Quakers",
+			"teamPlaceName": "Philadelphia"
+		},
+		{
+			"id": 10,
+			"fullName": "New York Rangers",
+			"teamCommonName": "Rangers",
+			"teamPlaceName": "New York"
+		},
+		{
+			"id": 11,
+			"fullName": "Chicago Blackhawks",
+			"teamCommonName": "Blackhawks",
+			"teamPlaceName": "Chicago"
+		},
+		{
+			"id": 12,
+			"fullName": "Detroit Red Wings",
+			"teamCommonName": "Red Wings",
+			"teamPlaceName": "Detroit"
+		},
+		{
+			"id": 13,
+			"fullName": "Cleveland Barons",
+			"teamCommonName": "Barons",
+			"teamPlaceName": "Cleveland"
+		},
+		{
+			"id": 14,
+			"fullName": "Los Angeles Kings",
+			"teamCommonName": "Kings",
+			"teamPlaceName": "Los Angeles"
+		},
+		{
+			"id": 15,
+			"fullName": "Dallas Stars",
+			"teamCommonName": "Stars",
+			"teamPlaceName": "Dallas"
+		},
+		{
+			"id": 16,
+			"fullName": "Philadelphia Flyers",
+			"teamCommonName": "Flyers",
+			"teamPlaceName": "Philadelphia"
+		},
+		{
+			"id": 17,
+			"fullName": "Pittsburgh Penguins",
+			"teamCommonName": "Penguins",
+			"teamPlaceName": "Pittsburgh"
+		},
+		{
+			"id": 18,
+			"fullName": "St. Louis Blues",
+			"teamCommonName": "Blues",
+			"teamPlaceName": "St. Louis"
+		},
+		{
+			"id": 19,
+			"fullName": "Buffalo Sabres",
+			"teamCommonName": "Sabres",
+			"teamPlaceName": "Buffalo"
+		},
+		{
+			"id": 20,
+			"fullName": "Vancouver Canucks",
+			"teamCommonName": "Canucks",
+			"teamPlaceName": "Vancouver"
+		},
+		{
+			"id": 21,
+			"fullName": "Calgary Flames",
+			"teamCommonName": "Flames",
+			"teamPlaceName": "Calgary"
+		},
+		{
+			"id": 22,
+			"fullName": "New York Islanders",
+			"teamCommonName": "Islanders",
+			"teamPlaceName": "New York"
+		},
+		{
+			"id": 23,
+			"fullName": "New Jersey Devils",
+			"teamCommonName": "Devils",
+			"teamPlaceName": "New Jersey"
+		},
+		{
+			"id": 24,
+			"fullName": "Washington Capitals",
+			"teamCommonName": "Capitals",
+			"teamPlaceName": "Washington"
+		},
+		{
+			"id": 25,
+			"fullName": "Edmonton Oilers",
+			"teamCommonName": "Oilers",
+			"teamPlaceName": "Edmonton"
+		},
+		{
+			"id": 26,
+			"fullName": "Carolina Hurricanes",
+			"teamCommonName": "Hurricanes",
+			"teamPlaceName": "Carolina"
+		},
+		{
+			"id": 27,
+			"fullName": "Colorado Avalanche",
+			"teamCommonName": "Avalanche",
+			"teamPlaceName": "Colorado"
+		},
+		{
+			"id": 28,
+			"fullName": "Arizona Coyotes",
+			"teamCommonName": "Coyotes",
+			"teamPlaceName": "Arizona"
+		},
+		{
+			"id": 29,
+			"fullName": "San Jose Sharks",
+			"teamCommonName": "Sharks",
+			"teamPlaceName": "San Jose"
+		},
+		{
+			"id": 30,
+			"fullName": "Ottawa Senators",
+			"teamCommonName": "Senators",
+			"teamPlaceName": "Ottawa"
+		},
+		{
+			"id": 31,
+			"fullName": "Tampa Bay Lightning",
+			"teamCommonName": "Lightning",
+			"teamPlaceName": "Tampa Bay"
+		},
+		{
+			"id": 32,
+			"fullName": "Anaheim Ducks",
+			"teamCommonName": "Ducks",
+			"teamPlaceName": "Anaheim"
+		},
+		{
+			"id": 33,
+			"fullName": "Florida Panthers",
+			"teamCommonName": "Panthers",
+			"teamPlaceName": "Florida"
+		},
+		{
+			"id": 34,
+			"fullName": "Nashville Predators",
+			"teamCommonName": "Predators",
+			"teamPlaceName": "Nashville"
+		},
+		{
+			"id": 35,
+			"fullName": "Winnipeg Jets",
+			"teamCommonName": "Jets",
+			"teamPlaceName": "Winnipeg"
+		},
+		{
+			"id": 36,
+			"fullName": "Columbus Blue Jackets",
+			"teamCommonName": "Blue Jackets",
+			"teamPlaceName": "Columbus"
+		},
+		{
+			"id": 37,
+			"fullName": "Minnesota Wild",
+			"teamCommonName": "Wild",
+			"teamPlaceName": "Minnesota"
+		},
+		{
+			"id": 38,
+			"fullName": "Vegas Golden Knights",
+			"teamCommonName": "Golden Knights",
+			"teamPlaceName": "Vegas"
+		},
+		{
+			"id": 39,
+			"fullName": "Seattle Kraken",
+			"teamCommonName": "Kraken",
+			"teamPlaceName": "Seattle"
+		}
+	],
+	"total": 39
+}

{nhl_api_py-2.1.1 → nhl_api_py-2.2.4}/nhlpy/http_client.py

@@ -23,13 +23,14 @@ class HttpClient:
 
         return r
 
-    def get_by_url(self, full_resource: str) -> httpx.request:
+    def get_by_url(self, full_resource: str, query_params: dict = None) -> httpx.request:
         """
         Private method to make a get request to any HTTP resource.  This wraps the lib httpx functionality.
+        :param query_params:
         :param full_resource:  The full resource to get.
         :return:
         """
-        r: httpx.request = httpx.get(url=full_resource, follow_redirects=True)
+        r: httpx.request = httpx.get(url=full_resource, params=query_params, follow_redirects=True)
 
         if self._config.verbose:
             logging.info(f"API URL: {r.url}")

{nhl_api_py-2.1.1 → nhl_api_py-2.2.4}/nhlpy/nhl_client.py

@@ -1,4 +1,4 @@
-from nhlpy.api import teams, standings, schedule, game_center
+from nhlpy.api import teams, standings, schedule, game_center, stats, misc
 from nhlpy.http_client import HttpClient
 from nhlpy.config import ClientConfig
 
@@ -24,3 +24,5 @@ class NHLClient:
         self.standings = standings.Standings(http_client=self._http_client)
         self.schedule = schedule.Schedule(http_client=self._http_client)
         self.game_center = game_center.GameCenter(http_client=self._http_client)
+        self.stats = stats.Stats(http_client=self._http_client)
+        self.misc = misc.Misc(http_client=self._http_client)

{nhl_api_py-2.1.1 → nhl_api_py-2.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "nhl-api-py"
-version = "2.1.1"
+version = "2.2.4"
 description = "NHL API.  For standings, team stats, outcomes, player information.  Contains each individual API endpoint as well as convience methods for easy data loading in Pandas or any ML applications."
 authors = ["Corey Schaf <cschaf@gmail.com>"]
 readme = "README.md"
@@ -30,7 +30,7 @@ include = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.10"
+python = "^3.9"
 httpx = "*"
 
 [tool.poetry.group.dev.dependencies]

nhl_api_py-2.1.1/nhlpy/api/teams.py

@@ -1,30 +0,0 @@
-import json
-import importlib.resources
-
-from typing import List
-
-from nhlpy.http_client import HttpClient
-
-
-class Teams:
-    def __init__(self, http_client: HttpClient) -> None:
-        self.client = http_client
-        self.base_url = "https://api.nhle.com"
-        self.api_ver = "/stats/rest/"
-
-    def team_stats_summary(self, lang="en") -> List[dict]:
-        """
-        I really dont know what this endpoint does.  It returns a list of dicts with team stats.
-        :param lang: Language param.  'en' for English, 'fr' for French
-        :return:
-        """
-        return self.client.get_by_url(full_resource=f"{self.base_url}{self.api_ver}{lang}/team/summary").json()["data"]
-
-    def teams_info(self) -> dict:
-        """
-        Returns a list of dicts with all the teams info.  This is loaded via a harccoded json file.
-        :return: dict
-        """
-
-        with importlib.resources.open_text("nhlpy.data", "teams_20232024.json") as f:
-            return json.load(f)