otf-api 0.5.0__tar.gz → 0.6.1__tar.gz

{otf_api-0.5.0 → otf_api-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: otf-api
-Version: 0.5.0
+Version: 0.6.1
 Summary: Python OrangeTheory Fitness API Client
 License: MIT
 Author: Jessica Smith
@@ -18,7 +18,7 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: aiohttp (==3.9.5)
+Requires-Dist: aiohttp (==3.10.*)
 Requires-Dist: humanize (>=4.9.0,<5.0.0)
 Requires-Dist: inflection (==0.5.*)
 Requires-Dist: loguru (==0.7.2)
@@ -26,16 +26,13 @@ Requires-Dist: pendulum (>=3.0.0,<4.0.0)
 Requires-Dist: pint (==0.24.*)
 Requires-Dist: pycognito (==2024.5.1)
 Requires-Dist: pydantic (==2.7.3)
-Requires-Dist: python-box (>=7.2.0,<8.0.0)
-Requires-Dist: readchar (>=4.1.0,<5.0.0)
-Requires-Dist: typer (>=0.12.3,<0.13.0)
 Project-URL: Documentation, https://otf-api.readthedocs.io/en/stable/
 Description-Content-Type: text/markdown
 
 Simple API client for interacting with the OrangeTheory Fitness APIs.
 
 
-This library allows access to the OrangeTheory API to retrieve workouts and performance data, class schedules, studio information, and bookings. It is a work in progress, currently only allowing access to GET calls, but my goal is to expand it to include POST, PUT, and DELETE calls as well.
+This library allows access to the OrangeTheory API to retrieve workouts and performance data, class schedules, studio information, and bookings.
 
 ## Installation
 ```bash

{otf_api-0.5.0 → otf_api-0.6.1}/README.md

@@ -1,7 +1,7 @@
 Simple API client for interacting with the OrangeTheory Fitness APIs.
 
 
-This library allows access to the OrangeTheory API to retrieve workouts and performance data, class schedules, studio information, and bookings. It is a work in progress, currently only allowing access to GET calls, but my goal is to expand it to include POST, PUT, and DELETE calls as well.
+This library allows access to the OrangeTheory API to retrieve workouts and performance data, class schedules, studio information, and bookings.
 
 ## Installation
 ```bash

{otf_api-0.5.0 → otf_api-0.6.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "otf-api"
-version = "0.5.0"
+version = "0.6.1"
 description = "Python OrangeTheory Fitness API Client"
 authors = ["Jessica Smith <j.smith.git1@gmail.com>"]
 license = "MIT"
@@ -22,7 +22,7 @@ classifiers = [
 
 [tool.poetry.dependencies]
 python = "^3.10"
-aiohttp = "3.9.5"
+aiohttp = "3.10.*"
 humanize = "^4.9.0"
 inflection = "0.5.*"
 loguru = "0.7.2"
@@ -30,9 +30,6 @@ pendulum = "^3.0.0"
 pint = "0.24.*"
 pycognito = "2024.5.1"
 pydantic = "2.7.3"
-python-box = "^7.2.0"
-readchar = "^4.1.0"
-typer = "^0.12.3"
 
 [tool.poetry.group.dev.dependencies]
 aioresponses = "0.7.6"
@@ -48,7 +45,7 @@ pytest-cov = "5.0.0"
 pytest-loguru = "0.4.0"
 ruff = "0.4.9"
 tox = "4.15.1"
-twine = "5.1.0"
+twine = "5.1.1"
 
 
 [tool.poetry.group.docs.dependencies]
@@ -65,19 +62,15 @@ mkdocs-material-extensions = "1.3.1"
 mkdocs-section-index = "0.3.9"
 mkdocstrings = "0.25.1"
 mkdocstrings-python = "1.10.3"
-pkginfo = "^1.11.1"
+pkginfo = "<1.11"
 setuptools = "^70.0.0"
 virtualenv = "^20.26.2"
+griffe = "<1.0.0"
 
 
-[tool.poetry.group.cli.dependencies]
-
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.pytest.ini_options]
 pythonpath = ["src"]
-
-[tool.poetry.scripts]
-otf = "otf_api.cli:base_app"

{otf_api-0.5.0 → otf_api-0.6.1}/src/otf_api/__init__.py

@@ -6,7 +6,7 @@ from loguru import logger
 from .api import Otf
 from .auth import OtfUser
 
-__version__ = "0.5.0"
+__version__ = "0.6.1"
 
 
 __all__ = ["Otf", "OtfUser"]

otf_api-0.6.1/src/otf_api/models/base.py

@@ -0,0 +1,22 @@
+from typing import ClassVar
+
+from pydantic import BaseModel, ConfigDict
+
+
+class OtfItemBase(BaseModel):
+    model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+
+
+class OtfListBase(BaseModel):
+    model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+    collection_field: ClassVar[str] = "data"
+
+    @property
+    def collection(self) -> list[OtfItemBase]:
+        return getattr(self, self.collection_field)
+
+    def to_json(self, **kwargs) -> str:
+        kwargs.setdefault("indent", 4)
+        kwargs.setdefault("exclude_none", True)
+
+        return self.model_dump_json(**kwargs)

{otf_api-0.5.0 → otf_api-0.6.1}/src/otf_api/models/responses/bookings.py

@@ -4,9 +4,6 @@ from typing import ClassVar
 
 from inflection import humanize
 from pydantic import Field
-from rich.style import Style
-from rich.styled import Styled
-from rich.table import Table
 
 from otf_api.models.base import OtfItemBase, OtfListBase
 from otf_api.models.responses.classes import OtfClassTimeMixin
@@ -223,82 +220,7 @@ class Booking(OtfItemBase):
     def id_val(self) -> str:
         return self.class_booking_id
 
-    @property
-    def sidebar_data(self) -> Table:
-        data = {
-            "date": self.otf_class.date,
-            "class_name": self.otf_class.name,
-            "description": self.otf_class.description,
-            "class_id": self.id_val,
-            "studio_address": self.otf_class.studio.studio_location.physical_address,
-            "coach_name": self.otf_class.coach.name,
-        }
-
-        table = Table(expand=True, show_header=False, show_footer=False)
-        table.add_column("Key", style="cyan", ratio=1)
-        table.add_column("Value", style="magenta", ratio=2)
-
-        for key, value in data.items():
-            if value is False:
-                table.add_row(key, Styled(str(value), style="red"))
-            else:
-                table.add_row(key, str(value))
-
-        return table
-
-    def get_style(self, is_selected: bool = False) -> Style:
-        style = super().get_style(is_selected)
-        if self.status == BookingStatus.Cancelled:
-            style = Style(color="red")
-        elif self.status == BookingStatus.Waitlisted:
-            style = Style(color="yellow")
-        elif self.status == BookingStatus.CheckedIn and is_selected:
-            style = Style(color="blue", strike=True)
-        elif self.status == BookingStatus.CheckedIn:
-            style = Style(color="grey58")
-
-        return style
-
-    @classmethod
-    def attr_to_column_header(cls, attr: str) -> str:
-        if attr.startswith("otf_class"):
-            return OtfClass.attr_to_column_header(attr.split(".")[-1])
-
-        attr_map = {k: humanize(k) for k in cls.model_fields}
-        overrides = {
-            "day_of_week": "Class DoW",
-            "date": "Class Date",
-            "time": "Class Time",
-            "duration": "Class Duration",
-            "name": "Class Name",
-            "is_home_studio": "Home Studio",
-            "is_booked": "Booked",
-        }
-
-        attr_map.update(overrides)
-
-        return attr_map.get(attr, attr)
-
 
 class BookingList(OtfListBase):
     collection_field: ClassVar[str] = "bookings"
     bookings: list[Booking]
-
-    @staticmethod
-    def show_bookings_columns() -> list[str]:
-        return [
-            "otf_class.day_of_week",
-            "otf_class.date",
-            "otf_class.time",
-            "otf_class.duration",
-            "otf_class.name",
-            "status",
-            "otf_class.studio.studio_name",
-            "is_home_studio",
-        ]
-
-    def to_table(self, columns: list[str] | None = None) -> Table:
-        if not columns:
-            columns = self.show_bookings_columns()
-
-        return super().to_table(columns)

{otf_api-0.5.0 → otf_api-0.6.1}/src/otf_api/models/responses/classes.py

@@ -3,11 +3,7 @@ from enum import Enum
 from typing import ClassVar
 
 from humanize import precisedelta
-from inflection import humanize
 from pydantic import Field
-from rich.style import Style
-from rich.styled import Styled
-from rich.table import Table
 
 from otf_api.models.base import OtfItemBase, OtfListBase
 
@@ -176,80 +172,7 @@ class OtfClass(OtfItemBase, OtfClassTimeMixin):
         dow = self.starts_at_local.strftime("%A")
         return DoW.get_case_insensitive(dow)
 
-    @property
-    def sidebar_data(self) -> Table:
-        data = {
-            "class_date": self.date,
-            "class_time": self.time.strip(),
-            "class_name": self.name,
-            "class_id": self.id_val,
-            "available": self.has_availability,
-            "waitlist_available": self.waitlist_available,
-            "studio_address": self.studio.address.line1,
-            "coach_name": self.coach.first_name,
-            "waitlist_size": self.waitlist_size,
-            "max_capacity": self.max_capacity,
-        }
-
-        if not self.full:
-            del data["waitlist_available"]
-            del data["waitlist_size"]
-
-        table = Table(expand=True, show_header=False, show_footer=False)
-        table.add_column("Key", style="cyan", ratio=1)
-        table.add_column("Value", style="magenta", ratio=2)
-
-        for key, value in data.items():
-            if value is False:
-                table.add_row(key, Styled(str(value), style="red"))
-            else:
-                table.add_row(key, str(value))
-
-        return table
-
-    def get_style(self, is_selected: bool = False) -> Style:
-        style = super().get_style(is_selected)
-        if self.is_booked:
-            style = Style(color="grey58")
-        return style
-
-    @classmethod
-    def attr_to_column_header(cls, attr: str) -> str:
-        attr_map = {k: humanize(k) for k in cls.model_fields}
-        overrides = {
-            "day_of_week": "Class DoW",
-            "date": "Class Date",
-            "time": "Class Time",
-            "duration": "Class Duration",
-            "name": "Class Name",
-            "is_home_studio": "Home Studio",
-            "is_booked": "Booked",
-        }
-
-        attr_map.update(overrides)
-
-        return attr_map.get(attr, attr)
-
 
 class OtfClassList(OtfListBase):
     collection_field: ClassVar[str] = "classes"
     classes: list[OtfClass]
-
-    @staticmethod
-    def book_class_columns() -> list[str]:
-        return [
-            "day_of_week",
-            "date",
-            "time",
-            "duration",
-            "name",
-            "studio.name",
-            "is_home_studio",
-            "is_booked",
-        ]
-
-    def to_table(self, columns: list[str] | None = None) -> Table:
-        if not columns:
-            columns = self.book_class_columns()
-
-        return super().to_table(columns)

{otf_api-0.5.0 → otf_api-0.6.1}/src/otf_api/models/responses/member_detail.py

@@ -101,7 +101,7 @@ class MemberDetail(OtfItemBase):
     state: None
     postal_code: None = Field(..., alias="postalCode")
     phone_number: str = Field(..., alias="phoneNumber")
-    home_phone: str = Field(..., alias="homePhone")
+    home_phone: str | None = Field(..., alias="homePhone")
     work_phone: None = Field(..., alias="workPhone")
     phone_type: None = Field(..., alias="phoneType")
     birth_day: date | str = Field(..., alias="birthDay")

{otf_api-0.5.0 → otf_api-0.6.1}/src/otf_api/models/responses/performance_summary_list.py

@@ -34,6 +34,7 @@ class Class(OtfItemBase):
     ot_base_class_uuid: str | None = None
     starts_at_local: str
     name: str | None = None
+    type: str | None = None
     coach: Coach
     studio: Studio
 

{otf_api-0.5.0 → otf_api-0.6.1}/src/otf_api/models/responses/telemetry.py

@@ -25,6 +25,14 @@ class TreadData(OtfItemBase):
     agg_tread_distance: int = Field(..., alias="aggTreadDistance")
 
 
+class RowData(OtfItemBase):
+    row_speed: float = Field(..., alias="rowSpeed")
+    row_pps: float = Field(..., alias="rowPps")
+    row_Spm: float = Field(..., alias="rowSpm")
+    agg_row_distance: int = Field(..., alias="aggRowDistance")
+    row_pace: int = Field(..., alias="rowPace")
+
+
 class TelemetryItem(OtfItemBase):
     relative_timestamp: int = Field(..., alias="relativeTimestamp")
     hr: int
@@ -36,6 +44,7 @@ class TelemetryItem(OtfItemBase):
         description="The timestamp of the telemetry item, calculated from the class start time and relative timestamp.",
     )
     tread_data: TreadData | None = Field(None, alias="treadData")
+    row_data: RowData | None = Field(None, alias="rowData")
 
 
 class Telemetry(OtfItemBase):

otf_api-0.5.0/src/otf_api/cli/__init__.py

@@ -1,4 +0,0 @@
-from otf_api.cli.app import base_app
-from otf_api.cli.bookings import bookings_app, classes_app
-
-__all__ = ["base_app", "bookings_app", "classes_app"]

otf_api-0.5.0/src/otf_api/cli/_utilities.py

@@ -1,60 +0,0 @@
-import functools
-import inspect
-import traceback
-from collections.abc import Awaitable, Callable
-from typing import Any, NoReturn, ParamSpec, TypeGuard, TypeVar
-
-import typer
-from click.exceptions import ClickException
-
-T = TypeVar("T")
-P = ParamSpec("P")
-R = TypeVar("R")
-
-
-def is_async_fn(func: Callable[P, R] | Callable[P, Awaitable[R]]) -> TypeGuard[Callable[P, Awaitable[R]]]:
-    """
-    Returns `True` if a function returns a coroutine.
-
-    See https://github.com/microsoft/pyright/issues/2142 for an example use
-    """
-    while hasattr(func, "__wrapped__"):
-        func = func.__wrapped__
-
-    return inspect.iscoroutinefunction(func)
-
-
-def exit_with_error(message: Any, code: int = 1, **kwargs: Any) -> NoReturn:
-    """
-    Utility to print a stylized error message and exit with a non-zero code
-    """
-    from otf_api.cli.app import base_app
-
-    kwargs.setdefault("style", "red")
-    base_app.console.print(message, **kwargs)
-    raise typer.Exit(code)
-
-
-def exit_with_success(message: Any, **kwargs: Any) -> NoReturn:
-    """
-    Utility to print a stylized success message and exit with a zero code
-    """
-    from otf_api.cli.app import base_app
-
-    kwargs.setdefault("style", "green")
-    base_app.console.print(message, **kwargs)
-    raise typer.Exit(0)
-
-
-def with_cli_exception_handling(fn: Callable[[Any], Any]) -> Callable[[Any], Any]:
-    @functools.wraps(fn)
-    def wrapper(*args: Any, **kwargs: Any) -> Any | None:
-        try:
-            return fn(*args, **kwargs)
-        except (typer.Exit, typer.Abort, ClickException):
-            raise  # Do not capture click or typer exceptions
-        except Exception:
-            traceback.print_exc()
-            exit_with_error("An exception occurred.")
-
-    return wrapper

otf_api-0.5.0/src/otf_api/cli/app.py

@@ -1,172 +0,0 @@
-import asyncio
-import functools
-import sys
-import typing
-from collections.abc import Callable
-from enum import Enum
-
-import typer
-from loguru import logger
-from rich.console import Console
-from rich.theme import Theme
-
-import otf_api
-from otf_api.cli._utilities import is_async_fn, with_cli_exception_handling
-
-if typing.TYPE_CHECKING:
-    from otf_api import Otf
-
-
-class OutputType(str, Enum):
-    json = "json"
-    table = "table"
-    interactive = "interactive"
-
-
-def version_callback(value: bool) -> None:
-    if value:
-        print(otf_api.__version__)
-        raise typer.Exit()
-
-
-OPT_USERNAME: str = typer.Option(None, envvar=["OTF_EMAIL", "OTF_USERNAME"], help="Username for the OTF API")
-OPT_PASSWORD: str = typer.Option(envvar="OTF_PASSWORD", help="Password for the OTF API", hide_input=True)
-OPT_OUTPUT: OutputType = typer.Option(None, envvar="OTF_OUTPUT", show_default=False, help="Output format")
-OPT_LOG_LEVEL: str = typer.Option("CRITICAL", help="Log level", envvar="OTF_LOG_LEVEL")
-OPT_VERSION: bool = typer.Option(
-    None, "--version", callback=version_callback, help="Display the current version.", is_eager=True
-)
-
-
-def register_main_callback(app: "AsyncTyper") -> None:
-    @app.callback()  # type: ignore
-    @with_cli_exception_handling
-    def main_callback(
-        ctx: typer.Context,  # noqa
-        version: bool = OPT_VERSION,  # noqa
-        username: str = OPT_USERNAME,
-        password: str = OPT_PASSWORD,
-        output: OutputType = OPT_OUTPUT,
-        log_level: str = OPT_LOG_LEVEL,
-    ) -> None:
-        app.setup_console()
-        app.set_username(username)
-        app.password = password
-        app.output = output or OutputType.table
-        app.set_log_level(log_level)
-
-        # When running on Windows we need to ensure that the correct event loop policy is
-        # in place or we will not be able to spawn subprocesses. Sometimes this policy is
-        # changed by other libraries, but here in our CLI we should have ownership of the
-        # process and be able to safely force it to be the correct policy.
-        # https://github.com/PrefectHQ/prefect/issues/8206
-        if sys.platform == "win32":
-            asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())
-
-
-class AsyncTyper(typer.Typer):
-    """
-    Wraps commands created by `Typer` to support async functions and handle errors.
-    """
-
-    console: Console
-
-    def __init__(self, *args: typing.Any, **kwargs: typing.Any):
-        super().__init__(*args, **kwargs)
-
-        theme = Theme({"prompt.choices": "bold blue"})
-        self.console = Console(highlight=False, theme=theme, color_system="auto")
-
-        # TODO: clean these up later, just don't want warnings everywhere that these could be None
-        self.api: Otf = None  # type: ignore
-        self.username: str = None  # type: ignore
-        self.password: str = None  # type: ignore
-        self.output: OutputType = None  # type: ignore
-        self.logger = logger
-        self.log_level = "CRITICAL"
-
-    def set_username(self, username: str | None = None) -> None:
-        if username:
-            self.username = username
-            return
-
-        raise ValueError("Username not provided and not found in cache")
-
-    def set_log_level(self, level: str) -> None:
-        self.log_level = level
-        logger.remove()
-        logger.add(sys.stderr, level=self.log_level.upper())
-
-    def print(self, *args: typing.Any, **kwargs: typing.Any) -> None:
-        if self.output == "json":
-            self.console.print_json(*args, **kwargs)
-        else:
-            self.console.print(*args, **kwargs)
-
-    def add_typer(
-        self, typer_instance: "AsyncTyper", *args: typing.Any, aliases: list[str] | None = None, **kwargs: typing.Any
-    ) -> typing.Any:
-        aliases = aliases or []
-        for alias in aliases:
-            super().add_typer(typer_instance, *args, name=alias, no_args_is_help=True, hidden=True, **kwargs)
-
-        return super().add_typer(typer_instance, *args, no_args_is_help=True, **kwargs)
-
-    def command(
-        self, name: str | None = None, *args: typing.Any, aliases: list[str] | None = None, **kwargs: typing.Any
-    ) -> Callable[[typing.Any], typing.Any]:
-        """
-        Create a new command. If aliases are provided, the same command function
-        will be registered with multiple names.
-        """
-
-        aliases = aliases or []
-
-        def wrapper(fn: Callable[[typing.Any], typing.Any]) -> Callable[[typing.Any], typing.Any]:
-            # click doesn't support async functions, so we wrap them in
-            # asyncio.run(). This has the advantage of keeping the function in
-            # the main thread, which means signal handling works for e.g. the
-            # server and workers. However, it means that async CLI commands can
-            # not directly call other async CLI commands (because asyncio.run()
-            # can not be called nested). In that (rare) circumstance, refactor
-            # the CLI command so its business logic can be invoked separately
-            # from its entrypoint.
-            if is_async_fn(fn):
-                _fn = fn
-
-                @functools.wraps(fn)
-                def fn(*args: typing.Any, **kwargs: typing.Any) -> typing.Any:
-                    return asyncio.run(_fn(*args, **kwargs))  # type: ignore
-
-                fn.aio = _fn  # type: ignore
-
-            fn = with_cli_exception_handling(fn)
-
-            # register fn with its original name
-            command_decorator = super(AsyncTyper, self).command(name=name, *args, **kwargs)
-            original_command = command_decorator(fn)
-
-            # register fn for each alias, e.g. @marvin_app.command(aliases=["r"])
-            for alias in aliases:
-                super(AsyncTyper, self).command(
-                    name=alias,
-                    *args,
-                    **{k: v for k, v in kwargs.items() if k != "aliases"},
-                )(fn)
-
-            return typing.cast(Callable[[typing.Any], typing.Any], original_command)
-
-        return wrapper
-
-    def setup_console(self, soft_wrap: bool = True, prompt: bool = True) -> None:
-        self.console = Console(
-            highlight=False,
-            color_system="auto",
-            theme=Theme({"prompt.choices": "bold blue"}),
-            soft_wrap=not soft_wrap,
-            force_interactive=prompt,
-        )
-
-
-base_app = AsyncTyper(add_completion=True, no_args_is_help=True)
-register_main_callback(base_app)

otf_api-0.5.0/src/otf_api/cli/bookings.py

@@ -1,231 +0,0 @@
-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-0.5.0/src/otf_api/cli/prompts.py

@@ -1,162 +0,0 @@
-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-0.5.0/src/otf_api/models/base.py

@@ -1,210 +0,0 @@
-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
-
-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)