mlb-cli-py 0.1.0__py3-none-any.whl

app/models/statsapi_source.py

@@ -0,0 +1,71 @@
+"""
+Implementation of BaseDataSource using the statsapi library.
+"""
+import statsapi
+from app.config import DIVISION_NAMES
+from app.logger import get_logger
+from app.exceptions import APIError
+from .base_data_source import BaseDataSource
+
+logger = get_logger(__name__)
+
+
+class StatsApiDataSource(BaseDataSource):
+    """
+    Data source implementation that fetches data from the MLB StatsAPI.
+    """
+
+    def fetch_teams(self):
+        """Fetches all MLB teams and returns a mapping of ID to abbreviation."""
+        try:
+            teams_data = statsapi.get('teams', {'sportId': 1})['teams']
+            return {t['id']: t.get('abbreviation', t['name'][:3].upper()) for t in teams_data}
+        except (ValueError, KeyError, IndexError, RuntimeError, TypeError, AttributeError) as e:
+            logger.error("Failed to fetch teams: %s", e)
+            # Fallback to some common ones if API fails
+            return {147: 'NYY', 110: 'BAL', 119: 'LAD'}
+
+    def fetch_schedule(self, date_str):
+        """Fetches the MLB schedule for a specific date."""
+        try:
+            return statsapi.schedule(date=date_str)
+        except (ValueError, KeyError, IndexError, RuntimeError, TypeError, AttributeError) as e:
+            logger.error("Failed to fetch schedule for %s: %s", date_str, e)
+            raise APIError(f"Unable to fetch schedule for {date_str}") from e
+
+    def fetch_standings(self):
+        """Fetches current MLB standings."""
+        try:
+            data = statsapi.get('standings', {'leagueId': '103,104'})
+            if not data or not data.get('records'):
+                return []
+
+            div_results = []
+            for record in data['records']:
+                div_id = record.get('division', {}).get('id')
+                if div_id:
+                    div_results.append({
+                        'id': div_id,
+                        'name': DIVISION_NAMES.get(
+                            div_id, record.get('division', {}).get('name', 'Unknown')
+                        ),
+                        'teams': record.get('teamRecords', [])
+                    })
+            return div_results
+        except (ValueError, KeyError, IndexError, RuntimeError, TypeError, AttributeError) as e:
+            logger.error("Failed to fetch standings: %s", e)
+            raise APIError("Unable to fetch standings") from e
+
+    def fetch_wild_card(self, league_id):
+        """Fetches wild card standings for a league."""
+        try:
+            data = statsapi.get('standings', {
+                'leagueId': league_id,
+                'standingsTypes': 'wildCard'
+            })
+            if not data or not data.get('records'):
+                return None
+            return data['records'][0]
+        except (ValueError, KeyError, IndexError, RuntimeError, TypeError, AttributeError) as e:
+            logger.error("Failed to fetch wild card for league %s: %s", league_id, e)
+            raise APIError(f"Unable to fetch wild card standings for league {league_id}") from e

app/screens/__init__.py

@@ -0,0 +1,9 @@
+"""
+Screens package for the MLB CLI application.
+"""
+from .schedule_screen import ScheduleScreen
+from .standings_screen import StandingsScreen
+from .calendar_screen import CalendarScreen
+from .error_screen import ErrorScreen
+
+__all__ = ["ScheduleScreen", "StandingsScreen", "CalendarScreen", "ErrorScreen"]

app/screens/calendar_screen.py

@@ -0,0 +1,58 @@
+"""
+Calendar screen for the MLB CLI application.
+"""
+import calendar
+import pytermgui as ptg
+from app.widgets import NavigationWidget, CalendarWidget
+
+
+class CalendarScreen:
+    # pylint: disable=too-few-public-methods
+    """
+    Screen class for displaying the MLB calendar.
+    """
+
+    @staticmethod
+    def get_widgets(year, months, on_date_selected, selected_date=None):
+        """
+        Generates the widget list and title for the calendar view showing multiple months.
+
+        Args:
+            year (int): Year to display.
+            months (list): List of month integers to display.
+            on_date_selected (callable): Callback for date selection.
+            selected_date (datetime, optional): The currently selected date for highlighting.
+
+        Returns:
+            tuple: (list of widgets, title string)
+        """
+        month_widgets = []
+        month_names = []
+
+        for month in months:
+            name = calendar.month_name[month]
+            month_names.append(name)
+
+            selected_day = None
+            if selected_date and selected_date.year == year and \
+               selected_date.month == month:
+                selected_day = selected_date.day
+
+            container = ptg.Container(
+                ptg.Label(f"[bold]{name}[/]", parent_align=ptg.HorizontalAlignment.CENTER),
+                CalendarWidget(year, month, on_date_selected, selected_day=selected_day),
+                box="EMPTY"
+            )
+            month_widgets.append(container)
+
+        # Fill with empty if less than 3
+        while len(month_widgets) < 3:
+            month_widgets.append(ptg.Label(""))
+
+        widgets = [
+            NavigationWidget(active_page="calendar"),
+        ]
+        widgets.extend(month_widgets)
+
+        title_range = f"{month_names[0]} - {month_names[-1]}"
+        return widgets, f"[green]Calendar - {title_range} {year}[/]"

