mlbrecaps 0.0.1__py3-none-any.whl

mlbrecaps/__init__.py

@@ -0,0 +1,13 @@
+from .clip import Clip
+from .clips import Clips
+from .date import Date
+from .date_range import DateRange
+from .date_generator import DateGenerator
+from .game import Game
+from .game_generator import GameGenerator
+from .play import Play
+from .player import Player
+from .team import Team
+from .scripts import get_highlights
+
+__all__ = ["Clip", "Clips", "Date", "DateRange", "DateGenerator", "Game", "Play", "Player", "GameGenerator", "Team", "scripts"]

mlbrecaps/__main__.py

@@ -0,0 +1,21 @@
+from .scripts import get_highlights
+
+from .date import Date
+from .team import Team
+
+if __name__ == "__main__":
+    # Get teams for the search
+    team = Team(input("Input team name: "))
+    date = Date(input("Date MM/DD/YYYY: "))
+    file_path = input("Downloads filepath: ")
+
+    if not file_path.endswith("/"):
+        file_path += "/"
+
+    game_clips = get_highlights(team, date)
+
+    for index, clips in enumerate(game_clips):
+        # Download all highlight clips
+        print(f"Game {index + 1}: {clips.plays[0].game}")
+
+        clips.download(f"{file_path}{index}", verbose=True)

mlbrecaps/clip.py

@@ -0,0 +1,103 @@
+from bs4 import BeautifulSoup
+
+import requests
+import json
+import subprocess
+
+from .play import Play
+
+class Clip():
+
+    def __init__(self, play: Play, broadcast_type: str | None=None):
+        if not isinstance(play, Play):
+            raise ValueError("Play must be a Play object")
+
+        self._play: Play = play
+
+        match broadcast_type: # Enforce broad_type types
+            case "HOME" | "AWAY" | None:
+                self.broadcast_type: str | None = broadcast_type
+            case _:
+                raise ValueError("BroadcastType must be None, \"HOME\", or \"AWAY\"")
+
+        self._clip_url: str = self.__generate()
+
+    @property
+    def clip_url(self) -> str:
+        return self._clip_url
+
+    def __str__(self) -> str:
+        return self.clip_url
+
+    @property
+    def play(self) -> Play:
+        return self._play
+
+    # gets the url of the clip to be downloaded from the savant clip
+    def __get_url(self, site_url: str) -> str:
+        # Get the savant site
+        site: requests.Response = requests.get(site_url)
+
+        # Find the video element of the savant clip, find the source url of the clip
+        soup= BeautifulSoup(site.text, features="lxml")
+        video_obj = soup.find("video", id="sporty")
+
+        if not video_obj:
+            return ""
+
+        source = video_obj.find('source')
+        clip_url: str = source.get('src')
+
+        # Return the source url of the clip so it can be downloaded later
+        return clip_url
+
+
+    # finds the savant clip based on the given at-bat information
+    # row must be a pandas dataframe row
+    def __generate(self) -> str:
+        # load the given game's json file
+        game_json = self._play.game.game_json
+
+        # find the broadcast type so it's always corresponding
+        # to the given batter's home team's broadcast
+        if self.broadcast_type:
+            broadcast_type = self.broadcast_type
+        elif self._play.inning_topbot == "TOP":
+            broadcast_type = "AWAY"
+        else:
+            broadcast_type = "HOME"
+
+        # with the play id find the url for the savant clip
+        site_url = f"https://baseballsavant.mlb.com/sporty-videos?playId={self._play.play_id}&videoType={broadcast_type}"
+        clip_url = self.__get_url(site_url)
+
+        # if the clip is alright return it
+        if clip_url != "":
+            return clip_url
+        
+        # if the clip is screwed up then it was a national tv game
+        # return the correct national tv clip url
+        site_url = f"https://baseballsavant.mlb.com/sporty-videos?playId={self._play.play_id}&videoType=NETWORK"
+        clip_url = self.__get_url(site_url)
+
+        return clip_url
+
+    def download(self, path: str, verbose: bool =False) -> None:
+        # create response object 
+        # if a time out happens, try five more times before crashing the entire program
+        for z in range(5):
+            try:
+                r = requests.get(self._clip_url, stream=True, timeout=60) 
+                break
+            except requests.exceptions.Timeout:
+                print(f'Timeout has been raised. Link: {self._clip_url}')
+
+        # download the file to the specific location
+        # honestly copied and pasted code, can't say much else
+        with open(path, 'wb') as f: 
+            for chunk in r.iter_content(chunk_size = 1024*1024): 
+                if chunk: 
+                    f.write(chunk) 
+
+        if verbose:
+            print(f"Successfully downloaded: {path}")

mlbrecaps/clips.py

