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

otf_api/__init__.py

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

otf_api/api.py

@@ -3,7 +3,6 @@ import contextlib
 import json
 import typing
 from datetime import date, datetime
-from math import ceil
 from typing import Any
 
 import aiohttp
@@ -43,7 +42,6 @@ from otf_api.models import (
     TelemetryHrHistory,
     TelemetryMaxHr,
     TotalClasses,
-    WorkoutList,
 )
 
 
@@ -226,32 +224,15 @@ class Otf:
         """Perform an API request to the performance summary API."""
         return await self._do(method, API_IO_BASE_URL, url, params, headers)
 
-    async def get_workouts(self) -> WorkoutList:
-        """Get the list of workouts from OT Live.
+    async def get_body_composition_list(self) -> BodyCompositionList:
+        """Get the member's body composition list.
 
         Returns:
-            WorkoutList: The list of workouts.
-
-        Info:
-            ---
-            This returns data from the same api the [OT Live website](https://otlive.orangetheory.com/) uses.
-            It is quite a bit of data, and all workouts going back to ~2019. The data includes the class history
-            UUID, which can be used to get telemetry data for a specific workout.
+            Any: The member's body composition list.
         """
+        data = await self._default_request("GET", f"/member/members/{self._member_uuid}/body-composition")
 
-        res = await self._default_request("GET", "/virtual-class/in-studio-workouts")
-
-        return WorkoutList(workouts=res["data"])
-
-    async def get_total_classes(self) -> TotalClasses:
-        """Get the member's total classes. This is a simple object reflecting the total number of classes attended,
-        both in-studio and OT Live.
-
-        Returns:
-            TotalClasses: The member's total classes.
-        """
-        data = await self._default_request("GET", "/mobile/v1/members/classes/summary")
-        return TotalClasses(**data["data"])
+        return BodyCompositionList(data=data["data"])
 
     async def get_classes(
         self,
@@ -346,6 +327,16 @@ class Otf:
 
         return classes_list
 
+    async def get_total_classes(self) -> TotalClasses:
+        """Get the member's total classes. This is a simple object reflecting the total number of classes attended,
+        both in-studio and OT Live.
+
+        Returns:
+            TotalClasses: The member's total classes.
+        """
+        data = await self._default_request("GET", "/mobile/v1/members/classes/summary")
+        return TotalClasses(**data["data"])
+
     async def book_class(self, class_uuid: str) -> BookClass | typing.Any:
         """Book a class by class_uuid.
 
@@ -860,16 +851,15 @@ class Otf:
         res = await self._telemetry_request("GET", path, params=params)
         return TelemetryMaxHr(**res)
 
-    async def get_telemetry(self, class_history_uuid: str, max_data_points: int = 0) -> Telemetry:
-        """Get the telemetry for a class history.
+    async def get_telemetry(self, performance_summary_id: str, max_data_points: int = 120) -> Telemetry:
+        """Get the telemetry for a performance summary.
 
         This returns an object that contains the max heartrate, start/end bpm for each zone,
         and a list of telemetry items that contain the heartrate, splat points, calories, and timestamp.
 
         Args:
-            class_history_uuid (str): The class history UUID.
-            max_data_points (int): The max data points to use for the telemetry. Default is 0, which will attempt to\
-            get the max data points from the workout. If the workout is not found, it will default to 120 data points.
+            performance_summary_id (str): The performance summary id.
+            max_data_points (int): The max data points to use for the telemetry. Default is 120.
 
         Returns:
             TelemetryItem: The telemetry for the class history.
@@ -877,30 +867,10 @@ class Otf:
         """
         path = "/v1/performance/summary"
 
-        max_data_points = max_data_points or await self._get_max_data_points(class_history_uuid)
-
-        params = {"classHistoryUuid": class_history_uuid, "maxDataPoints": max_data_points}
+        params = {"classHistoryUuid": performance_summary_id, "maxDataPoints": max_data_points}
         res = await self._telemetry_request("GET", path, params=params)
         return Telemetry(**res)
 
-    async def _get_max_data_points(self, class_history_uuid: str) -> int:
-        """Get the max data points to use for the telemetry.
-
-        Attempts to get the amount of active time for the workout from the OT Live API. If the workout is not found,
-        it will default to 120 data points. If it is found, it will calculate the amount of data points needed based on
-        the active time. This should amount to a data point per 30 seconds, roughly.
-
-        Args:
-            class_history_uuid (str): The class history UUID.
-
-        Returns:
-            int: The max data points to use.
-        """
-        workouts = await self.get_workouts()
-        workout = workouts.by_class_history_uuid.get(class_history_uuid)
-        max_data_points = 120 if workout is None else ceil(active_time_to_data_points(workout.active_time))
-        return max_data_points
-
     # the below do not return any data for me, so I can't test them
 
     async def _get_member_services(self, active_only: bool = True) -> typing.Any:
@@ -934,17 +904,3 @@ class Otf:
 
         data = self._default_request("GET", f"/member/wearables/{self._member_id}/wearable-daily", params=params)
         return data
-
-    async def get_body_composition_list(self) -> BodyCompositionList:
-        """Get the member's body composition list.
-
-        Returns:
-            Any: The member's body composition list.
-        """
-        data = await self._default_request("GET", f"/member/members/{self._member_uuid}/body-composition")
-
-        return BodyCompositionList(data=data["data"])
-
-
-def active_time_to_data_points(active_time: int) -> float:
-    return active_time / 60 * 2

otf_api/auth.py

@@ -63,7 +63,8 @@ class OtfCognito(Cognito):
     @device_key.setter
     def device_key(self, value: str | None):
         if not value:
-            logger.info("Clearing device key")
+            if self._device_key:
+                logger.info("Clearing device key")
             self._device_key = value
             return
 

otf_api/models/__init__.py

@@ -30,7 +30,6 @@ from .responses import (
     TelemetryHrHistory,
     TelemetryMaxHr,
     TotalClasses,
-    WorkoutList,
 )
 
 __all__ = [
@@ -66,5 +65,4 @@ __all__ = [
     "TelemetryHrHistory",
     "TelemetryMaxHr",
     "TotalClasses",
-    "WorkoutList",
 ]

otf_api/models/base.py

@@ -1,14 +1,9 @@
 import inspect
 import typing
-from enum import Enum
-from typing import Any, ClassVar, TypeVar
+from typing import 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
@@ -138,50 +133,6 @@ class BetterDumperMixin:
 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")
@@ -191,18 +142,6 @@ class OtfListBase(BaseModel):
     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)

otf_api/models/responses/__init__.py

@@ -21,7 +21,6 @@ from .telemetry import Telemetry
 from .telemetry_hr_history import TelemetryHrHistory
 from .telemetry_max_hr import TelemetryMaxHr
 from .total_classes import TotalClasses
-from .workouts import WorkoutList
 
 __all__ = [
     "BodyCompositionList",
@@ -56,5 +55,4 @@ __all__ = [
     "TelemetryHrHistory",
     "TelemetryMaxHr",
     "TotalClasses",
-    "WorkoutList",
 ]

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/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/models/responses/performance_summary_list.py

@@ -33,7 +33,7 @@ class Studio(OtfItemBase):
 class Class(OtfItemBase):
     ot_base_class_uuid: str | None = None
     starts_at_local: str
-    name: str
+    name: str | None = None
     coach: Coach
     studio: Studio
 
@@ -56,7 +56,7 @@ class Ratings(OtfItemBase):
 
 
 class PerformanceSummaryEntry(OtfItemBase):
-    performance_summary_id: str = Field(..., alias="id")
+    id: str = Field(..., alias="id")
     details: Details
     ratable: bool
     otf_class: Class = Field(..., alias="class")

{otf_api-0.4.0.dist-info → otf_api-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: otf-api
-Version: 0.4.0
+Version: 0.6.0
 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.8.*)
 Requires-Dist: humanize (>=4.9.0,<5.0.0)
 Requires-Dist: inflection (==0.5.*)
 Requires-Dist: loguru (==0.7.2)
@@ -27,15 +27,13 @@ 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.4.0.dist-info → otf_api-0.6.0.dist-info}/RECORD

@@ -1,21 +1,16 @@
-otf_api/__init__.py,sha256=r_Pbfy17O3PShjKEtmGbzMz77vKm6QIWf7nj1euogiw,237
-otf_api/api.py,sha256=4yiYQb_ShBduk0E9JLRs_PzLFEBDIw7c59FFE34BuKo,36749
-otf_api/auth.py,sha256=eapyHm768j402iqwgKOr2hpqzztXS8DBp021TSK0Txk,10194
-otf_api/cli/__init__.py,sha256=WI-882LPH7Tj_ygDHqE5ehsas_u7m3ulsplS9vXKByk,151
-otf_api/cli/_utilities.py,sha256=epjEO9S6ag4HgJLXlTpCQXfdVQkqGWyNavp7DjwPL78,1753
-otf_api/cli/app.py,sha256=88TuMwq3foRr1Cui0V3h0mxNkoANqd6QQifI9CIgLvI,6469
-otf_api/cli/bookings.py,sha256=wSmZA-03etcL6Tvb1vDSvHZW8EA9CZUgKX6W1pps3Yw,8161
-otf_api/cli/prompts.py,sha256=iyodQXVa5v9VsrMxw0ob1okGRBDbWCSxhrNEylsOTEQ,5358
-otf_api/models/__init__.py,sha256=2Zvf7u1Z3qguDd4PsWeoP_Lma3bk-A7RmYQ4LbPJ9Kg,1464
-otf_api/models/base.py,sha256=oTDxyliK64GyTNx1bGTd-b9dfVn0r3YPpSycs2qEuIw,7285
-otf_api/models/responses/__init__.py,sha256=UdJhkzREux-5DnHE5VSYN0KNKxyDkUkYMPWQpa9Y9qs,2000
+otf_api/__init__.py,sha256=eRrcOgzcFV7KIhf6KwQ5AnvOaGfAam3AKbP01hAFOys,237
+otf_api/api.py,sha256=QlRHXDwzbB97aCfacb_9FVox-5AuPLMweRQAZkz-EE0,34885
+otf_api/auth.py,sha256=XzwLSi5M3DyG7bE7DmWAzXF2y6fkJyAZxHUA9lpW25M,10231
+otf_api/models/__init__.py,sha256=3GHBOirQA4yu06cgD9pYmCU8u8_F9nxNHeSXDuFpe5A,1428
+otf_api/models/base.py,sha256=FrYzMVA4-EWhaKwzem8bEAzRu_jK-RTCkDj5ihTSkZM,5442
+otf_api/models/responses/__init__.py,sha256=xxwz-JwRd0upmI0VNdvInbAm2FOQvPo3pS0SEhWfkI4,1947
 otf_api/models/responses/body_composition_list.py,sha256=RTC5bQpmMDUKqFl0nGFExdDxfnbOAGoBLWunjpOym80,12193
 otf_api/models/responses/book_class.py,sha256=bWURKEjLZWPzwu3HNP2zUmHWo7q7h6_z43a9KTST0Ec,15413
-otf_api/models/responses/bookings.py,sha256=0oQxdKTK-k30GVDKiVxTh0vvPTbrw78sqpQpYL7JnJU,11058
+otf_api/models/responses/bookings.py,sha256=XwW6blHpw9imtXRnQJYahUgfrAeOcGZqfYE-oJZ8510,8467
 otf_api/models/responses/cancel_booking.py,sha256=dmC5OP97Dy4qYT0l1KHYIitqSCo6M6Yqa0QztjgG_xQ,3859
 otf_api/models/responses/challenge_tracker_content.py,sha256=KKpSWyyg3viN0vf1Sg2zTMlMZExLe3I6wowmUPWvRCA,1423
 otf_api/models/responses/challenge_tracker_detail.py,sha256=o0y_ETfHmR1QhoOmvd83P6lfMZUPIwPlnS1V_po0dkE,3048
-otf_api/models/responses/classes.py,sha256=wmFMcFT-VLqOFB65pApffNPH6VFS150CEKHMq2MblI4,7090
+otf_api/models/responses/classes.py,sha256=VxesbFyfRhohwkjiclqTtMPl8bNc5PJajveTHtDBQ2A,4731
 otf_api/models/responses/enums.py,sha256=Au8XhD-4T8ljiueUykFDc6Qz7kOoTlJ_kiDEx7nLVLM,1191
 otf_api/models/responses/favorite_studios.py,sha256=C5JSyiNijm6HQEBVrV9vPfZexSWQ1IlN0E3Ag0GeP_0,4982
 otf_api/models/responses/latest_agreement.py,sha256=aE8hbWE4Pgguw4Itah7a1SqwOLpJ6t9oODFwLQ8Wzo0,774
@@ -25,18 +20,16 @@ otf_api/models/responses/member_membership.py,sha256=_z301T9DrdQW9vIgnx_LeZmkRhv
 otf_api/models/responses/member_purchases.py,sha256=JoTk3hYjsq4rXogVivZxeFaM-j3gIChmIAGVldOU7rE,6085
 otf_api/models/responses/out_of_studio_workout_history.py,sha256=FwdnmTgFrMtQ8PngsmCv3UroWj3kDnQg6KfGLievoaU,1709
 otf_api/models/responses/performance_summary_detail.py,sha256=H5yWxGShR4uiXvY2OaniENburTGM7DKQjN7gvF3MG6g,1585
-otf_api/models/responses/performance_summary_list.py,sha256=1cbRX4bnLWwy6iYT6NmJXaT2AdZKGJvQMezkvcGLO58,1240
+otf_api/models/responses/performance_summary_list.py,sha256=R__tsXGz5tVX5gfoRoVUNK4UP2pXRoK5jdSyHABsDXs,1234
 otf_api/models/responses/studio_detail.py,sha256=CJBCsi4SMs_W5nrWE4hfCs1ugJ5t7GrH80hTv7Ie3eg,5007
 otf_api/models/responses/studio_services.py,sha256=mFDClPtU0HCk5fb19gjGKpt2F8n8kto7sj1pE_l4RdQ,1836
 otf_api/models/responses/telemetry.py,sha256=8dl8FKLeyb6jtqsZT7XD4JzXBMLlami448-Jt0tFbSY,1663
 otf_api/models/responses/telemetry_hr_history.py,sha256=vDcLb4wTHVBw8O0mGblUujHfJegkflOCWW-bnTXNCI0,763
 otf_api/models/responses/telemetry_max_hr.py,sha256=xKxH0fIlOqFyZv8UW98XsxF-GMoIs9gnCTAbu88ZQtg,266
 otf_api/models/responses/total_classes.py,sha256=WrKkWbq0eK8J0RC4qhZ5kmXnv_ZTDbyzsoRm7XKGlss,288
-otf_api/models/responses/workouts.py,sha256=4r6wQVY-yUsI83JYBpSCYhd7I5u-5OLvy1Vd1_gra88,3177
 otf_api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-otf_api-0.4.0.dist-info/AUTHORS.md,sha256=FcNWMxpe8KDuTq4Qau0SUXsabQwGs9TGnMp1WkXRnj8,123
-otf_api-0.4.0.dist-info/LICENSE,sha256=UaPT9ynYigC3nX8n22_rC37n-qmTRKLFaHrtUwF9ktE,1071
-otf_api-0.4.0.dist-info/METADATA,sha256=0VCBjMyO3Wrka4Jz0ZwB38zm5KxVOlb-H1ZL6_M64WU,2259
-otf_api-0.4.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-otf_api-0.4.0.dist-info/entry_points.txt,sha256=V2jhhfsUo3DeF0CA9HmKrMnvSoOldn9ShIzbApbeHTY,44
-otf_api-0.4.0.dist-info/RECORD,,
+otf_api-0.6.0.dist-info/AUTHORS.md,sha256=FcNWMxpe8KDuTq4Qau0SUXsabQwGs9TGnMp1WkXRnj8,123
+otf_api-0.6.0.dist-info/LICENSE,sha256=UaPT9ynYigC3nX8n22_rC37n-qmTRKLFaHrtUwF9ktE,1071
+otf_api-0.6.0.dist-info/METADATA,sha256=lzG11-AQbcrEr5whF8QiBWSeJljHCG3V2OL_I1hDl6M,2031
+otf_api-0.6.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+otf_api-0.6.0.dist-info/RECORD,,

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/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/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/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/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/models/responses/workouts.py

@@ -1,78 +0,0 @@
-from ast import literal_eval
-from datetime import datetime
-from typing import Any
-
-from pydantic import Field, PrivateAttr
-
-from otf_api.models.base import OtfItemBase
-
-
-class WorkoutType(OtfItemBase):
-    id: int
-    display_name: str = Field(..., alias="displayName")
-    icon: str
-
-
-class Workout(OtfItemBase):
-    studio_number: str = Field(..., alias="studioNumber")
-    studio_name: str = Field(..., alias="studioName")
-    class_type: str = Field(..., alias="classType")
-    active_time: int = Field(..., alias="activeTime")
-    coach: str
-    member_uuid: str = Field(..., alias="memberUuId")
-    class_date: datetime = Field(..., alias="classDate")
-    total_calories: int = Field(..., alias="totalCalories")
-    avg_hr: int = Field(..., alias="avgHr")
-    max_hr: int = Field(..., alias="maxHr")
-    avg_percent_hr: int = Field(..., alias="avgPercentHr")
-    max_percent_hr: int = Field(..., alias="maxPercentHr")
-    total_splat_points: int = Field(..., alias="totalSplatPoints")
-    red_zone_time_second: int = Field(..., alias="redZoneTimeSecond")
-    orange_zone_time_second: int = Field(..., alias="orangeZoneTimeSecond")
-    green_zone_time_second: int = Field(..., alias="greenZoneTimeSecond")
-    blue_zone_time_second: int = Field(..., alias="blueZoneTimeSecond")
-    black_zone_time_second: int = Field(..., alias="blackZoneTimeSecond")
-    step_count: int = Field(..., alias="stepCount")
-    class_history_uuid: str = Field(..., alias="classHistoryUuId")
-    class_id: str = Field(..., alias="classId")
-    date_created: datetime = Field(..., alias="dateCreated")
-    date_updated: datetime = Field(..., alias="dateUpdated")
-    is_intro: bool = Field(..., alias="isIntro")
-    is_leader: bool = Field(..., alias="isLeader")
-    member_email: None = Field(..., alias="memberEmail")
-    member_name: str = Field(..., alias="memberName")
-    member_performance_id: str = Field(..., alias="memberPerformanceId")
-    minute_by_minute_hr: list[int] = Field(
-        ...,
-        alias="minuteByMinuteHr",
-        description="HR data for each minute of the workout. It is returned as a string literal, so it needs to be "
-        "evaluated to a list. If can't be parsed, it will return an empty list.",
-    )
-    source: str
-    studio_account_uuid: str = Field(..., alias="studioAccountUuId")
-    version: str
-    workout_type: WorkoutType = Field(..., alias="workoutType")
-    _minute_by_minute_raw: str | None = PrivateAttr(None)
-
-    @property
-    def active_time_minutes(self) -> int:
-        """Get the active time in minutes."""
-        return self.active_time // 60
-
-    def __init__(self, **data: Any):
-        if "minuteByMinuteHr" in data:
-            try:
-                data["minuteByMinuteHr"] = literal_eval(data["minuteByMinuteHr"])
-            except (ValueError, SyntaxError):
-                data["minuteByMinuteHr"] = []
-
-        super().__init__(**data)
-        self._minute_by_minute_raw = data.get("minuteByMinuteHr")
-
-
-class WorkoutList(OtfItemBase):
-    workouts: list[Workout]
-
-    @property
-    def by_class_history_uuid(self) -> dict[str, Workout]:
-        return {workout.class_history_uuid: workout for workout in self.workouts}

otf_api-0.4.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-otf=otf_api.cli:base_app
-