otf-api 0.2.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

otf_api/cli/bookings.py

@@ -0,0 +1,231 @@
+from enum import Enum
+
+import pendulum
+import typer
+from loguru import logger
+
+import otf_api
+from otf_api.cli.app import OPT_OUTPUT, AsyncTyper, OutputType, base_app
+from otf_api.cli.prompts import prompt_select_from_table
+from otf_api.models.responses.bookings import BookingStatus
+from otf_api.models.responses.classes import ClassType, ClassTypeCli, DoW
+
+flipped_status = {item.value: item.name for item in BookingStatus}
+FlippedEnum = Enum("CliBookingStatus", flipped_status)  # type: ignore
+
+
+bookings_app = AsyncTyper(name="bookings", help="Get bookings data")
+classes_app = AsyncTyper(name="classes", help="Get classes data")
+base_app.add_typer(bookings_app, aliases=["booking"])
+base_app.add_typer(classes_app, aliases=["class"])
+
+
+def today() -> str:
+    val: str = pendulum.yesterday().date().to_date_string()
+    return val
+
+
+def next_month() -> str:
+    val: str = pendulum.now().add(months=1).date().to_date_string()
+    return val
+
+
+@bookings_app.command(name="list")
+async def list_bookings(
+    start_date: str = typer.Option(default_factory=today, help="Start date for bookings"),
+    end_date: str = typer.Option(default_factory=next_month, help="End date for bookings"),
+    status: FlippedEnum = typer.Option(None, case_sensitive=False, help="Booking status"),
+    limit: int = typer.Option(None, help="Limit the number of bookings returned"),
+    exclude_cancelled: bool = typer.Option(
+        True, "--exclude-cancelled/--include-cancelled", help="Exclude cancelled bookings", show_default=True
+    ),
+    exclude_none: bool = typer.Option(
+        True, "--exclude-none/--allow-none", help="Exclude fields with a value of None", show_default=True
+    ),
+    output: OutputType = OPT_OUTPUT,
+) -> None:
+    """
+    List bookings data
+    """
+
+    logger.info("Listing bookings data")
+
+    if output:
+        base_app.output = output
+
+    bk_status = BookingStatus.get_from_key_insensitive(status.value) if status else None
+
+    if not base_app.api:
+        base_app.api = await otf_api.Otf.create(base_app.username, base_app.password)
+    bookings = await base_app.api.get_bookings(start_date, end_date, bk_status, limit, exclude_cancelled)
+
+    if base_app.output == "json":
+        base_app.print(bookings.to_json(exclude_none=exclude_none))
+    elif base_app.output == "table":
+        base_app.print(bookings.to_table())
+    elif base_app.output == "interactive":
+        result = prompt_select_from_table(
+            console=base_app.console,
+            prompt="Select a booking",
+            columns=bookings.show_bookings_columns(),
+            data=bookings.bookings,
+        )
+        print(result)
+
+
+@bookings_app.command()
+async def book(class_uuid: str = typer.Option(help="Class UUID to cancel")) -> None:
+    """
+    Book a class
+    """
+
+    logger.info(f"Booking class {class_uuid}")
+
+    if not base_app.api:
+        base_app.api = await otf_api.Otf.create(base_app.username, base_app.password)
+    booking = await base_app.api.book_class(class_uuid)
+
+    base_app.console.print(booking)
+
+
+@bookings_app.command()
+async def book_interactive(
+    studio_uuids: list[str] = typer.Option(None, help="Studio UUIDs to get classes for"),
+    include_home_studio: bool = typer.Option(True, help="Include the home studio in the classes"),
+    start_date: str = typer.Option(default_factory=today, help="Start date for classes"),
+    end_date: str = typer.Option(None, help="End date for classes"),
+    limit: int = typer.Option(None, help="Limit the number of classes returned"),
+    class_type: list[ClassTypeCli] = typer.Option(None, help="Class type to filter by"),
+    day_of_week: list[DoW] = typer.Option(None, help="Days of the week to filter by"),
+    exclude_cancelled: bool = typer.Option(
+        True, "--exclude-cancelled/--allow-cancelled", help="Exclude cancelled classes", show_default=True
+    ),
+    start_time: list[str] = typer.Option(None, help="Start time for classes"),
+) -> None:
+    """
+    Book a class interactively
+    """
+
+    logger.info("Booking class interactively")
+
+    with base_app.console.status("Getting classes...", spinner="arc"):
+        if class_type:
+            class_type_enums = [ClassType.get_from_key_insensitive(class_type.value) for class_type in class_type]
+        else:
+            class_type_enums = None
+
+        if not base_app.api:
+            base_app.api = await otf_api.Otf.create(base_app.username, base_app.password)
+
+        classes = await base_app.api.get_classes(
+            studio_uuids,
+            include_home_studio,
+            start_date,
+            end_date,
+            limit,
+            class_type_enums,
+            exclude_cancelled,
+            day_of_week,
+            start_time,
+        )
+
+    result = prompt_select_from_table(
+        console=base_app.console,
+        prompt="Book a class, any class",
+        columns=classes.book_class_columns(),
+        data=classes.classes,
+    )
+
+    print(result["ot_class_uuid"])
+    booking = await base_app.api.book_class(result["ot_class_uuid"])
+
+    base_app.console.print(booking)
+
+
+@bookings_app.command()
+async def cancel_interactive() -> None:
+    """
+    Cancel a booking interactively
+    """
+
+    logger.info("Cancelling booking interactively")
+
+    with base_app.console.status("Getting bookings...", spinner="arc"):
+        if not base_app.api:
+            base_app.api = await otf_api.Otf.create(base_app.username, base_app.password)
+        bookings = await base_app.api.get_bookings()
+
+    result = prompt_select_from_table(
+        console=base_app.console,
+        prompt="Cancel a booking, any booking",
+        columns=bookings.show_bookings_columns(),
+        data=bookings.bookings,
+    )
+
+    print(result["class_booking_uuid"])
+    booking = await base_app.api.cancel_booking(result["class_booking_uuid"])
+
+    base_app.console.print(booking)
+
+
+@bookings_app.command()
+async def cancel(booking_uuid: str = typer.Option(help="Booking UUID to cancel")) -> None:
+    """
+    Cancel a booking
+    """
+
+    logger.info(f"Cancelling booking {booking_uuid}")
+
+    if not base_app.api:
+        base_app.api = await otf_api.Otf.create(base_app.username, base_app.password)
+    booking = await base_app.api.cancel_booking(booking_uuid)
+
+    base_app.console.print(booking)
+
+
+@classes_app.command(name="list")
+async def list_classes(
+    studio_uuids: list[str] = typer.Option(None, help="Studio UUIDs to get classes for"),
+    include_home_studio: bool = typer.Option(True, help="Include the home studio in the classes"),
+    start_date: str = typer.Option(default_factory=today, help="Start date for classes"),
+    end_date: str = typer.Option(default_factory=next_month, help="End date for classes"),
+    limit: int = typer.Option(None, help="Limit the number of classes returned"),
+    class_type: ClassTypeCli = typer.Option(None, help="Class type to filter by"),
+    exclude_cancelled: bool = typer.Option(
+        True, "--exclude-cancelled/--allow-cancelled", help="Exclude cancelled classes", show_default=True
+    ),
+    exclude_none: bool = typer.Option(
+        True, "--exclude-none/--allow-none", help="Exclude fields with a value of None", show_default=True
+    ),
+    output: OutputType = OPT_OUTPUT,
+) -> None:
+    """
+    List classes data
+    """
+
+    logger.info("Listing classes")
+
+    if output:
+        base_app.output = output
+
+    class_type_enum = ClassType.get_from_key_insensitive(class_type.value) if class_type else None
+
+    if not base_app.api:
+        base_app.api = await otf_api.Otf.create(base_app.username, base_app.password)
+    classes = await base_app.api.get_classes(
+        studio_uuids, include_home_studio, start_date, end_date, limit, class_type_enum, exclude_cancelled
+    )
+
+    if base_app.output == "json":
+        base_app.print(classes.to_json(exclude_none=exclude_none))
+    elif base_app.output == "table":
+        base_app.print(classes.to_table())
+    else:
+        result = prompt_select_from_table(
+            console=base_app.console,
+            prompt="Book a class, any class",
+            columns=classes.book_class_columns(),
+            data=classes.classes,
+        )
+        print(type(result))
+        print(result)