@@ -0,0 +1,51 @@
+from typing import List, Literal
+from functools import singledispatchmethod
+
+from .play import Play
+from .game import Game
+from .clip import Clip
+from .utils import async_run
+
+class Clips():
+    def __init__(self, plays: List[Play] | Play, broadcast_type: Literal["HOME", "AWAY"] | None=None):
+        self.__set_plays(plays)
+
+        match broadcast_type: # Enforce broad_type types
+            case "HOME" | "AWAY" | None:
+                self._broadcast_type: str | None = broadcast_type
+            case _:
+                raise ValueError("BroadcastType must be None, \"HOME\", or \"AWAY\"")
+
+        # Generate clip objects for each play passed
+        self._clips = async_run(Clip, self._plays, self._broadcast_type)
+
+    @singledispatchmethod
+    def __set_plays(self, plays) -> None:
+        raise ValueError("A Play or list of Play objects must be passed")
+    
+    @__set_plays.register(list)
+    def _(self, plays: List[Play]) -> None:
+        if len(plays) == 0 or not isinstance(plays[0], Play):
+            raise ValueError("A list of Play objects must be passed")
+
+        self._plays: List[Play] = plays
+
+    @__set_plays.register(Play)
+    def _(self, plays: Play) -> None:
+        self._plays = [plays]
+
+    @property
+    def plays(self) -> List[Play]:
+        return self._plays
+
+    @property
+    def clips(self) -> List[Clip]:
+        return self._clips
+
+    @property
+    def broadcast_type(self) -> str:
+        return self._broadcast_type
+
+    def download(self, path: str, verbose: bool=False) -> None:
+        paths = [f"{path}{index:03d}.mp4" for index in range(len(self._clips))]
+        async_run(Clip.download, self._clips, paths, verbose)

mlbrecaps/data/team-info.csv

@@ -0,0 +1,33 @@
+Team ID,Code,File Code,Abbreviation,Name,Full Name,Brief Name
+108,ana,ana,LAA,LA Angels,Los Angeles Angels,Angels
+109,ari,ari,ARI,Arizona,Arizona Diamondbacks,D-backs
+110,bal,bal,BAL,Baltimore,Baltimore Orioles,Orioles
+111,bos,bos,BOS,Boston,Boston Red Sox,Red Sox
+112,chn,chc,CHC,Chi Cubs,Chicago Cubs,Cubs
+113,cin,cin,CIN,Cincinnati,Cincinnati Reds,Reds
+114,cle,cle,CLE,Cleveland,Cleveland Guardians,Guardians
+115,col,col,COL,Colorado,Colorado Rockies,Rockies
+116,det,det,DET,Detroit,Detroit Tigers,Tigers
+117,hou,hou,HOU,Houston,Houston Astros,Astros
+118,kca,kc,KC,Kansas City,Kansas City Royals,Royals
+119,lan,la,LAD,LA Dodgers,Los Angeles Dodgers,Dodgers
+120,was,was,WSH,Washington,Washington Nationals,Nationals
+121,nyn,nym,NYM,NY Mets,New York Mets,Mets
+133,oak,oak,OAK,Oakland,Oakland Athletics,Athletics
+134,pit,pit,PIT,Pittsburgh,Pittsburgh Pirates,Pirates
+135,sdn,sd,SD,San Diego,San Diego Padres,Padres
+136,sea,sea,SEA,Seattle,Seattle Mariners,Mariners
+137,sfn,sf,SF,San Francisco,San Francisco Giants,Giants
+138,sln,stl,STL,St. Louis,St. Louis Cardinals,Cardinals
+139,tba,tb,TB,Tampa Bay,Tampa Bay Rays,Rays
+140,tex,tex,TEX,Texas,Texas Rangers,Rangers
+141,tor,tor,TOR,Toronto,Toronto Blue Jays,Blue Jays
+142,min,min,MIN,Minnesota,Minnesota Twins,Twins
+143,phi,phi,PHI,Philadelphia,Philadelphia Phillies,Phillies
+144,atl,atl,ATL,Atlanta,Atlanta Braves,Braves
+145,cha,cws,CWS,Chi White Sox,Chicago White Sox,White Sox
+146,mia,mia,MIA,Miami,Miami Marlins,Marlins
+147,nya,nyy,NYY,NY Yankees,New York Yankees,Yankees
+158,mil,mil,MIL,Milwaukee,Milwaukee Brewers,Brewers
+159,aas,al,AL,AL All-Stars,American League All-Stars,AL All-Stars
+160,nas,nl,NL,NL All-Stars,National League All-Stars,NL All-Stars