app/screens/error_screen.py

@@ -0,0 +1,42 @@
+"""
+Error screen for the MLB CLI application.
+Displays error messages and recovery instructions.
+"""
+import pytermgui as ptg
+from app.widgets import NavigationWidget
+
+
+class ErrorScreen:
+    # pylint: disable=too-few-public-methods
+    """
+    Screen class for displaying error messages.
+    """
+
+    @staticmethod
+    def get_widgets(error_message):
+        """
+        Generates the widget list and title for an error message.
+
+        Args:
+            error_message (str): The error message to display.
+
+        Returns:
+            tuple: (list of widgets, title string)
+        """
+        widgets = [
+            NavigationWidget(), # Default nav for recovery
+            ptg.Label(""),
+            ptg.Label("[bold red]ERROR[/]", parent_align=ptg.HorizontalAlignment.CENTER),
+            ptg.Label(""),
+            ptg.Label(f"[italic]{error_message}[/]", parent_align=ptg.HorizontalAlignment.CENTER),
+            ptg.Label(""),
+            ptg.Label("Please check your connection or try again later.",
+                      parent_align=ptg.HorizontalAlignment.CENTER),
+            ptg.Label(""),
+            ptg.Label("Press [bold cyan]t[/] to return to Today's schedule.",
+                      parent_align=ptg.HorizontalAlignment.CENTER),
+            ptg.Label("Press [bold cyan]ESC[/] to exit.",
+                      parent_align=ptg.HorizontalAlignment.CENTER),
+            ptg.Label(""),
+        ]
+        return widgets, "[red]Application Error[/]"

app/screens/schedule_screen.py

@@ -0,0 +1,33 @@
+"""
+Schedule screen for the MLB CLI application.
+"""
+import pytermgui as ptg
+from app.widgets import create_grid, NavigationWidget
+from app.models.data_service import fetch_schedule
+
+
+class ScheduleScreen:
+    # pylint: disable=too-few-public-methods
+    """
+    Screen class for displaying the MLB schedule.
+    """
+
+    @staticmethod
+    def get_widgets(date_str):
+        """
+        Generates the widget list and title for a specific date's schedule.
+
+        Args:
+            date_str (str): The date string in MM/DD/YYYY format.
+
+        Returns:
+            tuple: (list of widgets, title string)
+        """
+        games = fetch_schedule(date_str)
+
+        widgets = [
+            NavigationWidget(active_page="schedule"),
+            ptg.Label(f"[bold]MLB Schedule - {date_str}[/]"),
+            *create_grid(games),
+        ]
+        return widgets, f"[green]MLB Schedule - {date_str}[/]"

app/screens/standings_screen.py

@@ -0,0 +1,39 @@
+"""
+Standings screen for the MLB CLI application.
+"""
+import pytermgui as ptg
+from app.widgets import StandingWidget, NavigationWidget
+from app.models.data_service import fetch_standings
+
+
+class StandingsScreen:
+    # pylint: disable=too-few-public-methods
+    """
+    Screen class for displaying the MLB standings.
+    """
+
+    @staticmethod
+    def get_widgets():
+        """
+        Generates the widget list and title for the 'MLB Standings' screen.
+
+        Returns:
+            tuple: (list of widgets, title string)
+        """
+        al_divs, nl_divs, al_wc, nl_wc = fetch_standings()
+
+        # Define row structure with weights to ensure uniform width
+        # 2 columns for divisions, centered 1 column (using padding) for Wild Cards
+        widgets = [
+            NavigationWidget(active_page="standings"),
+            ptg.Label("[bold]MLB Standings[/]"),
+            # East Row
+            ptg.Splitter(StandingWidget(al_divs[0]), StandingWidget(nl_divs[0])),
+            # Central Row
+            ptg.Splitter(StandingWidget(al_divs[1]), StandingWidget(nl_divs[1])),
+            # West Row
+            ptg.Splitter(StandingWidget(al_divs[2]), StandingWidget(nl_divs[2])),
+            # Wild Card Row (AL and NL)
+            ptg.Splitter(StandingWidget(al_wc), StandingWidget(nl_wc)),
+        ]
+        return widgets, "[green]MLB Standings[/]"

