puckapi 0.1.0__py3-none-any.whl

puckapi/client.py

@@ -0,0 +1,892 @@
+"""Generated by packages/python/generate.py from the PuckAPI OpenAPI spec. Do not edit by hand."""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Literal, Optional, Union
+
+from ._core import BaseClient
+
+#: Credits each tool costs, from the spec.
+TOOLS: Dict[str, int] = {
+    "get_standings": 2,
+    "get_team_stats": 5,
+    "list_teams": 1,
+    "get_games": 5,
+    "get_schedule": 2,
+    "get_game_detail": 10,
+    "get_head_to_head": 10,
+    "search_players": 2,
+    "get_player_stats": 5,
+    "get_goalie_stats": 5,
+    "get_skater_season_stats": 5,
+    "get_player_game_log": 5,
+    "get_odds": 10,
+    "get_line_movement": 25,
+    "get_player_props": 10,
+    "get_prop_history": 10,
+    "get_plays": 10,
+    "get_shot_map": 10,
+    "get_shifts": 10,
+    "get_situation_time": 10,
+}
+
+
+class Client(BaseClient):
+    """Client for the PuckAPI API (NHL).
+
+    Create one with ``Client()`` (reads PUCKAPI_API_KEY) or ``Client(api_key="...")``.
+    Every method returns the unwrapped ``data`` from the response.
+    ``last_credits_used`` and ``last_credits_remaining`` hold the counters from
+    the most recent response.
+    """
+
+    def get_standings(
+        self,
+        *,
+        conference: Optional[Literal["Eastern", "Western"]] = None,
+        division: Optional[str] = None,
+        season: Optional[str] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Standings.
+
+        Use when checking where teams rank in their division or conference. Returns points, wins,
+        losses, OT losses, point%, goal differential, goals for/against per game, and 5v5 possession:
+        Corsi%, Fenwick% and expected goals for and against. The possession columns are 5v5 only, so
+        they will not match a goalie's expected goals against, which covers every strength. Defaults to
+        the most recent season with standings. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            conference (optional): Filter by conference. One of: Eastern, Western.
+            division (optional): Filter by division (e.g. Atlantic, Metropolitan, Central, Pacific)
+            season (optional): Season ID, 8-digit (e.g. 20242025 for 2024-25). 2024-25 and 2024-2025
+                also accepted. Defaults to current season.
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_standings",
+            {
+                "conference": conference,
+                "division": division,
+                "season": season,
+                "league": league,
+            },
+        )
+
+    def get_team_stats(
+        self,
+        team: str,
+        *,
+        season: Optional[str] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Team stats.
+
+        Use when you need full details for one team: record, goals for and against, league rank, and 5v5
+        possession (Corsi%, Fenwick%, expected goals for and against). Possession is 5v5 only. Requires
+        a team abbreviation (use list_teams if unsure). Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            team: Team abbreviation (e.g. BUF, TOR, NYR)
+            season (optional): Season ID, 8-digit (e.g. 20242025 for 2024-25). 2024-25 and 2024-2025
+                also accepted. Defaults to current season.
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_team_stats",
+            {
+                "team": team,
+                "season": season,
+                "league": league,
+            },
+        )
+
+    def list_teams(
+        self,
+        *,
+        conference: Optional[Literal["Eastern", "Western"]] = None,
+        division: Optional[str] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """List teams.
+
+        Use when you need team abbreviations, or to see all 32 active NHL teams with city, conference,
+        division, and arena. Excludes historical franchises (ATL, ARI). Cheapest tool at 1 credit.
+
+        Costs 1 credit per call.
+
+        Args:
+            conference (optional): Filter by conference. One of: Eastern, Western.
+            division (optional): Filter by division
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "list_teams",
+            {
+                "conference": conference,
+                "division": division,
+                "league": league,
+            },
+        )
+
+    def get_games(
+        self,
+        *,
+        date_from: Optional[str] = None,
+        date_to: Optional[str] = None,
+        team: Optional[str] = None,
+        season: Optional[str] = None,
+        game_state: Optional[Literal["FUT", "LIVE", "FINAL", "OFF"]] = None,
+        game_type: Optional[Literal["regular", "playoff", "preseason"]] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Games.
+
+        Use when querying past or future games with filters. Returns scores, teams, venue, and game
+        metadata. For upcoming-only games, prefer get_schedule (2 cr) instead. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            date_from (optional): Start date (YYYY-MM-DD)
+            date_to (optional): End date (YYYY-MM-DD)
+            team (optional): Team abbreviation to filter (home or away)
+            season (optional): Season ID, 8-digit (e.g. 20242025 for 2024-25). 2024-25 and 2024-2025
+                also accepted.
+            game_state (optional): Filter by game state. FINAL and OFF both mean finished and return the
+                same games; FUT is scheduled, LIVE in progress.
+            game_type (optional): Filter by game type. One of: regular, playoff, preseason.
+            limit (optional): Max results (default 100)
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_games",
+            {
+                "date_from": date_from,
+                "date_to": date_to,
+                "team": team,
+                "season": season,
+                "game_state": game_state,
+                "game_type": game_type,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def get_schedule(
+        self,
+        *,
+        team: Optional[str] = None,
+        days: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Schedule.
+
+        Use when checking what games are coming up. Returns only unplayed future games for the next N
+        days (default 7). For past games, use get_games instead. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            team (optional): Team abbreviation to filter
+            days (optional): Number of days ahead to look (default 7)
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_schedule",
+            {
+                "team": team,
+                "days": days,
+                "league": league,
+            },
+        )
+
+    def get_game_detail(
+        self,
+        game_id: str,
+        *,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Game detail.
+
+        Use when you need everything about one game: both teams' full info, all betting odds, and the
+        goalies who started, with their time on ice. Requires a game ID (get one from get_games or
+        get_schedule). Odds for every game from 2019-20 on (and part of the 2019 playoffs). Goalie
+        starts are derived from play-by-play, so they are available for played games, not upcoming ones.
+        Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id: NHL game ID (e.g. 2025020887)
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_game_detail",
+            {
+                "game_id": game_id,
+                "league": league,
+            },
+        )
+
+    def get_head_to_head(
+        self,
+        team1: str,
+        team2: str,
+        *,
+        season: Optional[str] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Head to head.
+
+        Use when comparing two teams' history. Returns recent matchups with win/loss record. Can filter
+        by season or get all-time. Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            team1: First team abbreviation (e.g. BUF)
+            team2: Second team abbreviation (e.g. TOR)
+            season (optional): Season ID, 8-digit (e.g. 20242025 for 2024-25). 2024-25 and 2024-2025
+                also accepted. Omit for all-time.
+            limit (optional): Max games to return (default 20)
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_head_to_head",
+            {
+                "team1": team1,
+                "team2": team2,
+                "season": season,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def search_players(
+        self,
+        query: str,
+        *,
+        team: Optional[str] = None,
+        position: Optional[Literal["G", "D", "C", "LW", "RW"]] = None,
+        active: Optional[bool] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Search players.
+
+        Use when looking up a player by name. Searches 4,900+ players across every season since 2010-11.
+        Returns active players by default; set active=false for retired/historical. Use the returned
+        player ID with get_player_stats for full details. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            query: Player name to search for (partial match supported)
+            team (optional): Filter by team abbreviation
+            position (optional): Filter by position. One of: G, D, C, LW, RW.
+            active (optional): Filter by active status (default: true). Set false to search active plus
+                retired/historical players.
+            limit (optional): Max results (default 10)
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "search_players",
+            {
+                "query": query,
+                "team": team,
+                "position": position,
+                "active": active,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def get_player_stats(
+        self,
+        player_id: int,
+        *,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Player stats.
+
+        Use when you need full details for one player: bio, team, physical attributes, and headshot. For
+        skaters, also returns the latest season line (games, goals, assists, points, +/-, PP/SH,
+        shooting%, TOI). For goalies, save%, GAA, GSAX, and trend data. Requires player ID from
+        search_players. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            player_id: NHL player ID
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_player_stats",
+            {
+                "player_id": player_id,
+                "league": league,
+            },
+        )
+
+    def get_goalie_stats(
+        self,
+        *,
+        team: Optional[str] = None,
+        season: Optional[str] = None,
+        min_games: Optional[int] = None,
+        sort_by: Optional[Literal["save_pct", "gaa", "gsax", "wins"]] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Goalie stats.
+
+        Use when ranking goalies or comparing goalie performance. Returns a leaderboard sorted by save%,
+        GAA, GSAX, or wins, with a games-played filter. Includes goals saved above expected, high-danger
+        save%, rolling save% and GSAX over the last 10 appearances, form trend and rest days. Goalie
+        expected goals cover every strength, unlike the 5v5-only team possession columns. Costs 5
+        credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            team (optional): Filter by team abbreviation
+            season (optional): Season ID, 8-digit (e.g. 20242025 for 2024-25). 2024-25 and 2024-2025
+                also accepted. Defaults to the most recent season with stats, which is the current
+                season once it is under way and the previous one before that. The season actually used
+                is echoed in filters.season.
+            min_games (optional): Minimum games played (default 10)
+            sort_by (optional): Sort metric (default save_pct). gsax is goals saved above expected. One
+                of: save_pct, gaa, gsax, wins.
+            limit (optional): Max results (default 20)
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_goalie_stats",
+            {
+                "team": team,
+                "season": season,
+                "min_games": min_games,
+                "sort_by": sort_by,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def get_skater_season_stats(
+        self,
+        *,
+        team: Optional[str] = None,
+        season: Optional[str] = None,
+        min_games: Optional[int] = None,
+        sort_by: Optional[Literal["points", "goals", "assists", "plus_minus", "shots"]] = None,
+        limit: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Skater season stats.
+
+        Use when ranking skaters or comparing scoring. Returns a leaderboard sorted by points, goals,
+        assists, plus/minus, or shots, with a games-played filter. Includes power play and shorthanded
+        production, shooting%, faceoff%, and average time on ice. Seasons from 2010-11 on. Costs 5
+        credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            team (optional): Filter by team abbreviation
+            season (optional): Season ID, 8-digit (e.g. 20242025 for 2024-25). 2024-25 and 2024-2025
+                also accepted. Defaults to the most recent season with stats, which is the current
+                season once it is under way and the previous one before that. The season actually used
+                is echoed in filters.season.
+            min_games (optional): Minimum games played (default 10)
+            sort_by (optional): Sort metric (default points). One of: points, goals, assists,
+                plus_minus, shots.
+            limit (optional): Max results (default 20)
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_skater_season_stats",
+            {
+                "team": team,
+                "season": season,
+                "min_games": min_games,
+                "sort_by": sort_by,
+                "limit": limit,
+                "league": league,
+            },
+        )
+
+    def get_player_game_log(
+        self,
+        player_id: int,
+        *,
+        season: Optional[str] = None,
+        game_type: Optional[Literal["regular", "playoff", "preseason", "all"]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Player game log.
+
+        Use when you need a player's game-by-game stat lines for a season, not a season total. For
+        skaters: date, opponent, home/away, goals, assists, points, shots, PIM and power-play points for
+        each game. For goalies: date, opponent, home/away, decision, shots against, saves, goals against
+        and save% for each game. Built from play-by-play, so time on ice and plus/minus are not
+        available and come back null; goalie time on ice is available only for games the goalie started.
+        Requires player ID from search_players. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            player_id: NHL player ID
+            season (optional): Season ID, 8-digit (e.g. 20242025 for 2024-25). 2024-25 and 2024-2025
+                also accepted. Defaults to the most recent season with stats for this player, which is
+                the current season once it is under way and the previous one before that. The season
+                actually used is echoed back in the response.
+            game_type (optional): Which games to include: regular, playoff, preseason, or all. Defaults
+                to regular, matching every other stats tool.
+            limit (optional): Max games to return (default 100)
+            offset (optional): Pagination offset
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_player_game_log",
+            {
+                "player_id": player_id,
+                "season": season,
+                "game_type": game_type,
+                "limit": limit,
+                "offset": offset,
+                "league": league,
+            },
+        )
+
+    def get_odds(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        season: Optional[str] = None,
+        team: Optional[str] = None,
+        bookmaker: Optional[str] = None,
+        snapshot_type: Optional[Literal["opening", "closing"]] = None,
+        all_books: Optional[bool] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        estimate_only: Optional[bool] = None,
+    ) -> Any:
+        """Odds.
+
+        Use when checking betting lines. Pass game_id for one game (10 credits): moneyline, puck line
+        and total by bookmaker, opening and closing. Or pass season (optionally with team) for a whole
+        season of closing lines in one call, with final scores, at 10 credits per game returned (a full
+        season is ~13,700 credits, a team-season ~820), 100 games a page by default (up to 500). Each
+        book's line is an array in the order given by columns. Set estimate_only to get the price
+        without being charged. Every game from 2019-20 on (and part of the 2019 playoffs): about 16 to
+        18 books a game from 2020-21 to 2023-24, about 6 in 2019-20, 8 in 2024-25 and 2025-26 (60+ on
+        about 300 games in 2025-26), with all_books; a season answer defaults to the four main books. A
+        season those four do not carry (2019-20) returns every book it has. Each line says its source:
+        the_odds_api (our Odds API pulls, from August 2020) or espn (ESPN's per-book lines); a season
+        answer lists each game's sources.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): NHL game ID (e.g. 2025020887). Omit and pass season for a whole season.
+            season (optional): Season for a whole season of lines, e.g. 2025-26 or 20252026. Used when
+                game_id is not set.
+            team (optional): With season: only this team's games (abbreviation, e.g. BUF).
+            bookmaker (optional): Filter by bookmaker key (e.g. draftkings, fanduel, betmgm). Lowercase.
+            snapshot_type (optional): opening (game-day morning; for a game not yet played, the latest
+                morning line) or closing (final pre-game). Single game: default both. Season: default
+                closing.
+            all_books (optional): With season: every book held (16 to 18 a game from 2020-21 to 2023-24,
+                8 in 2024-25, more than 60 on about 300 games in 2025-26) instead of DraftKings,
+                FanDuel, BetMGM and ESPN BET.
+            limit (optional): With season: games per page (default 100, max 500).
+            offset (optional): With season: page offset; use next_offset from the previous page.
+            estimate_only (optional): Return what this call would cost, without charging or running it.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_odds",
+            {
+                "game_id": game_id,
+                "season": season,
+                "team": team,
+                "bookmaker": bookmaker,
+                "snapshot_type": snapshot_type,
+                "all_books": all_books,
+                "limit": limit,
+                "offset": offset,
+                "estimate_only": estimate_only,
+            },
+        )
+
+    def get_line_movement(
+        self,
+        game_id: str,
+        *,
+        bookmaker: Optional[str] = None,
+    ) -> Any:
+        """Line movement.
+
+        Use when analyzing how betting lines moved over time. Returns time-series snapshots grouped by
+        bookmaker. Most expensive tool (25 cr). If you only need current lines, use get_odds (10 cr)
+        instead.
+
+        Costs 25 credits per call.
+
+        Args:
+            game_id: NHL game ID
+            bookmaker (optional): Filter by specific bookmaker key (lowercase)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_line_movement",
+            {
+                "game_id": game_id,
+                "bookmaker": bookmaker,
+            },
+        )
+
+    def get_player_props(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        player_id: Optional[Union[int, float, str]] = None,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        market: Optional[Literal["player_points", "player_goals", "player_assists", "player_shots_on_goal", "player_blocked_shots", "player_total_saves", "player_goal_scorer_anytime"]] = None,
+        bookmaker: Optional[str] = None,
+        snapshot_type: Optional[Literal["opening", "closing"]] = None,
+        estimate_only: Optional[bool] = None,
+    ) -> Any:
+        """Player props.
+
+        Use for player prop lines by sportsbook: over/under on points, goals, assists, shots on goal,
+        blocked shots, goalie saves and anytime goal scorer, from May 2023 (DraftKings, FanDuel, BetMGM,
+        ESPN BET, Pinnacle and others). Pass game_id for every player's props in one game (10 credits),
+        or player_id with from_date (and to_date) for one player across games (10 credits per game
+        returned, up to 100). Returns the closing line by default (the last before the game starts) or
+        the opening line, with each book's over and under prices. Set estimate_only to get the price
+        without being charged.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): Game id: every player's props for that game.
+            player_id (optional): Player id (e.g. 8478402) from search_players. With from_date: that
+                player's props across games.
+            from_date (optional): With player_id: first date, YYYY-MM-DD (the game's date).
+            to_date (optional): With player_id: last date (default: no end), YYYY-MM-DD (the game's
+                date).
+            market (optional): One market: player_points (points), player_goals (goals), player_assists
+                (assists), player_shots_on_goal (shots on goal), player_blocked_shots (blocked shots),
+                player_total_saves (goalie saves), player_goal_scorer_anytime (anytime goal scorer (over
+                = scores))
+            bookmaker (optional): Bookmaker key, e.g. draftkings, fanduel, pinnacle.
+            snapshot_type (optional): closing (default): the last line before the game starts. opening:
+                the first one captured.
+            estimate_only (optional): Return what this call would cost, without charging or running it.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_player_props",
+            {
+                "game_id": game_id,
+                "player_id": player_id,
+                "from_date": from_date,
+                "to_date": to_date,
+                "market": market,
+                "bookmaker": bookmaker,
+                "snapshot_type": snapshot_type,
+                "estimate_only": estimate_only,
+            },
+        )
+
+    def get_prop_history(
+        self,
+        player_id: Union[int, float, str],
+        market: Literal["player_points", "player_goals", "player_assists", "player_shots_on_goal", "player_blocked_shots", "player_total_saves", "player_goal_scorer_anytime"],
+        *,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        bookmaker: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> Any:
+        """Prop history.
+
+        Use to see how a player did against his prop line over time: for one market (points, goals,
+        assists, shots on goal, blocked shots, goalie saves or anytime goal scorer), one row per game
+        with the closing line (the median across books, or one book's), the opening line, the prices,
+        what the player actually recorded from our box scores and the result against the line, plus the
+        over rate. Costs 10 credits for up to 200 games.
+
+        Costs 10 credits per call.
+
+        Args:
+            player_id: Player id (e.g. 8478402) from search_players.
+            market: The market: player_points (points), player_goals (goals), player_assists (assists),
+                player_shots_on_goal (shots on goal), player_blocked_shots (blocked shots),
+                player_total_saves (goalie saves), player_goal_scorer_anytime (anytime goal scorer (over
+                = scores))
+            from_date (optional): First date, YYYY-MM-DD (the game's date).
+            to_date (optional): Last date, YYYY-MM-DD (the game's date).
+            bookmaker (optional): One book's closing line instead of the median across books, e.g.
+                draftkings.
+            limit (optional): Games to return, oldest first (default 50, max 200). next_from_date says
+                where to continue.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_prop_history",
+            {
+                "player_id": player_id,
+                "market": market,
+                "from_date": from_date,
+                "to_date": to_date,
+                "bookmaker": bookmaker,
+                "limit": limit,
+            },
+        )
+
+    def get_plays(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        season: Optional[str] = None,
+        team: Optional[str] = None,
+        player_id: Optional[int] = None,
+        type: Optional[Literal["goal", "shot-on-goal", "missed-shot", "blocked-shot", "faceoff", "hit", "giveaway", "takeaway", "penalty", "delayed-penalty", "stoppage", "period-start", "period-end", "game-end", "shootout-complete", "failed-shot-attempt"]] = None,
+        strength: Optional[str] = None,
+        zone: Optional[Literal["O", "N", "D"]] = None,
+        period: Optional[int] = None,
+        shot_attempts_only: Optional[bool] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "whl", "qmjhl", "echl", "ahl", "ushl"]] = None,
+    ) -> Any:
+        """Plays.
+
+        Use for play-by-play events: goals, shots, misses, blocks, faceoffs, hits, giveaways, takeaways,
+        penalties, with rink coordinates, strength state (5v5, 5v4), zone, and the players involved.
+        Filter by game, season, team, player (any role), event type, strength, zone, or period. Requires
+        at least one of game_id, season or player_id. Paginate with offset. Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): NHL game ID (e.g. 2025020887)
+            season (optional): Season ID, 8-digit (e.g. 20242025).
+            team (optional): Team abbreviation that owns the event (e.g. BUF)
+            player_id (optional): NHL player ID; matches the player in any role on the event
+            type (optional): Event type. One of: goal, shot-on-goal, missed-shot, blocked-shot, faceoff,
+                hit, giveaway, takeaway, penalty, delayed-penalty, stoppage, period-start, period-end,
+                game-end, shootout-complete, failed-shot-attempt.
+            strength (optional): Skater strength from the event owner's view, e.g. 5v5, 5v4, 4v5
+            zone (optional): Zone: O offensive, N neutral, D defensive
+            period (optional): Period number (4+ is overtime)
+            shot_attempts_only (optional): Only goals, shots on goal, missed shots and blocked shots
+                (Corsi events)
+            limit (optional): Max events (default 200)
+            offset (optional): Pagination offset
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, whl, qmjhl, echl, ahl,
+                ushl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_plays",
+            {
+                "game_id": game_id,
+                "season": season,
+                "team": team,
+                "player_id": player_id,
+                "type": type,
+                "strength": strength,
+                "zone": zone,
+                "period": period,
+                "shot_attempts_only": shot_attempts_only,
+                "limit": limit,
+                "offset": offset,
+                "league": league,
+            },
+        )
+
+    def get_shot_map(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        season: Optional[str] = None,
+        team: Optional[str] = None,
+        player_id: Optional[int] = None,
+        strength: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        league: Optional[Literal["nhl", "pwhl", "ohl", "qmjhl", "echl", "ahl"]] = None,
+    ) -> Any:
+        """Shot map.
+
+        Use when you want shot locations rather than a list of events: every shot attempt with rink
+        coordinates, shot type, strength, shooter and goalie. Filter by game, or by season plus a team
+        or player. Paginated: follow next_offset, since a season runs past one page and pages are
+        chronological. Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): NHL game ID
+            season (optional): Season ID, 8-digit (e.g. 20242025); use with team
+            team (optional): Team abbreviation; use with season
+            player_id (optional): NHL player ID of the shooter
+            strength (optional): Strength filter, e.g. 5v5
+            limit (optional): Max shots per page (default 1000)
+            offset (optional): Pagination offset; follow next_offset for a full season
+            league (optional): League. Defaults to nhl. One of: nhl, pwhl, ohl, qmjhl, echl, ahl.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_shot_map",
+            {
+                "game_id": game_id,
+                "season": season,
+                "team": team,
+                "player_id": player_id,
+                "strength": strength,
+                "limit": limit,
+                "offset": offset,
+                "league": league,
+            },
+        )
+
+    def get_shifts(
+        self,
+        game_id: str,
+        *,
+        team: Optional[str] = None,
+        player_id: Optional[int] = None,
+    ) -> Any:
+        """Shifts.
+
+        Use for who was on the ice and when: every player's shifts in one NHL game, each with period,
+        start and end (period clock and seconds from the opening faceoff) and duration, plus the
+        official boxscore time on ice and plus/minus. Filter to one team or player. NHL games from
+        2010-11 on. Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id: NHL game ID, 10 digits (e.g. 2026020084)
+            team (optional): Only this team's players, by abbreviation (e.g. WSH)
+            player_id (optional): Only this player, by NHL player ID
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_shifts",
+            {
+                "game_id": game_id,
+                "team": team,
+                "player_id": player_id,
+            },
+        )
+
+    def get_situation_time(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        date: Optional[str] = None,
+        include_players: Optional[bool] = None,
+    ) -> Any:
+        """Situation time.
+
+        Use for exact time at each strength: the seconds each team spent at 5v5, 5v4, 4v5, 4v4, 6v5 with
+        the goalie pulled and every other on-ice state in an NHL game, split into regulation and
+        overtime, from the shift charts. Also even / power-play / shorthanded totals, goalie-pulled
+        seconds, period lengths and a completeness check against the play-by-play. include_players adds
+        each skater's time by strength. One game by game_id (10 credits), or every game on a date (10
+        credits per game). NHL games from 2010-11 on.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): NHL game ID, 10 digits (e.g. 2026020084)
+            date (optional): Every game played on this date, YYYY-MM-DD (instead of game_id)
+            include_players (optional): Add each skater's seconds by strength (default false)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_situation_time",
+            {
+                "game_id": game_id,
+                "date": date,
+                "include_players": include_players,
+            },
+        )