mlbrecaps/date.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from functools import total_ordering, singledispatchmethod
+from datetime import datetime, timedelta
+
+from typing import Optional
+
+@total_ordering
+class Date():
+	
+	def __init__(self, date: datetime | str | int, day: Optional[int]=None, year: Optional[int]=None):
+		if day and year:
+			self.__set_date(date, day, year)
+		else:
+			self.__set_date(date)
+
+	@singledispatchmethod
+	def __set_date(self, date: datetime | str | int, day: Optional[int]=None, year: Optional[int]=None):
+		raise ValueError("Invalid Date")
+
+	@__set_date.register(datetime)
+	def _(self, date: datetime):
+		self._date = date
+
+	@__set_date.register(str)
+	def _(self, date: str):
+		self._date = datetime.strptime(date, "%m/%d/%Y")
+
+	@__set_date.register(int)
+	def _(self, date: int, day: int, year: int):
+		self._date: datetime = datetime(year, date, day)
+
+	@property
+	def date(self) -> datetime:
+		return self._date
+
+	def to_formatted_string(self) -> str:
+		return self._date.strftime("%Y-%m-%d")
+
+	@property
+	def year(self) -> int:
+		return self._date.year
+
+	@property
+	def month(self) -> int:
+		return self._date.month
+
+	@property
+	def day(self) -> int:
+		return self._date.day
+
+	def next(self, increment: float=1) -> None:
+		self._date += timedelta(days=increment)
+
+	def prev(self, increment: float=1) -> None:
+		self._date -= timedelta(days=increment)
+
+	def copy(self) -> Date:
+		month = self._date.month
+		day = self._date.day
+		year = self._date.year
+
+		return type(self)(datetime(year, month, day))
+
+	def __eq__(self, other: object) -> bool:
+		if not isinstance(other, Date):
+			return False
+
+		return self._date == other.date
+
+	def __lt__(self, other: object) -> bool:
+		if not isinstance(other, Date):
+			return False
+
+		return self._date < other.date
+
+	def __str__(self) -> str:
+		return self._date.strftime("%Y-%m-%d")

mlbrecaps/date_generator.py

@@ -0,0 +1,53 @@
+from datetime import datetime
+from copy import copy
+
+from .date import Date
+from .date_range import DateRange
+
+class DateGenerator():
+
+    @classmethod
+    def today(cls) -> Date:
+        obj = Date(datetime.now())
+
+        return obj
+
+    @classmethod
+    def yesterday(cls) -> Date:
+        obj = cls.today()
+        obj.prev()
+
+        return obj
+
+    @classmethod
+    def tomorrow(cls) -> Date:
+        obj = cls.today()
+        obj.next()
+
+        return obj
+
+    @classmethod
+    def week(cls, month: int, day: int, year: int) -> DateRange:
+        start_dt = Date(month, day, year)
+
+        # set the end date to the end of the week
+        end_dt = copy(start_dt)
+        end_dt.next(6)
+
+        return DateRange(start_dt, end_dt)
+
+    @classmethod
+    def month(cls, month: int, year: int) -> DateRange:
+        start_dt = Date(month, 1, year)
+
+        # set the end date to the end of the month
+        end_dt = copy(start_dt)
+        end_dt.next(28)
+
+        # check if it is still in the month then go one back
+        while end_dt._date.month == month:
+            end_dt.next()
+
+        end_dt.prev()
+
+        return DateRange(start_dt, end_dt)

mlbrecaps/date_range.py

@@ -0,0 +1,21 @@
+from typing import Tuple
+
+from .date import Date
+
+class DateRange():
+    def __init__(self, start_dt: Date, end_dt: Date):
+        self.set_dates(start_dt, end_dt)
+
+    def set_start_date(self, start_dt: Date) -> None:
+        self.start_dt: Date = start_dt
+
+    def set_end_date(self, end_dt: Date) -> None:
+        self.end_dt: Date = end_dt
+
+    def set_dates(self, start_dt: Date, end_dt: Date) -> None:
+        self.set_start_date(start_dt)
+        self.set_end_date(end_dt)
+
+    def get_dates(self) -> tuple[Date, Date]:
+        return self.start_dt, self.end_dt
+    

mlbrecaps/game.py

