otf-api 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

otf_api/__init__.py

@@ -3,13 +3,13 @@ import sys
 
 from loguru import logger
 
-from .api import Api
-from .models.auth import User
+from .api import Otf
+from .auth import OtfUser
 
-__version__ = "0.3.0"
+__version__ = "0.5.0"
 
 
-__all__ = ["Api", "User"]
+__all__ = ["Otf", "OtfUser"]
 
 logger.remove()
 logger.add(sink=sys.stdout, level=os.getenv("OTF_LOG_LEVEL", "INFO"))

otf_api/api.py

@@ -3,42 +3,45 @@ import contextlib
 import json
 import typing
 from datetime import date, datetime
-from math import ceil
 from typing import Any
 
 import aiohttp
+import requests
 from loguru import logger
 from yarl import URL
 
-from otf_api.models.auth import User
-from otf_api.models.responses.body_composition_list import BodyCompositionList
-from otf_api.models.responses.book_class import BookClass
-from otf_api.models.responses.cancel_booking import CancelBooking
-from otf_api.models.responses.classes import ClassType, DoW, OtfClassList
-from otf_api.models.responses.favorite_studios import FavoriteStudioList
-from otf_api.models.responses.lifetime_stats import StatsResponse, StatsTime
-from otf_api.models.responses.performance_summary_detail import PerformanceSummaryDetail
-from otf_api.models.responses.performance_summary_list import PerformanceSummaryList
-from otf_api.models.responses.studio_detail import Pagination, StudioDetail, StudioDetailList
-from otf_api.models.responses.telemetry import Telemetry
-from otf_api.models.responses.telemetry_hr_history import TelemetryHrHistory
-from otf_api.models.responses.telemetry_max_hr import TelemetryMaxHr
-
-from .models import (
+from otf_api.auth import OtfUser
+from otf_api.models import (
+    BodyCompositionList,
+    BookClass,
     BookingList,
     BookingStatus,
+    CancelBooking,
     ChallengeTrackerContent,
     ChallengeTrackerDetailList,
     ChallengeType,
+    ClassType,
+    DoW,
     EquipmentType,
+    FavoriteStudioList,
     LatestAgreement,
     MemberDetail,
     MemberMembership,
     MemberPurchaseList,
+    OtfClassList,
     OutOfStudioWorkoutHistoryList,
+    Pagination,
+    PerformanceSummaryDetail,
+    PerformanceSummaryList,
+    StatsResponse,
+    StatsTime,
+    StudioDetail,
+    StudioDetailList,
     StudioServiceList,
+    Telemetry,
+    TelemetryHrHistory,
+    TelemetryMaxHr,
     TotalClasses,
-    WorkoutList,
 )
 
 
@@ -56,40 +59,55 @@ API_TELEMETRY_BASE_URL = "api.yuzu.orangetheory.com"
 REQUEST_HEADERS = {"Authorization": None, "Content-Type": "application/json", "Accept": "application/json"}
 
 
-class Api:
-    """The main class of the otf-api library. Create an instance using the async method `create`.
+class Otf:
+    logger: "Logger" = logger
+    user: OtfUser
+    _session: aiohttp.ClientSession
 
-    Example:
+    def __init__(
+        self,
+        username: str | None = None,
+        password: str | None = None,
+        access_token: str | None = None,
+        id_token: str | None = None,
+        refresh_token: str | None = None,
+        device_key: str | None = None,
+        user: OtfUser | None = None,
+    ):
+        """Create a new Otf instance.
+
+        Authentication methods:
         ---
-        ```python
-        import asyncio
-        from otf_api import Api
-
-        async def main():
-            otf = await Api.create("username", "password")
-            print(otf.member)
+        - Provide a username and password.
+        - Provide an access token and id token.
+        - Provide a user object.
 
-        if __name__ == "__main__":
-            asyncio.run(main())
-        ```
-    """
-
-    logger: "Logger" = logger
-    user: User
-    session: aiohttp.ClientSession
+        Args:
+            username (str, optional): The username of the user. Default is None.
+            password (str, optional): The password of the user. Default is None.
+            access_token (str, optional): The access token. Default is None.
+            id_token (str, optional): The id token. Default is None.
+            refresh_token (str, optional): The refresh token. Default is None.
+            device_key (str, optional): The device key. Default is None.
+            user (OtfUser, optional): A user object. Default is None.
+        """
 
-    def __init__(self, username: str, password: str):
         self.member: MemberDetail
-        self.home_studio: StudioDetail
-
-        self.user = User.login(username, password)
-
-        headers = {
-            "Authorization": f"Bearer {self.user.cognito.id_token}",
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-        }
-        self.session = aiohttp.ClientSession(headers=headers)
+        self.home_studio_uuid: str
+
+        if user:
+            self.user = user
+        elif username and password or (access_token and id_token):
+            self.user = OtfUser(
+                username=username,
+                password=password,
+                access_token=access_token,
+                id_token=id_token,
+                refresh_token=refresh_token,
+                device_key=device_key,
+            )
+        else:
+            raise ValueError("No valid authentication method provided")
 
         # simplify access to member_id and member_uuid
         self._member_id = self.user.member_id
@@ -98,26 +116,48 @@ class Api:
             "koji-member-id": self._member_id,
             "koji-member-email": self.user.id_claims_data.email,
         }