app/state.py

@@ -0,0 +1,74 @@
+"""
+Application state management for the MLB CLI application.
+Handles dates, page tracking, and navigation logic.
+"""
+from datetime import datetime, timedelta
+
+
+class ApplicationState:
+    """
+    Manages the persistent state of the application.
+    Tracks the current date, active page, and calendar pagination.
+    """
+
+    def __init__(self):
+        self.current_date = datetime.now()
+        self.active_page = None
+        self.calendar_page = 0
+        self.determine_initial_calendar_page()
+
+    def determine_initial_calendar_page(self):
+        """Determines the calendar page based on current_date."""
+        month = self.current_date.month
+        if month <= 5:
+            self.calendar_page = 0
+        elif month <= 8:
+            self.calendar_page = 1
+        else:
+            self.calendar_page = 2
+
+    def increment_date(self):
+        """Increments the current date, with season boundary logic."""
+        if self.current_date.year < 2026:
+            self.current_date = datetime(2026, 1, 1)
+
+        if self.current_date < datetime(2026, 12, 31):
+            self.current_date += timedelta(days=1)
+            return True
+        return False
+
+    def decrement_date(self):
+        """Decrements the current date, with season boundary logic."""
+        if self.current_date.year > 2026:
+            self.current_date = datetime(2026, 12, 31)
+
+        if self.current_date > datetime(2026, 1, 1):
+            self.current_date -= timedelta(days=1)
+            return True
+        return False
+
+    def next_calendar_page(self):
+        """Moves to the next calendar page with wrapping."""
+        self.calendar_page = (self.calendar_page + 1) % 3
+
+    def prev_calendar_page(self):
+        """Moves to the previous calendar page with wrapping."""
+        self.calendar_page = (self.calendar_page - 1) % 3
+
+    def reset_to_today(self):
+        """Resets current_date to the actual today."""
+        self.current_date = datetime.now()
+
+    def set_active_page(self, page_name):
+        """Updates the active page name."""
+        self.active_page = page_name
+
+    @property
+    def on_calendar_screen(self):
+        """Returns True if currently on a calendar page."""
+        return self.active_page and self.active_page.startswith("calendar")
+
+    @property
+    def on_standings_screen(self):
+        """Returns True if currently on the standings page."""
+        return self.active_page == "standings"

app/widgets/__init__.py

@@ -0,0 +1,22 @@
+"""
+Widget package for the MLB CLI application.
+Contains various UI components for games, standings, navigation, and more.
+"""
+from .separator import Separator
+from .game_widget import GameWidget, create_grid, chunk_list
+from .standing_widget import StandingWidget
+from .navigation_widget import NavigationWidget
+from .calendar_widget import CalendarWidget, CalendarButton
+from .animations import slide_transition
+
+__all__ = [
+    "Separator",
+    "GameWidget",
+    "create_grid",
+    "chunk_list",
+    "StandingWidget",
+    "NavigationWidget",
+    "CalendarWidget",
+    "CalendarButton",
+    "slide_transition",
+]

app/widgets/animations.py