@@ -0,0 +1,169 @@
+import pandas as pd
+import io
+import requests
+import json
+
+from functools import lru_cache, singledispatchmethod
+from typing import List, Optional
+
+from .team import Team
+from .date import Date
+from .player import Player
+from .play import Play
+from .utils import async_run, dataframe_from_url
+
+class Game():
+
+    @lru_cache(maxsize=3)
+    def __new__(cls, game_pk: int):
+        return super().__new__(cls)
+
+    def __init__(self, game_pk: int):
+        self._game_pk: int  = game_pk
+        self._game_data: pd.DataFrame | None = None
+
+        # finds the url of the game based on the game_pk information stored in the at-bat data
+        game_url = f"https://baseballsavant.mlb.com/gf?game_pk={self._game_pk}"
+        game = requests.get(game_url)
+
+        # load the given game's json file
+        self._game_json = json.loads(game.text)
+        self._away_json = self._game_json["team_away"]
+        self._home_json = self._game_json["team_home"]
+
+        # Get home/away and date
+        self._home: Team = Team(self._game_json["home_team_data"]["abbreviation"])
+        self._away: Team = Team(self._game_json["away_team_data"]["abbreviation"])
+        self._date: Date = Date(self._game_json["gameDate"])
+
+        # Get both lineups
+        self._home_lineup: List[int] = self._game_json["home_lineup"]
+        self._away_lineup: List[int] = self._game_json["away_lineup"]
+
+        # Get the final scores
+        self._home_score: int = self._game_json["scoreboard"]["linescore"]["teams"]["home"]["runs"]
+        self._away_score: int = self._game_json["scoreboard"]["linescore"]["teams"]["away"]["runs"]
+    
+    @singledispatchmethod
+    def road_status(self, team: Team) -> str:
+        raise ValueError("team must be of type Team")
+
+    @road_status.register(Team)
+    def _(self, team: Team) -> str:
+        if self._away == team:
+            return "AWAY"
+
+        return "HOME"
+
+    @property
+    def home(self) -> Team:
+        return self._home
+
+    @property
+    def away(self) -> Team:
+        return self._away
+
+    @property
+    def home_score(self) -> int:
+        return self._home_score
+
+    @property
+    def away_score(self) -> int:
+        return self._away_score
+
+    @property
+    def home_lineup(self) -> List[int]:
+        return self._home_lineup.copy()
+
+    @property
+    def away_lineup(self) -> List[int]:
+        return self._away_lineup.copy()
+
+    def get_lineup(self, team) -> List[int]:
+        if team == self._away:
+            return self.away_lineup()
+            
+        return self.home_lineup
+
+    @property
+    def game_pk(self) -> int:
+        return self._game_pk
+
+    @property
+    def date(self) -> Date:
+        return self._date.copy()
+
+    @dataframe_from_url
+    def __get_data(self) -> pd.DataFrame:
+        return f"https://baseballsavant.mlb.com/statcast_search/csv?all=true&type=details&game_pk={self._game_pk}"
+
+    @property
+    def data(self) -> pd.DataFrame:
+        return self.__get_data().copy()
+
+    @property
+    def game_json(self):
+        return self._game_json.copy()
+
+    @property
+    def away_json(self):
+        return self._away_json.copy()
+
+    @property
+    def home_json(self):
+        return self._home_json.copy()
+
+    def get_highlights(self, plays:int =10, team: Optional[str]=None):
+        df = self.__get_data()
+
+        if plays <= 0:
+            raise ValueError("Plays must be greater than 0")
+
+        if team is not None and team.upper() not in ["HOME", "AWAY"]:
+            raise ValueError("Team must be None, \"HOME\", or \"AWAY\"")
+
+        # extra logic for when a home or away team is specified
+        key = None if team else abs
+        ascending = False if not team else (True, False)[team.lower() == "home"]
+
+        # removes all non-events (balls, strikes, etc.)
+        # then sorts for highest win expectancy for either team
+        # then only keeps the top plays
+        # also make sure the plays are in chronological order of the game
+        df = df[df.events.notnull()]
+        df = df.sort_values(by="delta_home_win_exp", key=key, ascending=ascending)
+        df = df.head(plays)
+        df = df.sort_values(by="pitch_number", ascending=True)
+        df = df.sort_values(by="at_bat_number", ascending=True)
+
+        rows = [row for index, row in df.iterrows()]
+        return async_run(Play, self, rows)
+
+    def get_home_highlights(self, plays=10):
+        return self.get_highlights(plays, "home")
+
+    def get_away_highlights(self, plays=10):
+        return self.get_highlights(plays, "away")
+
+    def get_player_highlights(self, player: Player, plays: int):
+        df = self.__get_data()
+
+        is_home_player = player.player_id in self.home_lineup
+
+        df = df[df.events.notnull() & ((df.batter == player.player_id) | (df.pitcher == player.player_id))]
+        df = df.sort_values(by="delta_home_win_exp", key=None, ascending=is_home_player)
+        df = df.sort_values(by="at_bat_number", ascending=True)
+
+        if is_home_player:
+            df = df[df["delta_home_win_exp"] >= 0]
+        else:
+            df = df[df["delta_home_win_exp"] <= 0]
+
+        df = df.head(plays)
+
+        rows = [row for index, row in df.iterrows()]
+        return async_run(Play, self, rows)
+
+    def __str__(self) -> str:
+        return f"{self._away.abbreviation} - {self._home.abbreviation}, Final: {self._away_score}-{self._home_score}, Date: {self._date}, GamePK: {self._game_pk}"
+

mlbrecaps/game_generator.py