otf_api/cli/prompts.py

@@ -0,0 +1,162 @@
+import os
+import typing
+
+import readchar
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from otf_api.cli._utilities import exit_with_error
+from otf_api.models.base import T
+
+if typing.TYPE_CHECKING:
+    from rich.console import Console
+
+
+def prompt(message, **kwargs):
+    """Utility to prompt the user for input with consistent styling"""
+    return Prompt.ask(f"[bold][green]?[/] {message}[/]", **kwargs)
+
+
+def confirm(message, **kwargs):
+    """Utility to prompt the user for confirmation with consistent styling"""
+    return Confirm.ask(f"[bold][green]?[/] {message}[/]", **kwargs)
+
+
+def prompt_select_from_table(
+    console: "Console",
+    prompt: str,
+    columns: list[str],
+    data: list[T],
+    table_kwargs: dict | None = None,
+) -> dict:
+    """
+    Given a list of columns and some data, display options to user in a table
+    and prompt them to select one.
+
+    Args:
+        prompt: A prompt to display to the user before the table.
+        columns: A list of strings that represent the attributes of the data to display.
+        data: A list of dicts with keys corresponding to the `key` values in
+            the `columns` argument.
+        table_kwargs: Additional kwargs to pass to the `rich.Table` constructor.
+    Returns:
+        dict: Data representation of the selected row
+    """
+    current_idx = 0
+    selected_row = None
+    table_kwargs = table_kwargs or {}
+    layout = Layout()
+
+    if not data:
+        exit_with_error("No data to display")
+
+    MODEL_TYPE = type(data[0])
+
+    TABLE_PANEL = Layout(name="left")
+    DATA_PANEL = Layout(name="right")
+
+    layout.split_row(TABLE_PANEL, DATA_PANEL)
+
+    TABLE_PANEL.ratio = 7
+    DATA_PANEL.ratio = 3
+    DATA_PANEL.minimum_size = 50
+
+    n_rows = os.get_terminal_size()[1] - 5
+
+    def build_table() -> Layout:
+        """
+        Generate a table of options. The `current_idx` will be highlighted.
+        """
+
+        table = initialize_table()
+        rows = data.copy()
+        rows, offset = paginate_rows(rows)
+        selected_item = add_rows_to_table(table, rows, offset)
+
+        finalize_table(table, prompt, selected_item)
+
+        return layout
+
+    def initialize_table() -> Table:
+        table_kwargs.setdefault("expand", True)
+        table = Table(**table_kwargs)
+        table.add_column()
+        for column in columns:
+            table.add_column(MODEL_TYPE.attr_to_column_header(column))
+        return table
+
+    def paginate_rows(rows: list[T]) -> tuple[list[T], int]:
+        if len(rows) > n_rows:
+            start = max(0, current_idx - n_rows + 1)
+            end = min(len(rows), start + n_rows)
+            rows = rows[start:end]
+            offset = start
+        else:
+            offset = 0
+        return rows, offset
+
+    def add_rows_to_table(table: Table, rows: list[T], offset: int) -> T:
+        selected_item: T = None
+        for i, item in enumerate(rows):
+            idx_with_offset = i + offset
+            is_selected_row = idx_with_offset == current_idx
+            if is_selected_row:
+                selected_item = item
+            table.add_row(*item.to_row(columns, is_selected_row))
+        return selected_item
+
+    def finalize_table(table: Table, prompt: str, selected_item: T) -> None:
+        if table.row_count < n_rows:
+            for _ in range(n_rows - table.row_count):
+                table.add_row()
+
+        TABLE_PANEL.update(Panel(table, title=prompt))
+        DATA_PANEL.update(Panel("", title="Selected Data"))
+        if not selected_item:
+            DATA_PANEL.visible = False
+        elif selected_item.sidebar_data is not None:
+            sidebar_data = selected_item.sidebar_data
+            DATA_PANEL.update(sidebar_data)
+            DATA_PANEL.visible = True
+
+    with Live(build_table(), console=console, transient=True) as live:
+        instructions_message = f"[bold][green]?[/] {prompt} [bright_blue][Use arrows to move; enter to select]"
+        live.console.print(instructions_message)
+        while selected_row is None:
+            key = readchar.readkey()
+
+            start_val = 0
+            offset = 0
+
+            match key:
+                case readchar.key.UP:
+                    offset = -1
+                    start_val = len(data) - 1 if current_idx < 0 else current_idx
+                case readchar.key.PAGE_UP:
+                    offset = -5
+                    start_val = len(data) - 1 if current_idx < 0 else current_idx
+                case readchar.key.DOWN:
+                    offset = 1
+                    start_val = 0 if current_idx >= len(data) else current_idx
+                case readchar.key.PAGE_DOWN:
+                    offset = 5
+                    start_val = 0 if current_idx >= len(data) else current_idx
+                case readchar.key.CTRL_C:
+                    # gracefully exit with no message
+                    exit_with_error("")
+                case readchar.key.ENTER | readchar.key.CR:
+                    selected_row = data[current_idx]
+
+            current_idx = start_val + offset
+
+            if current_idx < 0:
+                current_idx = len(data) - 1
+            elif current_idx >= len(data):
+                current_idx = 0
+
+            live.update(build_table(), refresh=True)
+
+        return selected_row