+        self.member = self._get_member_details_sync()
+        self.home_studio_uuid = self.member.home_studio.studio_uuid
 
-    @classmethod
-    async def create(cls, username: str, password: str) -> "Api":
-        """Create a new API instance. The username and password are required arguments because even though
-        we cache the token, they expire so quickly that we usually end up needing to re-authenticate.
+    def _get_member_details_sync(self) -> MemberDetail:
+        """Get the member details synchronously.
 
-        Args:
-            username (str): The username of the user.
-            password (str): The password of the user.
+        This is used to get the member details when the API is first initialized, to let use initialize
+        without needing to await the member details.
+
+        Returns:
+            MemberDetail: The member details.
         """
-        self = cls(username, password)
-        self.member = await self.get_member_detail()
-        self.home_studio = await self.get_studio_detail(self.member.home_studio.studio_uuid)
-        return self
+        url = f"https://{API_BASE_URL}/member/members/{self._member_id}"
+        resp = requests.get(url, headers=self.headers)
+        return MemberDetail(**resp.json()["data"])
+
+    @property
+    def headers(self) -> dict[str, str]:
+        """Get the headers for the API request."""
+
+        # check the token before making a request in case it has expired
+
+        self.user.cognito.check_token()
+        return {
+            "Authorization": f"Bearer {self.user.cognito.id_token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+    @property
+    def session(self) -> aiohttp.ClientSession:
+        """Get the aiohttp session."""
+        if not getattr(self, "_session", None):
+            self._session = aiohttp.ClientSession(headers=self.headers)
+
+        return self._session
 
     def __del__(self) -> None:
         if not hasattr(self, "session"):
             return
+
         try:
-            loop = asyncio.get_event_loop()
             asyncio.create_task(self._close_session())  # noqa
         except RuntimeError:
             loop = asyncio.new_event_loop()
@@ -145,6 +185,12 @@ class Api:
 
         logger.debug(f"Making {method!r} request to {full_url}, params: {params}")
 
+        # ensure we have headers that contain the most up-to-date token
+        if not headers:
+            headers = self.headers
+        else:
+            headers.update(self.headers)
+
         text = None
         async with self.session.request(method, full_url, headers=headers, params=params, **kwargs) as response:
             with contextlib.suppress(Exception):
@@ -155,10 +201,8 @@ class Api:
             except aiohttp.ClientResponseError as e:
                 logger.exception(f"Error making request: {e}")
                 logger.exception(f"Response: {text}")
-                # raise
             except Exception as e:
                 logger.exception(f"Error making request: {e}")
-                # raise
 
             return await response.json()
 
@@ -180,32 +224,15 @@ class Api:
         """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,