@@ -0,0 +1,93 @@
+import requests
+import json
+import pandas as pd
+
+# from multipledispatch import dispatch
+from functools import singledispatchmethod, cache
+from typing import List, Set, Tuple
+
+from .team import Team
+from .date import Date
+from .date_range import DateRange
+from .game import Game
+from .utils import async_run
+
+class GameGenerator():
+
+    def __init__(self, teams: Team | List[Team], date: Date | DateRange | str | Tuple[int, int, int]):
+        self.__set_teams(teams)
+        self.__set_date(date)
+
+        self._ids: Set[int] = self.__from_dates()
+
+    @singledispatchmethod
+    def __set_teams(self, teams: Team | List[Team]) -> None:
+        raise ValueError("Teams must be a Team or list of Team object")
+
+    @__set_teams.register(list)
+    def _(self, teams: List[Team]) -> None:
+        if len(teams) == 0 or not all(isinstance(team, Team) for team in teams):
+            raise ValueError("A list of Team objects must be passed")
+
+        self._teams: List[Team] = teams
+
+    @__set_teams.register(Team)
+    def _(self, teams: Team) -> None:
+        self._teams = [teams]
+
+    @singledispatchmethod
+    def __set_date(self, date) -> None:
+        raise ValueError("Invalid date must be of type Date, DateRange, str, or Tuple[int, int, int]")
+
+    @__set_date.register(str)
+    def _(self, date: str) -> None:
+        try: 
+            d = Date(date)
+        except:
+            raise ValueError("A valid date string of format %m/%d/%Y must be passed")
+
+        self._date = DateRange(d, d)
+
+    @__set_date.register(tuple)
+    def _(self, date: Tuple[int, int, int]) -> None:
+        try: 
+            d = Date(*date)
+        except:
+            raise ValueError("A valid date tuple of format (month, day, year) must be passed")
+
+        self._date = DateRange(d, d)
+
+    @__set_date.register(Date)
+    def _(self, date: Date) -> None:
+        self._date: DateRange = DateRange(date, date)
+
+    @__set_date.register(DateRange)
+    def _(self, date: DateRange) -> None:
+        self._date = date
+
+    @property
+    @cache
+    def games(self) -> List[Game]:
+        # Generate every Game object from ids
+        games: List[Game] = async_run(Game, list(self._ids))
+        games.sort(key=lambda game: game.date)
+
+        return games
+        
+    def __from_dates(self) -> Set[int]:
+        start_dt, end_dt = self._date.get_dates()
+
+        games_url = [f"https://statsapi.mlb.com/api/v1/schedule?startDate={start_dt.to_formatted_string()}&endDate={end_dt.to_formatted_string()}&sportId=1&teamId={team.team_id}" for team in self._teams]
+        date_jsons = [json.loads(requests.get(game_url).text) for game_url in games_url]
+
+        # Put all game_pks into a set
+        return {int(game["gamePk"]) for date_json in date_jsons for date in date_json["dates"] for game in date["games"]}
+
+    @property
+    def ids(self) -> List[int]:
+        # Only finds the unique game_pks for a given team (needed in case of a double header)
+        return list(self._ids)
+
+    def __len__(self) -> int:
+        return len(self._ids)
+

mlbrecaps/play.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import pandas as pd
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .game import Game
+
+class Play():
+
+    def __init__(self, game: Game, row):
+        self._game: Game = game
+        self._at_bat: int = row.at_bat_number
+        self._play: pd.DataFrame = row
+        self._pitch_number: int = row.pitch_number
+        self._batter: str = row.player_name
+        self._event: str = row.description
+        self._description: str = row.des
+        self._inning_topbot: str = row.inning_topbot
+
+        if self._inning_topbot == "Top":
+            team = self._game.home_json
+        else:
+            team = self._game.away_json
+
+        # filter the json file to find the at bat, this will help find the play id
+        team = [x for x in team if x["ab_number"] == self._at_bat]
+
+        # sorts the at bat by pitch number, highest number is the last pitch of the at bat
+        team.sort(key=lambda item: item["pitch_number"], reverse=True)
+        self._play_id: str = team[0]["play_id"]
+
+    @property
+    def game(self) -> Game:
+        return self._game
+
+    @property
+    def at_bat(self) -> int:
+        return self._at_bat
+
+    @property
+    def play_data(self) -> pd.DataFrame:
+        return self._play.copy()
+
+    @property
+    def inning_topbot(self) -> str:
+        return self._inning_topbot
+
+    @property
+    def batter(self) -> str:
+        return self._batter
+
+    @property
+    def event(self) -> str:
+        return self._event
+
+    @property
+    def description(self) -> str:
+        return self._description
+
+    @property
+    def play_id(self) -> str:
+        return self._play_id
+
+    def __str__(self):
+        return f"{self.__class__}@Game={self._game}:atBat={self._at_bat}:Batter={self._batter}:Description={self._description}:topBot={self._inning_topbot}"