@@ -0,0 +1,66 @@
+"""
+Animation utilities for the MLB CLI application.
+Provides functions for sliding windows and other transitions.
+"""
+import pytermgui as ptg
+from pytermgui.animations import Direction
+
+
+# pylint: disable=too-many-arguments,too-many-positional-arguments,too-many-locals
+def slide_transition(window, manager, widgets, title, duration=290, on_finish=None,
+                     new_width=None, new_height=None):
+    """
+    Performs a slide-out and slide-in transition for a window.
+
+    Args:
+        window (ptg.Window): The window to animate.
+        manager (ptg.WindowManager): The manager containing the window.
+        widgets (list): The new widgets to set after sliding out.
+        title (str): The new title to set after sliding out.
+        duration (int): Duration of each slide stage in milliseconds.
+        on_finish (callable, optional): Callback to run when the entire transition finishes.
+        new_width (int, optional): The target width for the window.
+        new_height (int, optional): The target height for the window.
+    """
+    # Use provided dimensions or fallback to current ones
+    target_width = new_width if new_width is not None else window.width
+    target_height = new_height if new_height is not None else window.height
+
+    # Calculate starting position for slide-in (centered)
+    final_target_x = (manager.terminal.width - target_width) // 2
+    _, start_y = window.pos
+    off_screen_right = manager.terminal.width
+
+    def slide_step(anim, off_x, current_target_x):
+        """Updates the window position based on animation state and off-screen target."""
+        curr_x = int(current_target_x + (off_x - current_target_x) * anim.state)
+        window.pos = (curr_x, start_y)
+        return False
+
+    def on_slide_in_finish(_):
+        """Runs the external on_finish callback if provided."""
+        if on_finish:
+            on_finish()
+
+    def on_slide_out_finish(_):
+        """Updates window content and starts the slide-in animation using Direction.BACKWARD."""
+        window.set_widgets(widgets)
+        window.set_title(title)
+        window.width = target_width
+        window.height = target_height
+        window.styles.border = "green"
+        window.styles.corner = "green"
+
+        ptg.animator.animate_float(
+            duration=duration,
+            direction=Direction.BACKWARD,
+            on_step=lambda anim: slide_step(anim, off_screen_right, final_target_x),
+            on_finish=on_slide_in_finish
+        )
+
+    # Start the slide-out animation using Direction.FORWARD
+    ptg.animator.animate_float(
+        duration=duration,
+        direction=Direction.FORWARD,
+        on_finish=on_slide_out_finish
+    )

app/widgets/calendar_widget.py

@@ -0,0 +1,78 @@
+"""
+Calendar widget for the MLB CLI application.
+"""
+import calendar
+import pytermgui as ptg
+from .separator import Separator
+
+
+class CalendarButton(ptg.Button):
+    """
+    A button that only responds to keyboard events.
+    """
+
+    def handle_mouse(self, event):
+        """Ignores mouse events."""
+        return False
+
+
+class CalendarWidget(ptg.Container):
+    """
+    A widget that displays a calendar for a specific month.
+    Allows selecting a date and confirming with ENTER.
+    """
+
+    def __init__(self, year, month, on_date_selected, selected_day=None, **kwargs):
+        """
+        Initializes the CalendarWidget.
+
+        Args:
+            year (int): The year to display.
+            month (int): The month to display.
+            on_date_selected (callable): Callback when a date is selected with ENTER.
+            selected_day (int, optional): The day to highlight as selected.
+            **kwargs: Additional arguments for ptg.Container.
+        """
+        super().__init__(**kwargs)
+        self.year = year
+        self.month = month
+        self.on_date_selected = on_date_selected
+        self.day_to_button = {}
+        self.button_to_day = {}
+        self.border = ptg.boxes.SINGLE
+
+        cal = calendar.Calendar(firstweekday=6)  # Sunday
+        month_days = cal.monthdayscalendar(year, month)
+
+        widgets = []
+        # Header: Su Mo Tu We Th Fr Sa
+        days_header = ptg.Splitter(
+            *[ptg.Label(d, parent_align=ptg.HorizontalAlignment.CENTER)
+              for d in ["Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"]]
+        )
+        widgets.append(days_header)
+        widgets.append(Separator())
+
+        for week in month_days:
+            week_widgets = []
+            for day in week:
+                if day == 0:
+                    week_widgets.append(ptg.Label(""))
+                else:
+                    btn = CalendarButton(
+                        str(day),
+                        lambda b, d=day: self.on_date_selected(self.year, self.month, d)
+                    )
+                    if day == selected_day:
+                        btn.styles.label = "inverse"
+                    else:
+                        btn.styles.label = "white"
+
+                    btn.styles.highlight = "inverse"
+
+                    self.day_to_button[day] = btn
+                    self.button_to_day[btn] = day
+                    week_widgets.append(btn)
+            widgets.append(ptg.Splitter(*week_widgets))
+
+        self.set_widgets(widgets)

app/widgets/game_widget.py