otf_api/models/__init__.py

@@ -1,13 +1,14 @@
-from .auth import User
 from .responses import (
-    ALL_CLASS_STATUS,
-    ALL_HISTORY_CLASS_STATUS,
-    ALL_STUDIO_STATUS,
+    BodyCompositionList,
+    BookClass,
     BookingList,
     BookingStatus,
+    CancelBooking,
     ChallengeTrackerContent,
     ChallengeTrackerDetailList,
     ChallengeType,
+    ClassType,
+    DoW,
     EquipmentType,
     FavoriteStudioList,
     HistoryClassStatus,
@@ -17,12 +18,14 @@ from .responses import (
     MemberPurchaseList,
     OtfClassList,
     OutOfStudioWorkoutHistoryList,
+    Pagination,
     PerformanceSummaryDetail,
     PerformanceSummaryList,
+    StatsResponse,
+    StatsTime,
     StudioDetail,
     StudioDetailList,
     StudioServiceList,
-    StudioStatus,
     Telemetry,
     TelemetryHrHistory,
     TelemetryMaxHr,
@@ -31,33 +34,37 @@ from .responses import (
 )
 
 __all__ = [
-    "User",
-    "ChallengeType",
-    "BookingStatus",
-    "EquipmentType",
-    "HistoryClassStatus",
-    "StudioStatus",
+    "BodyCompositionList",
+    "BookClass",
     "BookingList",
+    "BookingStatus",
+    "CancelBooking",
     "ChallengeTrackerContent",
     "ChallengeTrackerDetailList",
+    "ChallengeType",
+    "ClassType",
+    "DoW",
+    "EquipmentType",
+    "FavoriteStudioList",
+    "HistoryClassStatus",
     "LatestAgreement",
     "MemberDetail",
     "MemberMembership",
     "MemberPurchaseList",
+    "OtfClassList",
     "OutOfStudioWorkoutHistoryList",
+    "Pagination",
+    "PerformanceSummaryDetail",
+    "PerformanceSummaryList",
+    "StatsResponse",
+    "StatsTime",
+    "StudioDetail",
+    "StudioDetailList",
     "StudioServiceList",
-    "TotalClasses",
-    "WorkoutList",
-    "FavoriteStudioList",
-    "OtfClassList",
-    "TelemetryHrHistory",
+    "StudioStatus",
     "Telemetry",
+    "TelemetryHrHistory",
     "TelemetryMaxHr",
-    "StudioDetail",
-    "StudioDetailList",
-    "ALL_CLASS_STATUS",
-    "ALL_HISTORY_CLASS_STATUS",
-    "ALL_STUDIO_STATUS",
-    "PerformanceSummaryDetail",
-    "PerformanceSummaryList",
+    "TotalClasses",
+    "WorkoutList",
 ]

otf_api/models/base.py

@@ -1,7 +1,210 @@
-from typing import ClassVar
+import inspect
+import typing
+from enum import Enum
+from typing import Any, ClassVar, TypeVar
 
+from box import Box
+from inflection import humanize
 from pydantic import BaseModel, ConfigDict
+from rich.style import Style
+from rich.styled import Styled
+from rich.table import Table
 
+if typing.TYPE_CHECKING:
+    from pydantic.main import IncEx
 
-class OtfBaseModel(BaseModel):
+T = TypeVar("T", bound="OtfItemBase")
+
+
+class BetterDumperMixin:
+    """A better dumper for Pydantic models that includes properties in the dumped data. Must be mixed
+    into a Pydantic model, as it overrides the `model_dump` method.
+
+    Includes support for nested models, and has an option to not include properties when dumping.
+    """
+
+    def get_properties(self) -> list[str]:
+        """Get the properties of the model."""
+        cls = type(self)
+
+        properties: list[str] = []
+        methods = inspect.getmembers(self, lambda f: not (inspect.isroutine(f)))
+        for prop_name, _ in methods:
+            if hasattr(cls, prop_name) and isinstance(getattr(cls, prop_name), property):
+                properties.append(prop_name)
+
+        return properties
+
+    @typing.overload
+    def model_dump(
+        self,
+        *,
+        mode: typing.Literal["json", "python"] | str = "python",
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+        include_properties: bool = True,
+    ) -> Box[str, typing.Any]: ...
+
+    @typing.overload
+    def model_dump(
+        self,
+        *,
+        mode: typing.Literal["json", "python"] | str = "python",
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+        include_properties: bool = False,
+    ) -> dict[str, typing.Any]: ...
+
+    def model_dump(
+        self,
+        *,
+        mode: typing.Literal["json", "python"] | str = "python",
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+        include_properties: bool = True,
+    ) -> dict[str, typing.Any] | Box[str, typing.Any]:
+        """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump
+
+        Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
+        Args:
+            mode: The mode in which `to_python` should run.
+                If mode is 'json', the dictionary will only contain JSON serializable types.
+                If mode is 'python', the dictionary may contain any Python objects.
+            include: A list of fields to include in the output.
+            exclude: A list of fields to exclude from the output.
+            by_alias: Whether to use the field's alias in the dictionary key if defined.
+            exclude_unset: Whether to exclude fields that are unset or None from the output.
+            exclude_defaults: Whether to exclude fields that are set to their default value from the output.
+            exclude_none: Whether to exclude fields that have a value of `None` from the output.
+            round_trip: Whether to enable serialization and deserialization round-trip support.
+            warnings: Whether to log warnings when invalid fields are encountered.
+            include_properties: Whether to include properties in the dumped data.
+
+        Returns:
+            A dictionary representation of the model. Will be a `Box` if `include_properties` is `True`, otherwise a
+            regular dictionary.
+
+        """
+        dumped_data = typing.cast(BaseModel, super()).model_dump(
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+
+        if not include_properties:
+            return dumped_data
+
+        properties = self.get_properties()
+
+        # set properties to their values
+        for prop_name in properties:
+            dumped_data[prop_name] = getattr(self, prop_name)
+
+        # if the property is a Pydantic model, dump it as well
+        for k, v in dumped_data.items():
+            if issubclass(type(getattr(self, k)), BaseModel):
+                dumped_data[k] = getattr(self, k).model_dump()
+            elif hasattr(v, "model_dump"):
+                dumped_data[k] = v.model_dump()
+
+        return Box(dumped_data)
+
+
+class OtfItemBase(BetterDumperMixin, BaseModel):
     model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
+
+    def convert_row_value_types(self, row: list[Any]) -> list[str]:
+        for i, val in enumerate(row):
+            if isinstance(val, bool):
+                row[i] = str(val)
+                continue
+
+            if isinstance(val, Enum):
+                row[i] = val.name
+                continue
+
+            if val is None:
+                row[i] = ""
+                continue
+
+            row[i] = str(val)
+
+        return row
+
+    def get_style(self, is_selected: bool = False) -> Style:
+        return Style(color="blue", bold=True) if is_selected else Style(color="white")
+
+    def to_row(self, attributes: list[str], is_selected: bool = False) -> list[Styled]:
+        style = self.get_style(is_selected)
+
+        boxed_self = Box(self.model_dump(), box_dots=True)
+        row = [boxed_self.get(attr, "") for attr in attributes]
+        row = self.convert_row_value_types(row)
+        styled = [Styled(cell, style=style) for cell in row]
+
+        prefix = "> " if is_selected else "  "
+        styled.insert(0, Styled(prefix, style=style))
+
+        return styled
+
+    @property
+    def sidebar_data(self) -> Table | None:
+        return None
+
+    @classmethod
+    def attr_to_column_header(cls, attr: str) -> str:
+        attr_map = {k: humanize(k) for k in cls.model_fields}
+
+        return attr_map.get(attr, attr)
+
+
+class OtfListBase(BaseModel):
+    model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
+    collection_field: ClassVar[str] = "data"
+
+    @property
+    def collection(self) -> list[OtfItemBase]:
+        return getattr(self, self.collection_field)
+
+    def to_table(self, columns: list[str]) -> Table:
+        table = Table(expand=True, show_header=True, show_footer=False)
+
+        table.add_column()
+        for column in columns:
+            table.add_column(OtfItemBase.attr_to_column_header(column))
+
+        for item in self.collection:
+            table.add_row(*item.to_row(columns))
+
+        return table
+
+    def to_json(self, **kwargs) -> str:
+        kwargs.setdefault("indent", 4)
+        kwargs.setdefault("exclude_none", True)
+
+        return self.model_dump_json(**kwargs)