mlbrecaps/player.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import pandas as pd
+import io
+import requests
+import json
+
+from typing import List, Dict, Optional, TYPE_CHECKING
+if TYPE_CHECKING:
+    from .game import Play
+
+from .date_generator import DateGenerator
+from .utils import async_run, dataframe_copy, dataframe_from_url
+
+class Player():
+
+    def __init__(self, player_id: int):
+        self._player_id: int = player_id
+
+        # Get player JSON information
+        playerURL: str = f"https://statsapi.mlb.com/api/v1/people/{player_id}"
+        playerContent = requests.get(playerURL)
+        player_json = json.loads(playerContent.text)["people"][0]
+
+        # Player's name
+        self._first_name: str = player_json["firstName"]
+        self._last_name: str = player_json["lastName"]
+
+        # Player's position
+        self._primary_position: str = player_json["primaryPosition"]["name"]
+        self._primary_position_abbr: str = player_json["primaryPosition"]["abbreviation"]
+
+    def is_pitcher(self) -> bool:
+        return self._primary_position_abbr == "P"
+    
+    def is_batter(self) -> bool:
+        return not self.is_pitcher()
+
+    @property
+    def position(self) -> str:
+        return self._primary_position
+
+    @property
+    def position_abbr(self) -> str:
+        return self._primary_position_abbr
+
+    @property
+    def player_id(self) -> int:
+        return self._player_id
+
+    @property
+    def season(self) -> int:
+        return self._season
+
+    @property
+    def first_name(self) -> str:
+        return self._first_name
+
+    @property
+    def last_name(self) -> str:
+        return self._last_name
+
+    @property
+    def full_name(self) -> str:
+        return f"{self._first_name} {self._last_name}"
+
+    # Lazy generate and save each season on call
+    @dataframe_from_url
+    def __get_homerun_data(self, season: int) -> pd.DataFrame:
+        """
+        Gets pandas dataframe information on all their homerun plays
+        """
+        return f"https://baseballsavant.mlb.com/statcast_search/csv?hfPT=&hfAB=home%5C.%5C.run%7C&hfGT=R%7C&hfPR=hit%5C.%5C.into%5C.%5C.play%7C&hfZ=&hfStadium=&hfBBL=&hfNewZones=&hfPull=&hfC=&hfSea={season}%7C&hfSit=&player_type=batter&hfOuts=&hfOpponent=&pitcher_throws=&batter_stands=&hfSA=&game_date_gt=&game_date_lt=&hfMo=&hfTeam=&home_road=&hfRO=&position=&hfInfield=&hfOutfield=&hfInn=&hfBBT=&batters_lookup%5B%5D={self._player_id}&hfFlag=&metric_1=&group_by=name&min_pitches=0&min_results=0&min_pas=0&sort_col=pitches&player_event_sort=api_p_release_speed&sort_order=desc&type=details&player_id={self._player_id}"
+
+    # Encapsulates mutable data by making a copy
+    @dataframe_copy
+    def get_homerun_data(self, season: int) -> pd.DataFrame:
+        return self.__get_homerun_data(season)
+
+    def get_homerun_count(self, season: int) -> int:
+        return len(self.__get_homerun_data(season).index)
+
+    def get_homeruns(self, season: int | Date) -> List[Play]:
+        from .game import Play, Game
+
+        homerun_data = self.__get_homerun_data(season)
+        # homerun_data.to_csv("./homeruns.csv")
+
+        # if date:
+            # homerun_data = homerun_data[homerun_data[]]
+
+        games: List[Game] = async_run(Game, list(homerun_data["game_pk"]))
+        rows = [row for index, row in homerun_data.iterrows()]
+
+        return async_run(Play, games, rows)[::-1]
+
+    def __eq__(self, o: object) -> bool:
+        if not isinstance(o, Player):
+            return False
+
+        return self._player_id == other._player_id
+
+    def __hash__(self) -> int:
+        return self._player_id
+
+    def __str__(self) -> str:
+        return f"{self.__class__}@PlayerID={self._player_id}:FirstName={self._first_name}:LastName={self._last_name}"

mlbrecaps/scripts.py