@@ -0,0 +1,139 @@
+"""
+Game widget for the MLB CLI application.
+"""
+from datetime import datetime, timezone
+import pytermgui as ptg
+from app.models.data_service import get_team_abbr
+
+
+class GameWidget(ptg.Container):
+    """
+    A container widget displaying the score and teams for a single MLB game.
+    """
+
+    def __init__(self, game, **kwargs):
+        """
+        Initializes the GameWidget with game data.
+
+        Args:
+            game (dict): Dictionary containing game details (teams, scores, status).
+            **kwargs: Additional arguments for ptg.Container.
+        """
+        super().__init__(**kwargs)
+        self.game_id = game['game_id']
+        self._selectables_length = 1
+
+        away_abbr = get_team_abbr(game['away_id'])
+        home_abbr = get_team_abbr(game['home_id'])
+
+        status = game.get('status', '')
+        away_score, home_score = self._get_scores(game, status)
+        inning_text = self._get_inning_text(game, status)
+
+        self.away_info, self.home_info = self._create_rows(
+            (away_abbr, away_score),
+            (home_abbr, home_score),
+            inning_text
+        )
+
+        self.set_widgets([self.away_info, self.home_info])
+        self.border = ptg.boxes.SINGLE
+
+    def _get_scores(self, game, status):
+        """Determines the away and home scores based on game status."""
+        if status in ['Scheduled', 'Preview', 'Pre-Game']:
+            return "-", "-"
+
+        away_score = game.get('away_score', "-")
+        home_score = game.get('home_score', "-")
+        return (str(away_score) if away_score is not None else "-",
+                str(home_score) if home_score is not None else "-")
+
+    def _get_inning_text(self, game, status):
+        """Formats the inning or start time text."""
+        if status in ['Scheduled', 'Preview', 'Pre-Game']:
+            try:
+                dt_naive = datetime.strptime(game['game_datetime'], '%Y-%m-%dT%H:%M:%SZ')
+                dt_aware = dt_naive.replace(tzinfo=timezone.utc)
+                return dt_aware.astimezone().strftime('%-I:%M %p')
+            except (ValueError, KeyError, TypeError):
+                return ""
+
+        if status == 'Final':
+            return "FINAL"
+
+        inning_val = game.get('current_inning')
+        inning_state = game.get('inning_state', '')
+        if inning_val:
+            prefix = ""
+            if inning_state.lower().startswith('top'):
+                prefix = "TOP"
+            elif inning_state.lower().startswith('bottom'):
+                prefix = "BOT"
+            elif inning_state.lower().startswith('middle'):
+                prefix = "MID"
+            elif inning_state.lower().startswith('end'):
+                prefix = "END"
+            return f"{prefix} {inning_val}"
+
+        return ""
+
+    def _create_rows(self, away_data, home_data, inning_text):
+        """Creates the splitter rows for away and home teams."""
+        away_abbr, away_score = away_data
+        home_abbr, home_score = home_data
+
+        away_row = ptg.Splitter(
+            ptg.Label(f"[bold]{away_abbr:3}[/] {away_score:>2}"),
+            ptg.Label("", parent_align=ptg.HorizontalAlignment.RIGHT)
+        )
+
+        home_row = ptg.Splitter(
+            ptg.Label(f"[bold]{home_abbr:3}[/] {home_score:>2}"),
+            ptg.Label(f"[italic]{inning_text}[/]", parent_align=ptg.HorizontalAlignment.CENTER)
+        )
+        return away_row, home_row
+
+    def handle_key(self, key):
+        """
+        Handles key events for the widget.
+
+        Args:
+            key (str): The key that was pressed.
+        """
+        if key == ptg.keys.RETURN:
+            # Future: show box score
+            pass
+        return super().handle_key(key)
+
+
+def chunk_list(lst, n):
+    """
+    Yields successive n-sized chunks from a list.
+
+    Args:
+        lst (list): The list to chunk.
+        n (int): The size of each chunk.
+    """
+    for i in range(0, len(lst), n):
+        yield lst[i:i + n]
+
+
+def create_grid(games):
+    """
+    Creates a grid layout of GameWidgets from a list of games.
+
+    Args:
+        games (list): List of game data dictionaries.
+
+    Returns:
+        list: A list of tuples, each representing a row of widgets for the grid.
+    """
+    grid_rows = []
+    for game_group in chunk_list(games, 3):
+        widgets = [GameWidget(game) for game in game_group]
+        # Fill empty slots if less than 3 games in row
+        while len(widgets) < 3:
+            widgets.append(ptg.Label(""))
+        grid_rows.append(tuple(widgets))
+    return grid_rows