endzoneapi 0.1.0__py3-none-any.whl

endzoneapi/client.py

@@ -0,0 +1,880 @@
+"""Generated by packages/python/generate.py from the EndzoneAPI 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] = {
+    "list_teams": 1,
+    "get_standings": 2,
+    "get_team_stats": 5,
+    "get_games": 5,
+    "get_schedule": 2,
+    "get_game_detail": 10,
+    "get_head_to_head": 10,
+    "search_players": 2,
+    "get_player_stats": 5,
+    "get_player_leaders": 5,
+    "get_injuries": 2,
+    "get_depth_chart": 2,
+    "get_snap_counts": 5,
+    "get_plays": 10,
+    "get_advanced_stats": 5,
+    "get_odds": 10,
+    "get_line_movement": 25,
+    "get_player_props": 10,
+    "get_prop_history": 10,
+    "get_alt_lines": 10,
+}
+
+
+class Client(BaseClient):
+    """Client for the EndzoneAPI API (NFL).
+
+    Create one with ``Client()`` (reads ENDZONEAPI_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 list_teams(
+        self,
+        *,
+        conference: Optional[Literal["AFC", "NFC"]] = None,
+        division: Optional[str] = None,
+    ) -> Any:
+        """List teams.
+
+        Use when you need team codes, or all 32 current teams with conference, division, colours, and
+        logo URLs. Team codes are nflverse spelling (LA for the Rams, WAS for Washington). Cheapest tool
+        at 1 credit.
+
+        Costs 1 credit per call.
+
+        Args:
+            conference (optional): Filter by conference. One of: AFC, NFC.
+            division (optional): Filter by division, e.g. 'AFC East' or 'NFC West'
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "list_teams",
+            {
+                "conference": conference,
+                "division": division,
+            },
+        )
+
+    def get_standings(
+        self,
+        *,
+        season: Optional[Union[str, int, float]] = None,
+        conference: Optional[Literal["AFC", "NFC"]] = None,
+        division: Optional[str] = None,
+    ) -> Any:
+        """Standings.
+
+        Use for regular-season standings and playoff seeding: record, win%, points for/against,
+        home/away/division/conference records, streak, division rank, and conference seed. Ranks apply
+        the real NFL tiebreaking procedure and report which step decided each one. Computed from final
+        scores. Defaults to the current season. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            season (optional): Season year the regular season starts (e.g. 2025). Defaults to current.
+            conference (optional): Filter by conference. One of: AFC, NFC.
+            division (optional): Filter by division, e.g. 'NFC North'
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_standings",
+            {
+                "season": season,
+                "conference": conference,
+                "division": division,
+            },
+        )
+
+    def get_team_stats(
+        self,
+        team: str,
+        *,
+        season: Optional[Union[str, int, float]] = None,
+        season_type: Optional[Literal["REG", "POST"]] = None,
+    ) -> Any:
+        """Team stats.
+
+        Use for one team's season: totals (passing, rushing, receiving, defense, kicking, penalties),
+        EPA per play, yards per attempt/carry, the standings row, and every weekly stat line. Costs 5
+        credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            team: Team code (e.g. KC, BUF, PHI)
+            season (optional): Season year (e.g. 2025). Defaults to current.
+            season_type (optional): Regular season (default) or postseason. One of: REG, POST.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_team_stats",
+            {
+                "team": team,
+                "season": season,
+                "season_type": season_type,
+            },
+        )
+
+    def get_games(
+        self,
+        *,
+        season: Optional[Union[str, int, float]] = None,
+        week: Optional[int] = None,
+        team: Optional[str] = None,
+        date_from: Optional[str] = None,
+        date_to: Optional[str] = None,
+        game_type: Optional[Literal["REG", "WC", "DIV", "CON", "SB", "POST"]] = None,
+        status: Optional[Literal["FUT", "LIVE", "FINAL"]] = None,
+        limit: Optional[int] = None,
+    ) -> Any:
+        """Games.
+
+        Use when querying past or future games with filters: season, week, team, date range, game type,
+        status. Returns scores, kickoff (UTC), venue, rest days, starting QBs, coaches, referee, and the
+        consensus closing spread, total, and moneylines. For upcoming-only games prefer get_schedule (2
+        cr). Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            season (optional): Season year (e.g. 2025)
+            week (optional): Week number (1-18 regular season; 19+ postseason)
+            team (optional): Team code (home or away)
+            date_from (optional): Start date YYYY-MM-DD
+            date_to (optional): End date YYYY-MM-DD
+            game_type (optional): REG, WC, DIV, CON, SB, or POST for any playoff game
+            status (optional): Game status. One of: FUT, LIVE, FINAL.
+            limit (optional): Max results (default 100)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_games",
+            {
+                "season": season,
+                "week": week,
+                "team": team,
+                "date_from": date_from,
+                "date_to": date_to,
+                "game_type": game_type,
+                "status": status,
+                "limit": limit,
+            },
+        )
+
+    def get_schedule(
+        self,
+        *,
+        team: Optional[str] = None,
+        week: Optional[int] = None,
+        days: Optional[int] = None,
+    ) -> Any:
+        """Schedule.
+
+        Use to see what is coming up: unplayed games in the next N days (default 7), or a specific week
+        of the current season. Includes consensus lines where posted. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            team (optional): Team code to filter
+            week (optional): A specific week of the current season (returns all games that week, played
+                or not)
+            days (optional): Days ahead to look when week is not set (default 7)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_schedule",
+            {
+                "team": team,
+                "week": week,
+                "days": days,
+            },
+        )
+
+    def get_game_detail(
+        self,
+        game_id: str,
+    ) -> Any:
+        """Game detail.
+
+        Use when you need everything about one game: both teams, full team box-score stats (EPA,
+        success, drives), consensus closing line, per-bookmaker opening/closing/latest odds, weather,
+        surface, and officials. Requires a game id from get_games or get_schedule. Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id: Game id, e.g. 2025_01_KC_BUF
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_game_detail",
+            {
+                "game_id": game_id,
+            },
+        )
+
+    def get_head_to_head(
+        self,
+        team1: str,
+        team2: str,
+        *,
+        season: Optional[Union[str, int, float]] = None,
+        limit: Optional[int] = None,
+    ) -> Any:
+        """Head to head.
+
+        Use to compare two teams' history: recent meetings with scores, the win/loss record between
+        them, and average margin. Filter by season or get all-time. Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            team1: First team code
+            team2: Second team code
+            season (optional): Season year. Omit for all-time.
+            limit (optional): Max games (default 20)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_head_to_head",
+            {
+                "team1": team1,
+                "team2": team2,
+                "season": season,
+                "limit": limit,
+            },
+        )
+
+    def search_players(
+        self,
+        query: str,
+        *,
+        team: Optional[str] = None,
+        position: Optional[str] = None,
+        active: Optional[bool] = None,
+        limit: Optional[int] = None,
+    ) -> Any:
+        """Search players.
+
+        Use to find a player by name (partial match). Searches ~25,000 players back to 1999; returns
+        current-season players by default, falling back to all players back to 1999 when none match.
+        Returns the GSIS player id needed by get_player_stats. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            query: Player name or part of it
+            team (optional): Filter by current team code
+            position (optional): Filter by position (e.g. QB, RB, WR, TE, OL, DL, LB, DB)
+            active (optional): Default true, but an active-only search that finds nobody automatically
+                falls back to all players and says so. Set false to search everyone outright.
+            limit (optional): Max results (default 10)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "search_players",
+            {
+                "query": query,
+                "team": team,
+                "position": position,
+                "active": active,
+                "limit": limit,
+            },
+        )
+
+    def get_player_stats(
+        self,
+        player_id: str,
+        *,
+        season: Optional[Union[str, int, float]] = None,
+        season_type: Optional[Literal["REG", "POST"]] = None,
+    ) -> Any:
+        """Player stats.
+
+        Use for one player: bio, draft, physicals, headshot, id crosswalk (PFR, ESPN), summed season
+        totals across passing, rushing, receiving, defense, kicking, returns, and fantasy points, every
+        weekly stat line for the season, and games played per season. Defaults to the player's latest
+        season. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            player_id: GSIS player id from search_players (e.g. 00-0033873)
+            season (optional): Season year. Defaults to the player's latest season.
+            season_type (optional): Regular season (default) or postseason. One of: REG, POST.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_player_stats",
+            {
+                "player_id": player_id,
+                "season": season,
+                "season_type": season_type,
+            },
+        )
+
+    def get_player_leaders(
+        self,
+        stat: str,
+        *,
+        season: Optional[Union[str, int, float]] = None,
+        season_type: Optional[Literal["REG", "POST"]] = None,
+        position: Optional[str] = None,
+        team: Optional[str] = None,
+        min_games: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> Any:
+        """Player leaders.
+
+        Use to rank players on any weekly stat over a season: passing_yards, passing_tds, rushing_yards,
+        receiving_yards, receptions, targets, def_sacks, def_interceptions, fantasy_points_ppr,
+        passing_epa, rushing_epa, receiving_epa, and ~130 more. Counting stats are summed, rate stats
+        averaged. Filter by position, team, minimum games. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            stat: Weekly stat column to rank by (e.g. passing_yards, receiving_epa, def_sacks)
+            season (optional): Season year. Defaults to current.
+            season_type (optional): Regular season (default) or postseason. One of: REG, POST.
+            position (optional): Position filter, e.g. QB, RB, WR, TE
+            team (optional): Team code filter
+            min_games (optional): Minimum games with a stat line (default 1)
+            limit (optional): Max results (default 20)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_player_leaders",
+            {
+                "stat": stat,
+                "season": season,
+                "season_type": season_type,
+                "position": position,
+                "team": team,
+                "min_games": min_games,
+                "limit": limit,
+            },
+        )
+
+    def get_injuries(
+        self,
+        *,
+        team: Optional[str] = None,
+        season: Optional[Union[str, int, float]] = None,
+        week: Optional[int] = None,
+        status: Optional[str] = None,
+    ) -> Any:
+        """Injuries.
+
+        Use for the official injury report: game status (Out, Doubtful, Questionable) and practice
+        participation with the injury named, by team and week. Defaults to the latest reported week of
+        the current season. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            team (optional): Team code
+            season (optional): Season year. Defaults to current.
+            week (optional): Week. Defaults to the latest week with a report.
+            status (optional): Filter by game status: Out, Doubtful, Questionable
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_injuries",
+            {
+                "team": team,
+                "season": season,
+                "week": week,
+                "status": status,
+            },
+        )
+
+    def get_depth_chart(
+        self,
+        team: str,
+        *,
+        season: Optional[Union[str, int, float]] = None,
+        week: Optional[int] = None,
+        formation: Optional[str] = None,
+    ) -> Any:
+        """Depth chart.
+
+        Use for a team's depth chart by week: formation, position, depth rank, player. Defaults to the
+        latest week available. Costs 2 credits.
+
+        Costs 2 credits per call.
+
+        Args:
+            team: Team code
+            season (optional): Season year. Defaults to current.
+            week (optional): Week. Defaults to latest.
+            formation (optional): Filter by formation/unit, e.g. Offense, Defense, Special Teams
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_depth_chart",
+            {
+                "team": team,
+                "season": season,
+                "week": week,
+                "formation": formation,
+            },
+        )
+
+    def get_snap_counts(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        player_id: Optional[str] = None,
+        team: Optional[str] = None,
+        season: Optional[Union[str, int, float]] = None,
+        week: Optional[int] = None,
+        limit: Optional[int] = None,
+    ) -> Any:
+        """Snap counts.
+
+        Use for playing time: offensive, defensive, and special-teams snaps and snap shares, for one
+        game, one player (PFR id), or a team's season. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            game_id (optional): Game id, e.g. 2025_01_KC_BUF
+            player_id (optional): PFR player id (from search_players pfr_id)
+            team (optional): Team code
+            season (optional): Season year (with team or player)
+            week (optional): Week filter
+            limit (optional): Max rows (default 200)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_snap_counts",
+            {
+                "game_id": game_id,
+                "player_id": player_id,
+                "team": team,
+                "season": season,
+                "week": week,
+                "limit": limit,
+            },
+        )
+
+    def get_plays(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        season: Optional[Union[str, int, float]] = None,
+        week: Optional[int] = None,
+        posteam: Optional[str] = None,
+        defteam: Optional[str] = None,
+        play_type: Optional[Literal["pass", "run", "punt", "kickoff", "field_goal", "extra_point", "qb_kneel", "qb_spike", "no_play"]] = None,
+        down: Optional[int] = None,
+        quarter: Optional[int] = None,
+        passer_id: Optional[str] = None,
+        rusher_id: Optional[str] = None,
+        receiver_id: Optional[str] = None,
+        min_wp: Optional[float] = None,
+        max_wp: Optional[float] = None,
+        red_zone: Optional[bool] = None,
+        third_down: Optional[bool] = None,
+        include_charting: Optional[bool] = None,
+        is_play_action: Optional[bool] = None,
+        is_motion: Optional[bool] = None,
+        is_rpo: Optional[bool] = None,
+        is_screen_pass: Optional[bool] = None,
+        is_no_huddle: Optional[bool] = None,
+        is_trick_play: Optional[bool] = None,
+        is_qb_out_of_pocket: Optional[bool] = None,
+        is_drop: Optional[bool] = None,
+        min_blitzers: Optional[int] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> Any:
+        """Plays.
+
+        Use for play-by-play with nflfastR metrics: EPA, WPA, win probability, success, CPOE, air yards,
+        formation flags, and the players involved. Filter by game, or by season plus week/team/player,
+        plus play type, down, quarter, win-probability band, red zone, third down. Set include_charting
+        for FTN manual charting from 2022 on: alignment, pre-snap motion, play action, screens, run-pass
+        options, blitzer counts, drops: or filter directly on those flags. Returns a per-query EPA and
+        success-rate summary. Paginate with offset. Costs 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): Game id, e.g. 2025_01_KC_BUF
+            season (optional): Season year (required when game_id is not set)
+            week (optional): Week
+            posteam (optional): Offense team code
+            defteam (optional): Defense team code
+            play_type (optional): Play type. One of: pass, run, punt, kickoff, field_goal, extra_point,
+                qb_kneel, qb_spike, no_play.
+            down (optional): Down
+            quarter (optional): Quarter (5+ = overtime)
+            passer_id (optional): GSIS id of the passer
+            rusher_id (optional): GSIS id of the rusher
+            receiver_id (optional): GSIS id of the receiver
+            min_wp (optional): Minimum pre-play win probability for the offense
+            max_wp (optional): Maximum pre-play win probability
+            red_zone (optional): Only plays inside the 20
+            third_down (optional): Only third downs
+            include_charting (optional): Attach FTN manual charting to each play (2022+): alignment,
+                motion, play action, screens, RPO, blitzers, drops
+            is_play_action (optional): Charting filter: play action (2022+)
+            is_motion (optional): Charting filter: pre-snap motion (2022+)
+            is_rpo (optional): Charting filter: run-pass option (2022+)
+            is_screen_pass (optional): Charting filter: screen pass (2022+)
+            is_no_huddle (optional): Charting filter: no huddle (2022+)
+            is_trick_play (optional): Charting filter: trick play (2022+)
+            is_qb_out_of_pocket (optional): Charting filter: quarterback out of the pocket (2022+)
+            is_drop (optional): Charting filter: charted drop (2022+)
+            min_blitzers (optional): Charting filter: at least this many blitzers (2022+). FTN counts
+                rushers beyond the base rush, so this is typically 0-3; 5+ is almost never charted.
+            limit (optional): Max plays (default 200)
+            offset (optional): Pagination offset
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_plays",
+            {
+                "game_id": game_id,
+                "season": season,
+                "week": week,
+                "posteam": posteam,
+                "defteam": defteam,
+                "play_type": play_type,
+                "down": down,
+                "quarter": quarter,
+                "passer_id": passer_id,
+                "rusher_id": rusher_id,
+                "receiver_id": receiver_id,
+                "min_wp": min_wp,
+                "max_wp": max_wp,
+                "red_zone": red_zone,
+                "third_down": third_down,
+                "include_charting": include_charting,
+                "is_play_action": is_play_action,
+                "is_motion": is_motion,
+                "is_rpo": is_rpo,
+                "is_screen_pass": is_screen_pass,
+                "is_no_huddle": is_no_huddle,
+                "is_trick_play": is_trick_play,
+                "is_qb_out_of_pocket": is_qb_out_of_pocket,
+                "is_drop": is_drop,
+                "min_blitzers": min_blitzers,
+                "limit": limit,
+                "offset": offset,
+            },
+        )
+
+    def get_advanced_stats(
+        self,
+        source: Literal["ngs_passing", "ngs_rushing", "ngs_receiving", "pfr_passing", "pfr_rushing", "pfr_receiving", "pfr_defense"],
+        *,
+        season: Optional[Union[str, int, float]] = None,
+        week: Optional[int] = None,
+        player_id: Optional[str] = None,
+        team: Optional[str] = None,
+        limit: Optional[int] = None,
+    ) -> Any:
+        """Advanced stats.
+
+        Use for tracking and charting metrics the box score does not carry. Next Gen Stats (2016+): time
+        to throw, air yards, completion percentage above expectation, separation, cushion, rush yards
+        over expected. Pro Football Reference advanced (2018+): pressures, hurries, blitzes, drops, bad
+        throws, missed tackles, coverage yards allowed. Pick a source, then filter by season, week,
+        player or team. Costs 5 credits.
+
+        Costs 5 credits per call.
+
+        Args:
+            source: Which dataset: ngs_passing, ngs_rushing, ngs_receiving, pfr_passing, pfr_rushing,
+                pfr_receiving, pfr_defense
+            season (optional): Season year. Defaults to current. NGS from 2016, PFR from 2018.
+            week (optional): Week. NGS also publishes week 0 as the season aggregate.
+            player_id (optional): GSIS id for an ngs_* source, PFR id for a pfr_* source; both are on
+                search_players
+            team (optional): Team code
+            limit (optional): Max rows (default 50)
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_advanced_stats",
+            {
+                "source": source,
+                "season": season,
+                "week": week,
+                "player_id": player_id,
+                "team": team,
+                "limit": limit,
+            },
+        )
+
+    def get_odds(
+        self,
+        *,
+        game_id: Optional[str] = None,
+        season: Optional[Union[str, int, float]] = None,
+        team: Optional[str] = None,
+        bookmaker: Optional[str] = None,
+        snapshot_type: Optional[Literal["opening", "closing", "latest"]] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        estimate_only: Optional[bool] = None,
+    ) -> Any:
+        """Odds.
+
+        Use for betting lines. Pass game_id for one game (10 credits): the consensus closing spread and
+        total (every game since 1999; moneyline every game since 2010) plus each sportsbook's closing
+        line from the 2014 season (4-9 books for 2014-2019, closing only) and per-bookmaker opening,
+        closing and latest lines from the 2020 season (up to 8 books, including Pinnacle). Or pass
+        season (optionally team) for a season of per-book closing lines in one call, with final scores
+        and the consensus close, at 10 credits per game returned, 100 games a page by default (up to
+        500); each book's line is an array in the order given by columns. Each line says its source:
+        espn (2014-2019 closing lines) or the_odds_api (from 2020); a season answer lists each game's
+        sources. For consensus closing lines only, get_games returns a whole season for 5 credits. Set
+        estimate_only to get the price without being charged.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): Game id, e.g. 2026_01_KC_BUF. Omit and pass season for a whole season.
+            season (optional): Season year for a whole season of per-book lines, e.g. 2026. Used when
+                game_id is not set.
+            team (optional): With season: only this team's games (e.g. KC).
+            bookmaker (optional): Bookmaker key (draftkings, fanduel, betmgm, espnbet, pinnacle, bovada,
+                betonlineag, mybookieag; for 2014-2019 also westgate, caesars, wynn, unibet, 5dimes,
+                sportsbettingag and others)
+            snapshot_type (optional): Single game: one snapshot type (default all). Season: opening or
+                closing (default closing). One of: opening, closing, latest.
+            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,
+                "limit": limit,
+                "offset": offset,
+                "estimate_only": estimate_only,
+            },
+        )
+
+    def get_line_movement(
+        self,
+        game_id: str,
+        *,
+        bookmaker: Optional[str] = None,
+    ) -> Any:
+        """Line movement.
+
+        Use to see how a game's lines moved: the full time series of hourly snapshots grouped by
+        bookmaker. Most expensive tool (25 cr); use get_odds (10 cr) if you only need opening, closing,
+        or current lines.
+
+        Costs 25 credits per call.
+
+        Args:
+            game_id: Game id
+            bookmaker (optional): Bookmaker key filter
+
+        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[str] = None,
+        season: Optional[Union[str, int, float]] = None,
+        market: Optional[Literal["player_pass_yds", "player_pass_tds", "player_rush_yds", "player_reception_yds", "player_receptions", "player_anytime_td"]] = 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 passing yards, passing TDs, rushing
+        yards, receiving yards and receptions, plus anytime TD, from the 2023 season (7 books:
+        DraftKings, FanDuel, BetMGM, ESPN BET, Pinnacle, Bovada, BetOnline). Pass game_id for every
+        player's props in one game (10 credits), or player_id with season for one player across a season
+        (10 credits per game returned). Returns the closing line by default (the last before kickoff) or
+        the opening line. Set estimate_only to get the price without being charged.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id (optional): Game id, e.g. 2025_01_KC_LAC.
+            player_id (optional): GSIS player id (00-00XXXXX) from search_players. With season: that
+                player's props across the season.
+            season (optional): Season year, with player_id.
+            market (optional): One market: player_pass_yds (passing yards), player_pass_tds (passing
+                touchdowns), player_rush_yds (rushing yards), player_reception_yds (receiving yards),
+                player_receptions (receptions), player_anytime_td (anytime touchdown (over = scores))
+            bookmaker (optional): Bookmaker key, e.g. draftkings, fanduel, pinnacle.
+            snapshot_type (optional): closing (default): the last line before kickoff. 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,
+                "season": season,
+                "market": market,
+                "bookmaker": bookmaker,
+                "snapshot_type": snapshot_type,
+                "estimate_only": estimate_only,
+            },
+        )
+
+    def get_prop_history(
+        self,
+        player_id: str,
+        market: Literal["player_pass_yds", "player_pass_tds", "player_pass_completions", "player_pass_attempts", "player_pass_interceptions", "player_rush_yds", "player_rush_attempts", "player_receptions", "player_reception_yds", "player_anytime_td"],
+        *,
+        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 (passing, rushing or
+        receiving yards, passing touchdowns, completions, attempts, interceptions, carries, receptions
+        or anytime touchdown), 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 (a GSIS id such as 00-0033873) from search_players.
+            market: The market: player_pass_yds (passing yards), player_pass_tds (passing touchdowns),
+                player_pass_completions (pass completions), player_pass_attempts (pass attempts),
+                player_pass_interceptions (interceptions thrown), player_rush_yds (rushing yards),
+                player_rush_attempts (rush attempts), player_receptions (receptions),
+                player_reception_yds (receiving yards), player_anytime_td (anytime touchdown (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_alt_lines(
+        self,
+        game_id: str,
+        *,
+        market: Optional[Literal["alternate_spreads", "alternate_totals"]] = None,
+        bookmaker: Optional[str] = None,
+        snapshot_type: Optional[Literal["opening", "closing"]] = None,
+    ) -> Any:
+        """Alt lines.
+
+        Use for alternate spreads and totals by sportsbook: every point on each book's ladder with its
+        price (e.g. KC -10.5 at +260, over 51.5 at +140), for one game, from the 2023 to 2025 seasons (6
+        books: FanDuel, DraftKings, BetMGM, Bovada, Pinnacle, ESPN BET). Returns each book's closing
+        ladder by default (the last before kickoff) or its opening one. side is home or away for spreads
+        (point is that side's spread) and over or under for totals. 10 credits.
+
+        Costs 10 credits per call.
+
+        Args:
+            game_id: Game id, e.g. 2025_01_KC_LAC.
+            market (optional): One market (default both). One of: alternate_spreads, alternate_totals.
+            bookmaker (optional): Bookmaker key: fanduel, draftkings, betmgm, bovada, pinnacle, espnbet.
+            snapshot_type (optional): closing (default): each book's last ladder before kickoff.
+                opening: its first.
+
+        Returns:
+            The unwrapped ``data`` object from the response.
+        """
+        return self._call(
+            "get_alt_lines",
+            {
+                "game_id": game_id,
+                "market": market,
+                "bookmaker": bookmaker,
+                "snapshot_type": snapshot_type,
+            },
+        )