@@ -0,0 +1,56 @@
+from typing import List
+
+from .team import Team
+from .player import Player
+from .clips import Clips
+from .date import Date
+from .date_range import DateRange
+from .game_generator import GameGenerator
+
+def get_highlights(team: Team, dates: Date | DateRange, plays: int=10) -> List[Clips]:
+    # Type checking
+    if not isinstance(team, Team):
+        raise ValueError("team must be of type Team")
+    
+    if not (isinstance(dates, Date) or isinstance(dates, DateRange)):
+        raise ValueError("dates must be of type Date or DateRange")
+
+    if not isinstance(plays, int):
+        raise ValueError("plays must be of type int")
+
+    # get all games on that date
+    games = GameGenerator(team, dates).games
+    clips = []
+
+    for game in games:
+        # Determine whether the team is home or away
+        homeRoad = game.road_status(team)
+
+        # Get the top x number of plays of the game
+        homeHighlights = game.get_highlights(plays, homeRoad) 
+        clips.append(Clips(homeHighlights, homeRoad)) # Generate clips of the plays from the home broadcast
+
+    return clips      
+
+def get_player_highlights(team: Team, player: Player, dates: Date):
+    # Type checking
+    if not isinstance(team, Team):
+        raise ValueError("team must be of type Team")
+    
+    if not isinstance(dates, Date):
+        raise ValueError("dates must be of type Date or DateRange")
+
+    game: Game = GameGenerator(team, dates).games[0]
+    player_plays = game.get_player_highlights(player, 5)
+
+    return Clips(player_plays)
+
+def get_player_homeruns(player_id: Player | int, season: int=2023):
+    if isinstance(player_id, Player):
+        player: Player = player_id
+    else:
+        player = Player(player_id)
+
+    homeruns: List[Play] = player.get_homeruns(season)
+
+    return Clips(homeruns)

mlbrecaps/team.py

@@ -0,0 +1,41 @@
+import pandas as pd
+import os
+
+from functools import cache
+from typing import List, Dict
+
+class Team():
+    _team_lookup: pd.DataFrame = pd.read_csv(os.path.join(os.path.dirname(os.path.realpath(__file__)), 'data/team-info.csv'))
+
+    # Speeds up and saves memory by caching the same type of objects
+    @cache
+    def __new__(cls, abbr: str):
+        return super().__new__(cls)
+
+    def __init__(self, abbr: str):
+        self._abbr: str = abbr.upper()
+
+        row: pd.DataFrame = Team._team_lookup.loc[Team._team_lookup["Abbreviation"] == self._abbr]
+        self._team: str = row["Full Name"].values[0]
+        self._team_id: int = row["Team ID"].values[0]
+
+    @property
+    def name(self) -> str:
+        return self._team
+
+    @property
+    def abbreviation(self) -> str:
+        return self._abbr
+
+    @property
+    def team_id(self) -> int:
+        return self._team_id
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Team):
+            return False
+
+        return self._abbr == other._abbr
+
+    def __str__(self) -> str:
+        return f"{self.__class__}@Name={self._team}:Abbreviation={self._abbr}:ID={self._team_id}"

mlbrecaps/utils.py

@@ -0,0 +1,59 @@
+import asyncio
+import requests
+import io
+import pandas as pd
+
+import itertools
+import functools
+
+from typing import Any, List, Tuple
+
+def async_run(func: callable, *args: Any | List[Any]) -> List[Any]:
+    # Makes all arguments into lists
+    try:
+        max_length = max(len(x) for x in args if isinstance(x, list))
+    except ValueError:
+        raise ValueError("At least one argument must be a list")
+
+    repeated_args = [arg if isinstance(arg, list) else list(itertools.repeat(arg, max_length)) for arg in args]
+
+    # Ensure all list arguments are of the same length
+    if not all(len(i) == len(repeated_args[0]) for i in repeated_args):
+        raise ValueError("Argument arrays must all be of the same length")
+
+    async def create(*args: List[Any]):
+        return func(*args)
+
+    async def generate() -> List[Any]:
+        tasks = [asyncio.create_task(create(*args)) for args in zip(*repeated_args)]
+
+        await asyncio.gather(*tasks)
+        return [task.result() for task in tasks]
+
+    return asyncio.run(generate())
+
+def copy_cache(func):
+    func = functools.cache(func)
+
+    def wrapper(*args, **kwargs):
+        return func.copy()
+
+    return wrapper
+
+def dataframe_copy(func):
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs).copy()
+
+    return wrapper
+
+def dataframe_from_url(func, use_cache: bool=True):
+    if use_cache:
+        func = functools.cache(func)
+
+    def wrapper(*args, **kwargs):
+        url: str = func(*args, **kwargs)
+        csv: bytes = requests.get(url).content
+
+        return pd.read_csv(io.StringIO(csv.decode('utf-8')))
+
+    return wrapper

mlbrecaps-0.0.1.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Karsten Larson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mlbrecaps-0.0.1.dist-info/METADATA