@@ -231,7 +258,7 @@ class Api:
             start_date (str | None): The start date to get classes for, in the format "YYYY-MM-DD". Default is None.
             end_date (str | None): The end date to get classes for, in the format "YYYY-MM-DD". Default is None.
             limit (int | None): Limit the number of classes returned. Default is None.
-            class_type (ClassType | list[ClassType] | None): The class type to filter by. Default is None. Multiple
+            class_type (ClassType | list[ClassType] | None): The class type to filter by. Default is None. Multiple\
             class types can be provided, if there are multiple there will be a call per class type.
             exclude_cancelled (bool): Whether to exclude cancelled classes. Default is False.
             day_of_week (list[DoW] | None): The days of the week to filter by. Default is None.
@@ -242,9 +269,9 @@ class Api:
         """
 
         if not studio_uuids:
-            studio_uuids = [self.home_studio.studio_uuid]
-        elif include_home_studio and self.home_studio.studio_uuid not in studio_uuids:
-            studio_uuids.append(self.home_studio.studio_uuid)
+            studio_uuids = [self.home_studio_uuid]
+        elif include_home_studio and self.home_studio_uuid not in studio_uuids:
+            studio_uuids.append(self.home_studio_uuid)
 
         path = "/v1/classes"
 
@@ -280,7 +307,7 @@ class Api:
             classes_list.classes = [c for c in classes_list.classes if not c.canceled]
 
         for otf_class in classes_list.classes:
-            otf_class.is_home_studio = otf_class.studio.id == self.home_studio.studio_uuid
+            otf_class.is_home_studio = otf_class.studio.id == self.home_studio_uuid
 
         if day_of_week:
             classes_list.classes = [c for c in classes_list.classes if c.day_of_week_enum in day_of_week]
@@ -300,6 +327,16 @@ class Api:
 
         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.
 
@@ -415,7 +452,7 @@ class Api:
         for booking in data.bookings:
             if not booking.otf_class:
                 continue
-            if booking.otf_class.studio.studio_uuid == self.home_studio.studio_uuid:
+            if booking.otf_class.studio.studio_uuid == self.home_studio_uuid:
                 booking.is_home_studio = True
             else:
                 booking.is_home_studio = False
@@ -660,7 +697,7 @@ class Api:
         Returns:
             StudioServiceList: The services available at the studio.
         """
-        studio_uuid = studio_uuid or self.home_studio.studio_uuid
+        studio_uuid = studio_uuid or self.home_studio_uuid
         data = await self._default_request("GET", f"/member/studios/{studio_uuid}/services")
         return StudioServiceList(data=data["data"])
 
@@ -711,7 +748,7 @@ class Api:
         Returns:
             StudioDetail: Detailed information about the studio.
         """
-        studio_uuid = studio_uuid or self.home_studio.studio_uuid
+        studio_uuid = studio_uuid or self.home_studio_uuid
 
         path = f"/mobile/v1/studios/{studio_uuid}"
         params = {"include": "locations"}
@@ -747,8 +784,11 @@ class Api:
         """
         path = "/mobile/v1/studios"
 
-        latitude = latitude or self.home_studio.studio_location.latitude
-        longitude = longitude or self.home_studio.studio_location.longitude
+        if not latitude and not longitude:
+            home_studio = await self.get_studio_detail()
+
+            latitude = home_studio.studio_location.latitude
+            longitude = home_studio.studio_location.longitude
 
         if page_size > 50:
             self.logger.warning("The API does not support more than 50 results per page, limiting to 50.")
@@ -811,16 +851,15 @@ class Api:
         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.
@@ -828,30 +867,10 @@ class Api:
         """
         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:
@@ -885,17 +904,3 @@ class Api:
 
         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