@@ -0,0 +1,73 @@
+Metadata-Version: 2.1
+Name: mlbrecaps
+Version: 0.0.1
+Summary: Package that gathers information on given MLB games
+Home-page: https://github.com/MrRedwing/MLB-Recaps
+Author: Karsten Larson
+Author-email: karsten.larson.1@gmail.com
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: numpy >=1.13.0
+Requires-Dist: pandas >=1.0.3
+Requires-Dist: beautifulsoup4 >=4.4.0
+Requires-Dist: requests >=2.18.1
+Requires-Dist: lxml >=4.2.1
+Provides-Extra: dev
+Requires-Dist: twine ; extra == 'dev'
+
+# mlbrecaps
+
+A Python package for downloading Major League Baseball game highlights based on team and date.
+
+### Installation
+
+```
+pip install mlbrecaps
+```
+
+Usage
+The mlbrecaps package provides a simple function highlight_generator to download game highlights for a specified Major League Baseball team and date.
+
+### Basic Python Example:
+
+```
+from mlbrecaps import scripts, Team, Date
+
+# Download highlights for the Minnesota Twins game on October 3rd, 2023
+
+highlights = scripts.get_highlights(Team("MIN"), Date(10, 3, 2023))
+
+# Handle all the highlights to a folder
+highlights.download("/path/to/folder/", verbose=True)
+```
+
+### Run directly from the terminal
+
+If you have the mlbrecaps package installed, you can use the following command to download highlights directly from the terminal:
+
+```
+python -m mlbrecaps
+```
+
+This command will prompt you to enter the team three-letter abbreviation, game date, and path to a videos download directory for the desired highlights.
+
+### Examples
+
+More examples are avaliable on [Github](https://github.com/MrRedwing/MLB-Recaps).
+
+### Development
+
+This package is under active development. Feel free to contribute by submitting pull requests!
+
+### Contributing
+
+All contributions are welcomed to improve the mlbrecaps package. To contribute simply submit a pull request.
+
+### License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

mlbrecaps-0.0.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+mlbrecaps/__init__.py,sha256=rkJ4dEuvgWVrQYpOzKG_0xjJ1LpiHjRih9ePsKCgTyc,449
+mlbrecaps/__main__.py,sha256=Rdt3X9Xkz0T7Y2yGC0mJlzaU5mSFgKoC3LQq_GhYYnY,589
+mlbrecaps/clip.py,sha256=73c4E6R_JbeT1J24TY74IQfS2eBfAvoERHcLek32zd0,3477
+mlbrecaps/clips.py,sha256=-qEThGxihDewbDP4S3K_owAJZFnixjqYwLFtL9SJBNA,1670
+mlbrecaps/date.py,sha256=d2dSeCpK4z6CtjLBACe3n-PlCdmoYO-jpxH9kY8hazQ,1834
+mlbrecaps/date_generator.py,sha256=hLFbw88EbdYkHofxi-Li1YuypZfSzSMt6ooanOawHN4,1158
+mlbrecaps/date_range.py,sha256=m2lyCOK4zg7MLA4WMlVZEeet7kR1XoPF3L9OkPxZd3o,573
+mlbrecaps/game.py,sha256=hLcxa-uCGxLRFg7x7VFETQa2VkCrovcob95F2UFnhvc,5397
+mlbrecaps/game_generator.py,sha256=4XN4oaMAIOKHDyyXIashaUO8lEJgPTSf0Ih9m2ZTHmM,3027
+mlbrecaps/play.py,sha256=rLsqcPrwZs5M-4tUQZAx6zdjD5DGsJNwfVEpSpHlh3Q,1834
+mlbrecaps/player.py,sha256=iIyhNuhXcbUIGyFus5_XbwneL6o-dVt08hOFyzKjLtg,3696
+mlbrecaps/scripts.py,sha256=aSiWoO1YOM47uiEL7hScipKAL2douTRYdePswPRrol4,1791
+mlbrecaps/team.py,sha256=GDd2C97kxqiQpr7LfpJh5NlWg1C_jEsU6PqAQqvQQnE,1161
+mlbrecaps/utils.py,sha256=s6f875DWv-5uSh7uWDaswoUzKwGbT0zhpCKZvPYAWyE,1613
+mlbrecaps/data/team-info.csv,sha256=FuJQjMoRMO7nKlfXJaBOPW6DNygFze9VbgJ2rGhtMoY,1708
+mlbrecaps-0.0.1.dist-info/LICENSE.txt,sha256=dZUFPJprmKmTUFjocGDr8Az4zrrynjaRwhWVZYA7J8s,1070
+mlbrecaps-0.0.1.dist-info/METADATA,sha256=gGbNI0WWeswgn9baeZaADLLtU1vItB5YcVijJtu_SFY,2113
+mlbrecaps-0.0.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+mlbrecaps-0.0.1.dist-info/top_level.txt,sha256=FR_TA1KjJjFZJJCdGLXW9s1mNH22ZG85hizGPokUA44,10
+mlbrecaps-0.0.1.dist-info/RECORD,,

mlbrecaps-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mlbrecaps-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mlbrecaps