otf-api 0.9.4__py3-none-any.whl → 0.10.1__py3-none-any.whl

otf_api/api.py

@@ -1,6 +1,8 @@
 import atexit
 import contextlib
 import functools
+from concurrent.futures import ThreadPoolExecutor
+from copy import deepcopy
 from datetime import date, datetime, timedelta
 from json import JSONDecodeError
 from logging import getLogger
@@ -8,11 +10,14 @@ from typing import Any, Literal
 
 import attrs
 import httpx
+from cachetools import TTLCache, cached
+from tenacity import retry, retry_if_exception_type, stop_after_attempt, wait_exponential
 from yarl import URL
 
 from otf_api import exceptions as exc
 from otf_api import filters, models
 from otf_api.auth import OtfUser
+from otf_api.models.enums import HISTORICAL_BOOKING_STATUSES
 from otf_api.utils import ensure_date, ensure_list, get_booking_uuid, get_class_uuid
 
 API_BASE_URL = "api.orangetheory.co"
@@ -58,6 +63,11 @@ class Otf:
         # Combine immutable attributes into a single hash value
         return hash(self.member_uuid)
 
+    @retry(
+        retry=retry_if_exception_type(exc.OtfRequestError),
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=4, max=10),
+    )
     def _do(
         self,
         method: str,
@@ -87,13 +97,20 @@ class Otf:
             LOGGER.exception(f"Response: {response.text}")
             raise
         except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                raise exc.ResourceNotFoundError("Resource not found")
+
+            if e.response.status_code == 403:
+                raise
+
             raise exc.OtfRequestError("Error making request", e, response=response, request=request)
         except Exception as e:
             LOGGER.exception(f"Error making request: {e}")
             raise
 
         if not response.text:
-            return None
+            # insanely enough, at least one endpoint (get perf summary) returns None without error instead of 404
+            raise exc.OtfRequestError("Empty response", None, response=response, request=request)
 
         try:
             resp = response.json()
@@ -129,6 +146,204 @@ class Otf:
         perf_api_headers = {"koji-member-id": self.member_uuid, "koji-member-email": self.user.email_address}
         return self._do(method, API_IO_BASE_URL, url, params, perf_api_headers)
 
+    def _get_classes_raw(self, studio_uuids: list[str] | None) -> dict:
+        """Retrieve raw class data."""
+        return self._classes_request("GET", "/v1/classes", params={"studio_ids": studio_uuids})
+
+    def _get_booking_raw(self, booking_uuid: str) -> dict:
+        """Retrieve raw booking data."""
+        return self._default_request("GET", f"/member/members/{self.member_uuid}/bookings/{booking_uuid}")
+
+    def _get_bookings_raw(self, start_date: str | None, end_date: str | None, status: str | list[str] | None) -> dict:
+        """Retrieve raw bookings data."""
+
+        if isinstance(status, list):
+            status = ",".join(status)
+
+        return self._default_request(
+            "GET",
+            f"/member/members/{self.member_uuid}/bookings",
+            params={"startDate": start_date, "endDate": end_date, "statuses": status},
+        )
+
+    def _get_member_detail_raw(self) -> dict:
+        """Retrieve raw member details."""
+        return self._default_request(
+            "GET", f"/member/members/{self.member_uuid}", params={"include": "memberAddresses,memberClassSummary"}
+        )
+
+    def _get_member_membership_raw(self) -> dict:
+        """Retrieve raw member membership details."""
+        return self._default_request("GET", f"/member/members/{self.member_uuid}/memberships")
+
+    def _get_performance_summaries_raw(self, limit: int | None = None) -> dict:
+        """Retrieve raw performance summaries data."""
+        params = {"limit": limit} if limit else {}
+        return self._performance_summary_request("GET", "/v1/performance-summaries", params=params)
+
+    def _get_performance_summary_raw(self, performance_summary_id: str) -> dict:
+        """Retrieve raw performance summary data."""
+        return self._performance_summary_request("GET", f"/v1/performance-summaries/{performance_summary_id}")
+
+    def _get_hr_history_raw(self) -> dict:
+        """Retrieve raw heart rate history."""
+        return self._telemetry_request("GET", "/v1/physVars/maxHr/history", params={"memberUuid": self.member_uuid})
+
+    def _get_telemetry_raw(self, performance_summary_id: str, max_data_points: int) -> dict:
+        """Retrieve raw telemetry data."""
+        return self._telemetry_request(
+            "GET",
+            "/v1/performance/summary",
+            params={"classHistoryUuid": performance_summary_id, "maxDataPoints": max_data_points},
+        )
+
+    def _get_studio_detail_raw(self, studio_uuid: str) -> dict:
+        """Retrieve raw studio details."""
+        return self._default_request("GET", f"/mobile/v1/studios/{studio_uuid}")
+
+    def _get_studios_by_geo_raw(
+        self, latitude: float | None, longitude: float | None, distance: int, page_index: int, page_size: int
+    ) -> dict:
+        """Retrieve raw studios by geo data."""
+        return self._default_request(
+            "GET",
+            "/mobile/v1/studios",
+            params={
+                "latitude": latitude,
+                "longitude": longitude,
+                "distance": distance,
+                "pageIndex": page_index,
+                "pageSize": page_size,
+            },
+        )
+
+    def _get_body_composition_list_raw(self) -> dict:
+        """Retrieve raw body composition list."""
+        return self._default_request("GET", f"/member/members/{self.user.cognito_id}/body-composition")
+
+    def _get_challenge_tracker_raw(self) -> dict:
+        """Retrieve raw challenge tracker data."""
+        return self._default_request("GET", f"/challenges/v3.1/member/{self.member_uuid}")
+
+    def _get_benchmarks_raw(self, challenge_category_id: int, equipment_id: int, challenge_subcategory_id: int) -> dict:
+        """Retrieve raw fitness benchmark data."""
+        return self._default_request(
+            "GET",
+            f"/challenges/v3/member/{self.member_uuid}/benchmarks",
+            params={
+                "equipmentId": equipment_id,
+                "challengeTypeId": challenge_category_id,
+                "challengeSubTypeId": challenge_subcategory_id,
+            },
+        )
+
+    def _get_sms_notification_settings_raw(self) -> dict:
+        """Retrieve raw SMS notification settings."""
+        return self._default_request("GET", url="/sms/v1/preferences", params={"phoneNumber": self.member.phone_number})
+
+    def _get_email_notification_settings_raw(self) -> dict:
+        """Retrieve raw email notification settings."""
+        return self._default_request("GET", url="/otfmailing/v2/preferences", params={"email": self.member.email})
+
+    def _get_member_lifetime_stats_raw(self, select_time: str) -> dict:
+        """Retrieve raw lifetime stats data."""
+        return self._default_request("GET", f"/performance/v2/{self.member_uuid}/over-time/{select_time}")
+
+    def _get_member_services_raw(self, active_only: bool) -> dict:
+        """Retrieve raw member services data."""
+        return self._default_request(
+            "GET", f"/member/members/{self.member_uuid}/services", params={"activeOnly": str(active_only).lower()}
+        )
+
+    def _get_aspire_data_raw(self, datetime: str | None, unit: str | None) -> dict:
+        """Retrieve raw aspire wearable data."""
+        return self._default_request(
+            "GET", f"/member/wearables/{self.member_uuid}/wearable-daily", params={"datetime": datetime, "unit": unit}
+        )
+
+    def _get_member_purchases_raw(self) -> dict:
+        """Retrieve raw member purchases data."""
+        return self._default_request("GET", f"/member/members/{self.member_uuid}/purchases")
+
+    def _get_favorite_studios_raw(self) -> dict:
+        """Retrieve raw favorite studios data."""
+        return self._default_request("GET", f"/member/members/{self.member_uuid}/favorite-studios")
+
+    def _get_studio_services_raw(self, studio_uuid: str) -> dict:
+        """Retrieve raw studio services data."""
+        return self._default_request("GET", f"/member/studios/{studio_uuid}/services")
+
+    def _get_out_of_studio_workout_history_raw(self) -> dict:
+        """Retrieve raw out-of-studio workout history data."""
+        return self._default_request("GET", f"/member/members/{self.member_uuid}/out-of-studio-workout")
+
+    def _add_favorite_studio_raw(self, studio_uuids: list[str]) -> dict:
+        """Retrieve raw response from adding a studio to favorite studios."""
+        return self._default_request("POST", "/mobile/v1/members/favorite-studios", json={"studioUUIds": studio_uuids})
+
+    def _remove_favorite_studio_raw(self, studio_uuids: list[str]) -> dict:
+        """Retrieve raw response from removing a studio from favorite studios."""
+        return self._default_request(
+            "DELETE", "/mobile/v1/members/favorite-studios", json={"studioUUIds": studio_uuids}
+        )
+
+    def _get_challenge_tracker_detail_raw(self, challenge_category_id: int) -> dict:
+        """Retrieve raw challenge tracker detail data."""
+        return self._default_request(
+            "GET",
+            f"/challenges/v1/member/{self.member_uuid}/participation",
+            params={"challengeTypeId": challenge_category_id},
+        )
+
+    def _update_sms_notification_settings_raw(self, promotional_enabled: bool, transactional_enabled: bool) -> dict:
+        """Retrieve raw response from updating SMS notification settings."""
+        return self._default_request(
+            "POST",
+            "/sms/v1/preferences",
+            json={
+                "promosms": promotional_enabled,
+                "source": "OTF",
+                "transactionalsms": transactional_enabled,
+                "phoneNumber": self.member.phone_number,
+            },
+        )
+
+    def _update_email_notification_settings_raw(self, promotional_enabled: bool, transactional_enabled: bool) -> dict:
+        """Retrieve raw response from updating email notification settings."""
+        return self._default_request(
+            "POST",
+            "/otfmailing/v2/preferences",
+            json={
+                "promotionalEmail": promotional_enabled,
+                "source": "OTF",
+                "transactionalEmail": transactional_enabled,
+                "email": self.member.email,
+            },
+        )
+
+    def _rate_class_raw(
+        self, class_uuid: str, performance_summary_id: str, class_rating: int, coach_rating: int
+    ) -> dict:
+        """Retrieve raw response from rating a class and coach."""
+        return self._default_request(
+            "POST",
+            "/mobile/v1/members/classes/ratings",
+            json={
+                "classUUId": class_uuid,
+                "otBeatClassHistoryUUId": performance_summary_id,
+                "classRating": class_rating,
+                "coachRating": coach_rating,
+            },
+        )
+
+    def _update_member_name_raw(self, first_name: str, last_name: str) -> dict:
+        """Retrieve raw response from updating member name."""
+        return self._default_request(
+            "PUT",
+            f"/member/members/{self.member_uuid}",
+            json={"firstName": first_name, "lastName": last_name},
+        )
+
     def get_classes(
         self,
         start_date: date | None = None,
@@ -204,7 +419,7 @@ class Otf:
             else:
                 studio_uuids.append(self.home_studio_uuid)
 
-        classes_resp = self._classes_request("GET", "/v1/classes", params={"studio_ids": studio_uuids})
+        classes_resp = self._get_classes_raw(studio_uuids)
 
         studio_dict = {s: self.get_studio_detail(s) for s in studio_uuids}
         classes: list[models.OtfClass] = []
@@ -289,7 +504,7 @@ class Otf:
         if not booking_uuid:
             raise ValueError("booking_uuid is required")
 
-        data = self._default_request("GET", f"/member/members/{self.member_uuid}/bookings/{booking_uuid}")
+        data = self._get_booking_raw(booking_uuid)
         return models.Booking(**data["data"])
 
     def get_booking_from_class(self, otf_class: str | models.OtfClass) -> models.Booking:
@@ -437,7 +652,7 @@ class Otf:
         self,
         start_date: date | str | None = None,
         end_date: date | str | None = None,
-        status: models.BookingStatus | None = None,
+        status: models.BookingStatus | list[models.BookingStatus] | None = None,
         exclude_cancelled: bool = True,
         exclude_checkedin: bool = True,
     ) -> list[models.Booking]:
@@ -446,8 +661,7 @@ class Otf:
         Args:
             start_date (date | str | None): The start date for the bookings. Default is None.
             end_date (date | str | None): The end date for the bookings. Default is None.
-            status (BookingStatus | None): The status of the bookings to get. Default is None, which includes\
-            all statuses. Only a single status can be provided.
+            status (BookingStatus | list[BookingStatus] | None): The status(es) to filter by. Default is None.
             exclude_cancelled (bool): Whether to exclude cancelled bookings. Default is True.
             exclude_checkedin (bool): Whether to exclude checked-in bookings. Default is True.
 
@@ -467,12 +681,6 @@ class Otf:
             ---
             If dates are provided, the endpoint will return bookings where the class date is within the provided
             date range. If no dates are provided, it will go back 45 days and forward about 30 days.
-
-        Developer Notes:
-            ---
-            Looking at the code in the app, it appears that this endpoint accepts multiple statuses. Indeed,
-            it does not throw an error if you include a list of statuses. However, only the last status in the list is
-            used. I'm not sure if this is a bug or if the API is supposed to work this way.
         """
 
         if exclude_cancelled and status == models.BookingStatus.Cancelled:
@@ -487,11 +695,16 @@ class Otf:
         if isinstance(end_date, date):
             end_date = end_date.isoformat()
 
-        status_value = status.value if status else None
+        if isinstance(status, list):
+            status_value = ",".join(status)
+        elif isinstance(status, models.BookingStatus):
+            status_value = status.value
+        elif isinstance(status, str):
+            status_value = status
+        else:
+            status_value = None
 
-        params = {"startDate": start_date, "endDate": end_date, "statuses": status_value}
-
-        resp = self._default_request("GET", f"/member/members/{self.member_uuid}/bookings", params=params)["data"]
+        resp = self._get_bookings_raw(start_date, end_date, status_value)["data"]
 
         # add studio details for each booking, instead of using the different studio model returned by this endpoint
         studio_uuids = {b["class"]["studio"]["studioUUId"] for b in resp}
@@ -512,55 +725,25 @@ class Otf:
 
         return bookings
 
-    def _get_bookings_old(self, status: models.BookingStatus | None = None) -> list[models.Booking]:
-        """Get the member's bookings.
-
-        Args:
-            status (BookingStatus | None): The status of the bookings to get. Default is None, which includes
-            all statuses. Only a single status can be provided.
+    def get_historical_bookings(self) -> list[models.Booking]:
+        """Get the member's historical bookings. This will go back 45 days and return all bookings
+        for that time period.
 
         Returns:
-            list[Booking]: The member's bookings.
-
-        Raises:
-            ValueError: If an unaccepted status is provided.
-
-        Notes:
-        ---
-            This one is called with the param named 'status'. Dates cannot be provided, because if the endpoint
-            receives a date, it will return as if the param name was 'statuses'.
-
-            Note: This seems to only work for Cancelled, Booked, CheckedIn, and Waitlisted statuses. If you provide
-            a different status, it will return all bookings, not filtered by status. The results in this scenario do
-            not line up with the `get_bookings` with no status provided, as that returns fewer records. Likely the
-            filtered dates are different on the backend.
-
-            My guess: the endpoint called with dates and 'statuses' is a "v2" kind of thing, where they upgraded without
-            changing the version of the api. Calling it with no dates and a singular (limited) status is probably v1.
-
-            I'm leaving this in here for reference, but marking it private. I just don't want to have to puzzle over
-            this again if I remove it and forget about it.
-
+            list[Booking]: The member's historical bookings.
         """
-
-        if status and status not in [
-            models.BookingStatus.Cancelled,
-            models.BookingStatus.Booked,
-            models.BookingStatus.CheckedIn,
-            models.BookingStatus.Waitlisted,
-        ]:
-            raise ValueError(
-                "Invalid status provided. Only Cancelled, Booked, CheckedIn, Waitlisted, and None are supported."
-            )
-
-        status_value = status.value if status else None
-
-        res = self._default_request(
-            "GET", f"/member/members/{self.member_uuid}/bookings", params={"status": status_value}
+        # api goes back 45 days but we'll go back 47 to be safe
+        start_date = datetime.today().date() - timedelta(days=47)
+        end_date = datetime.today().date()
+
+        return self.get_bookings(
+            start_date=start_date,
+            end_date=end_date,
+            status=HISTORICAL_BOOKING_STATUSES,
+            exclude_cancelled=False,
+            exclude_checkedin=False,
         )
 
-        return [models.Booking(**b) for b in res["data"]]
-
     def get_member_detail(self) -> models.MemberDetail:
         """Get the member details.
 
@@ -568,9 +751,7 @@ class Otf:
             MemberDetail: The member details.
         """
 
-        params = {"include": "memberAddresses,memberClassSummary"}
-
-        resp = self._default_request("GET", f"/member/members/{self.member_uuid}", params=params)
+        resp = self._get_member_detail_raw()
         data = resp["data"]
 
         # use standard StudioDetail model instead of the one returned by this endpoint
@@ -586,7 +767,7 @@ class Otf:
             MemberMembership: The member's membership details.
         """
 
-        data = self._default_request("GET", f"/member/members/{self.member_uuid}/memberships")
+        data = self._get_member_membership_raw()
         return models.MemberMembership(**data["data"])
 
     def get_member_purchases(self) -> list[models.MemberPurchase]:
@@ -595,9 +776,7 @@ class Otf:
         Returns:
             list[MemberPurchase]: The member's purchases.
         """
-        data = self._default_request("GET", f"/member/members/{self.member_uuid}/purchases")
-
-        purchases = data["data"]
+        purchases = self._get_member_purchases_raw()["data"]
 
         for p in purchases:
             p["studio"] = self.get_studio_detail(p["studio"]["studioUUId"])
@@ -621,7 +800,7 @@ class Otf:
             Any: The member's lifetime stats.
         """
 
-        data = self._default_request("GET", f"/performance/v2/{self.member_uuid}/over-time/{select_time}")
+        data = self._get_member_lifetime_stats_raw(select_time.value)
 
         stats = models.StatsResponse(**data["data"])
 
@@ -665,7 +844,7 @@ class Otf:
         Returns:
             list[OutOfStudioWorkoutHistory]: The member's out of studio workout history.
         """
-        data = self._default_request("GET", f"/member/members/{self.member_uuid}/out-of-studio-workout")
+        data = self._get_out_of_studio_workout_history_raw()
 
         return [models.OutOfStudioWorkoutHistory(**workout) for workout in data["data"]]
 
@@ -675,7 +854,7 @@ class Otf:
         Returns:
             list[StudioDetail]: The member's favorite studios.
         """
-        data = self._default_request("GET", f"/member/members/{self.member_uuid}/favorite-studios")
+        data = self._get_favorite_studios_raw()
         studio_uuids = [studio["studioUUId"] for studio in data["data"]]
         return [self.get_studio_detail(studio_uuid) for studio_uuid in studio_uuids]
 
@@ -694,8 +873,7 @@ class Otf:
         if not studio_uuids:
             raise ValueError("studio_uuids is required")
 
-        body = {"studioUUIds": studio_uuids}
-        resp = self._default_request("POST", "/mobile/v1/members/favorite-studios", json=body)
+        resp = self._add_favorite_studio_raw(studio_uuids)
 
         new_faves = resp.get("data", {}).get("studios", [])
 
@@ -716,8 +894,9 @@ class Otf:
         if not studio_uuids:
             raise ValueError("studio_uuids is required")
 
-        body = {"studioUUIds": studio_uuids}
-        self._default_request("DELETE", "/mobile/v1/members/favorite-studios", json=body)
+        # keeping the convention of regular/raw methods even though this method doesn't return anything
+        # in case that changes in the future
+        self._remove_favorite_studio_raw(studio_uuids)
 
     def get_studio_services(self, studio_uuid: str | None = None) -> list[models.StudioService]:
         """Get the services available at a specific studio. If no studio UUID is provided, the member's home studio
@@ -730,18 +909,20 @@ class Otf:
             list[StudioService]: The services available at the studio.
         """
         studio_uuid = studio_uuid or self.home_studio_uuid
-        data = self._default_request("GET", f"/member/studios/{studio_uuid}/services")
+        data = self._get_studio_services_raw(studio_uuid)
 
         for d in data["data"]:
             d["studio"] = self.get_studio_detail(studio_uuid)
 
         return [models.StudioService(**d) for d in data["data"]]
 
-    @functools.cache
+    @cached(cache=TTLCache(maxsize=1024, ttl=600))
     def get_studio_detail(self, studio_uuid: str | None = None) -> models.StudioDetail:
         """Get detailed information about a specific studio. If no studio UUID is provided, it will default to the
         user's home studio.
 
+        If the studio is not found, it will return a StudioDetail object with default values.
+
         Args:
             studio_uuid (str, optional): The studio UUID to get detailed information about.
 
@@ -750,9 +931,10 @@ class Otf:
         """
         studio_uuid = studio_uuid or self.home_studio_uuid
 
-        path = f"/mobile/v1/studios/{studio_uuid}"
-
-        res = self._default_request("GET", path)
+        try:
+            res = self._get_studio_detail_raw(studio_uuid)
+        except exc.ResourceNotFoundError:
+            return models.StudioDetail(studioUUId=studio_uuid, studioName="Studio Not Found", studioStatus="Unknown")
 
         return models.StudioDetail(**res["data"])
 
@@ -804,18 +986,25 @@ class Otf:
         Returns:
             list[models.StudioDetail]: List of studios matching the search criteria.
         """
-        path = "/mobile/v1/studios"
-
         distance = min(distance, 250)  # max distance is 250 miles
-
-        params = {"latitude": latitude, "longitude": longitude, "distance": distance, "pageIndex": 1, "pageSize": 100}
-
-        LOGGER.debug("Starting studio search", extra={"params": params})
+        page_size = 100
+        page_index = 1
+        LOGGER.debug(
+            "Starting studio search",
+            extra={
+                "latitude": latitude,
+                "longitude": longitude,
+                "distance": distance,
+                "page_index": page_index,
+                "page_size": page_size,
+            },
+        )
 
         all_results: dict[str, dict[str, Any]] = {}
 
         while True:
-            res = self._default_request("GET", path, params=params)
+            res = self._get_studios_by_geo_raw(latitude, longitude, distance, page_index, page_size)
+
             studios = res["data"].get("studios", [])
             total_count = res["data"].get("pagination", {}).get("totalCount", 0)
 
@@ -823,7 +1012,7 @@ class Otf:
             if len(all_results) >= total_count or not studios:
                 break
 
-            params["pageIndex"] += 1
+            page_index += 1
 
         LOGGER.info("Studio search completed, fetched %d of %d studios", len(all_results), total_count, stacklevel=2)
 
@@ -835,7 +1024,7 @@ class Otf:
         Returns:
             list[BodyCompositionData]: The member's body composition list.
         """
-        data = self._default_request("GET", f"/member/members/{self.user.cognito_id}/body-composition")
+        data = self._get_body_composition_list_raw()
         return [models.BodyCompositionData(**item) for item in data["data"]]
 
     def get_challenge_tracker(self) -> models.ChallengeTracker:
@@ -844,7 +1033,7 @@ class Otf:
         Returns:
             ChallengeTracker: The member's challenge tracker content.
         """
-        data = self._default_request("GET", f"/challenges/v3.1/member/{self.member_uuid}")
+        data = self._get_challenge_tracker_raw()
         return models.ChallengeTracker(**data["Dto"])
 
     def get_benchmarks(
@@ -865,13 +1054,7 @@ class Otf:
         Returns:
             list[FitnessBenchmark]: The member's challenge tracker details.
         """
-        params = {
-            "equipmentId": int(equipment_id),
-            "challengeTypeId": int(challenge_category_id),
-            "challengeSubTypeId": challenge_subcategory_id,
-        }
-
-        data = self._default_request("GET", f"/challenges/v3/member/{self.member_uuid}/benchmarks", params=params)
+        data = self._get_benchmarks_raw(int(challenge_category_id), int(equipment_id), challenge_subcategory_id)
         return [models.FitnessBenchmark(**item) for item in data["Dto"]]
 
     def get_benchmarks_by_equipment(self, equipment_id: models.EquipmentType) -> list[models.FitnessBenchmark]:
@@ -917,11 +1100,7 @@ class Otf:
             FitnessBenchmark: Details about the challenge.
         """
 
-        data = self._default_request(
-            "GET",
-            f"/challenges/v1/member/{self.member_uuid}/participation",
-            params={"challengeTypeId": int(challenge_category_id)},
-        )
+        data = self._get_challenge_tracker_detail_raw(int(challenge_category_id))
 
         if len(data["Dto"]) > 1:
             LOGGER.warning("Multiple challenge participations found, returning the first one.")
@@ -931,15 +1110,52 @@ class Otf:
 
         return models.FitnessBenchmark(**data["Dto"][0])
 
-    def get_performance_summaries(self, limit: int = 5) -> list[models.PerformanceSummaryEntry]:
-        """Get a list of performance summaries for the authenticated user.
+    @cached(cache=TTLCache(maxsize=1024, ttl=600))
+    def get_performance_summaries_dict(self, limit: int | None = None) -> dict[str, models.PerformanceSummary]:
+        """Get a dictionary of performance summaries for the authenticated user.
+
+        Args:
+            limit (int | None): The maximum number of entries to return. Default is None.
+
+        Returns:
+            dict[str, PerformanceSummary]: A dictionary of performance summaries, keyed by class history UUID.
+
+        Developer Notes:
+            ---
+            In the app, this is referred to as 'getInStudioWorkoutHistory'.
+
+        """
+
+        items = self._get_performance_summaries_raw(limit=limit)["items"]
+
+        distinct_studio_ids = set([rec["class"]["studio"]["id"] for rec in items])
+        perf_summary_ids = set([rec["id"] for rec in items])
+
+        with ThreadPoolExecutor() as pool:
+            studio_futures = {s: pool.submit(self.get_studio_detail, s) for s in distinct_studio_ids}
+            perf_summary_futures = {s: pool.submit(self._get_performancy_summary_detail, s) for s in perf_summary_ids}
+
+            studio_dict = {k: v.result() for k, v in studio_futures.items()}
+            # deepcopy these so that mutating them in PerformanceSummary doesn't affect the cache
+            perf_summary_dict = {k: deepcopy(v.result()) for k, v in perf_summary_futures.items()}
+
+        for item in items:
+            item["class"]["studio"] = studio_dict[item["class"]["studio"]["id"]]
+            item["detail"] = perf_summary_dict[item["id"]]
+
+        entries = [models.PerformanceSummary(**item) for item in items]
+        entries_dict = {entry.performance_summary_id: entry for entry in entries}
+
+        return entries_dict
+
+    def get_performance_summaries(self, limit: int | None = None) -> list[models.PerformanceSummary]:
+        """Get a list of all performance summaries for the authenticated user.
 
         Args:
-            limit (int): The maximum number of performance summaries to return. Defaults to 5.
-            only_include_rateable (bool): Whether to only include rateable performance summaries. Defaults to True.
+            limit (int | None): The maximum number of entries to return. Default is None.
 
         Returns:
-            list[PerformanceSummaryEntry]: A list of performance summaries.
+            list[PerformanceSummary]: A list of performance summaries.
 
         Developer Notes:
             ---
@@ -947,28 +1163,55 @@ class Otf:
 
         """
 
-        res = self._performance_summary_request("GET", "/v1/performance-summaries", params={"limit": limit})
-        entries = [models.PerformanceSummaryEntry(**item) for item in res["items"]]
+        records = list(self.get_performance_summaries_dict(limit=limit).values())
 
-        return entries
+        sorted_records = sorted(records, key=lambda x: x.otf_class.starts_at, reverse=True)
 
-    def get_performance_summary(self, performance_summary_id: str) -> models.PerformanceSummaryDetail:
-        """Get a detailed performance summary for a given workout.
+        return sorted_records
+
+    def get_performance_summary(
+        self, performance_summary_id: str, limit: int | None = None
+    ) -> models.PerformanceSummary:
+        """Get performance summary for a given workout.
+
+        Note: Due to the way the OTF API is set up, we have to call both the list and the get endpoints. By
+        default this will call the list endpoint with no limit, in order to ensure that the performance summary
+        is returned if it exists. This could result in a lot of requests, so you also have the option to provide
+        a limit to only fetch a certain number of performance summaries.
 
         Args:
             performance_summary_id (str): The ID of the performance summary to retrieve.
 
         Returns:
-            PerformanceSummaryDetail: A detailed performance summary.
+            PerformanceSummary: The performance summary.
+
+        Raises:
+            ResourceNotFoundError: If the performance_summary_id is not in the list of performance summaries.
         """
 
-        path = f"/v1/performance-summaries/{performance_summary_id}"
-        res = self._performance_summary_request("GET", path)
+        perf_summary = self.get_performance_summaries_dict(limit=limit).get(performance_summary_id)
 
-        if res is None:
+        if perf_summary is None:
             raise exc.ResourceNotFoundError(f"Performance summary {performance_summary_id} not found")
 
-        return models.PerformanceSummaryDetail(**res)
+        return perf_summary
+
+    @functools.lru_cache(maxsize=1024)
+    def _get_performancy_summary_detail(self, performance_summary_id: str) -> dict[str, Any]:
+        """Get the details for a performance summary. Generally should not be called directly. This
+
+        Args:
+            performance_summary_id (str): The performance summary ID.
+
+        Returns:
+            dict[str, Any]: The performance summary details.
+
+        Developer Notes:
+            ---
+            This is mostly here to cache the results of the raw method.
+        """
+
+        return self._get_performance_summary_raw(performance_summary_id)
 
     def get_hr_history(self) -> list[models.TelemetryHistoryItem]:
         """Get the heartrate history for the user.
@@ -980,10 +1223,7 @@ class Otf:
             list[HistoryItem]: The heartrate history for the user.
 
         """
-        path = "/v1/physVars/maxHr/history"
-
-        params = {"memberUuid": self.member_uuid}
-        resp = self._telemetry_request("GET", path, params=params)
+        resp = self._get_hr_history_raw()
         return [models.TelemetryHistoryItem(**item) for item in resp["history"]]
 
     def get_telemetry(self, performance_summary_id: str, max_data_points: int = 120) -> models.Telemetry:
@@ -998,12 +1238,9 @@ class Otf:
 
         Returns:
             TelemetryItem: The telemetry for the class history.
-
         """
-        path = "/v1/performance/summary"
 
-        params = {"classHistoryUuid": performance_summary_id, "maxDataPoints": max_data_points}
-        res = self._telemetry_request("GET", path, params=params)
+        res = self._get_telemetry_raw(performance_summary_id, max_data_points)
         return models.Telemetry(**res)
 
     def get_sms_notification_settings(self) -> models.SmsNotificationSettings:
@@ -1012,7 +1249,7 @@ class Otf:
         Returns:
             SmsNotificationSettings: The member's SMS notification settings.
         """
-        res = self._default_request("GET", url="/sms/v1/preferences", params={"phoneNumber": self.member.phone_number})
+        res = self._get_sms_notification_settings_raw()
 
         return models.SmsNotificationSettings(**res["data"])
 
@@ -1047,7 +1284,6 @@ class Otf:
             }
             ```
         """
-        url = "/sms/v1/preferences"
 
         current_settings = self.get_sms_notification_settings()
 
@@ -1058,14 +1294,7 @@ class Otf:
             transactional_enabled if transactional_enabled is not None else current_settings.is_transactional_sms_opt_in
         )
 
-        body = {
-            "promosms": promotional_enabled,
-            "source": "OTF",
-            "transactionalsms": transactional_enabled,
-            "phoneNumber": self.member.phone_number,
-        }
-
-        self._default_request("POST", url, json=body)
+        self._update_sms_notification_settings_raw(promotional_enabled, transactional_enabled)
 
         # the response returns nothing useful, so we just query the settings again
         new_settings = self.get_sms_notification_settings()
@@ -1077,7 +1306,7 @@ class Otf:
         Returns:
             EmailNotificationSettings: The member's email notification settings.
         """
-        res = self._default_request("GET", url="/otfmailing/v2/preferences", params={"email": self.member.email})
+        res = self._get_email_notification_settings_raw()
 
         return models.EmailNotificationSettings(**res["data"])
 
@@ -1104,14 +1333,7 @@ class Otf:
             else current_settings.is_transactional_email_opt_in
         )
 
-        body = {
-            "promotionalEmail": promotional_enabled,
-            "source": "OTF",
-            "transactionalEmail": transactional_enabled,
-            "email": self.member.email,
-        }
-
-        self._default_request("POST", "/otfmailing/v2/preferences", json=body)
+        self._update_email_notification_settings_raw(promotional_enabled, transactional_enabled)
 
         # the response returns nothing useful, so we just query the settings again
         new_settings = self.get_email_notification_settings()
@@ -1139,20 +1361,17 @@ class Otf:
             LOGGER.warning("No changes to names, nothing to update.")
             return self.member
 
-        path = f"/member/members/{self.member_uuid}"
-        body = {"firstName": first_name, "lastName": last_name}
-
-        res = self._default_request("PUT", path, json=body)
+        res = self._update_member_name_raw(first_name, last_name)
 
         return models.MemberDetail(**res["data"])
 
     def _rate_class(
         self,
         class_uuid: str,
-        class_history_uuid: str,
+        performance_summary_id: str,
         class_rating: Literal[0, 1, 2, 3],
         coach_rating: Literal[0, 1, 2, 3],
-    ) -> models.PerformanceSummaryEntry:
+    ) -> models.PerformanceSummary:
         """Rate a class and coach. A simpler method is provided in `rate_class_from_performance_summary`.
 
 
@@ -1162,12 +1381,12 @@ class Otf:
 
         Args:
             class_uuid (str): The class UUID.
-            class_history_uuid (str): The performance summary ID.
+            performance_summary_id (str): The performance summary ID.
             class_rating (int): The class rating. Must be 0, 1, 2, or 3.
             coach_rating (int): The coach rating. Must be 0, 1, 2, or 3.
 
         Returns:
-            PerformanceSummaryEntry: The updated performance summary entry.
+            PerformanceSummary: The updated performance summary.
         """
 
         # com/orangetheoryfitness/fragment/rating/RateStatus.java
@@ -1188,93 +1407,60 @@ class Otf:
         body_class_rating = CLASS_RATING_MAP[class_rating]
         body_coach_rating = COACH_RATING_MAP[coach_rating]
 
-        body = {
-            "classUUId": class_uuid,
-            "otBeatClassHistoryUUId": class_history_uuid,
-            "classRating": body_class_rating,
-            "coachRating": body_coach_rating,
-        }
-
         try:
-            self._default_request("POST", "/mobile/v1/members/classes/ratings", json=body)
+            self._rate_class_raw(class_uuid, performance_summary_id, body_class_rating, body_coach_rating)
         except exc.OtfRequestError as e:
             if e.response.status_code == 403:
-                raise exc.AlreadyRatedError(f"Performance summary {class_history_uuid} is already rated.") from None
+                raise exc.AlreadyRatedError(f"Performance summary {performance_summary_id} is already rated.") from None
             raise
 
-        return self._get_performance_summary_entry_from_id(class_history_uuid)
-
-    def _get_performance_summary_entry_from_id(self, class_history_uuid: str) -> models.PerformanceSummaryEntry:
-        """Get a performance summary entry from the ID.
-
-        This is a helper function to compensate for the fact that a PerformanceSummaryDetail object does not contain
-        the class UUID, which is required to rate the class. It will also be used to return an updated performance
-        summary entry after rating a class.
-
-        Args:
-            class_history_uuid (str): The performance summary ID.
-
-        Returns:
-            PerformanceSummaryEntry: The performance summary entry.
-
-        Raises:
-            ResourceNotFoundError: If the performance summary is not found.
-        """
-
-        # try going in as small of increments as possible, assuming that the rating request
-        # will be for a recent class
-        for limit in [5, 20, 60, 100]:
-            summaries = self.get_performance_summaries(limit)
-            summary = next((s for s in summaries if s.class_history_uuid == class_history_uuid), None)
+        # we have to clear the cache after rating a class, otherwise we will get back the same data
+        # showing it not rated. that would be incorrect, confusing, and would cause errors if the user
+        # then attempted to rate the class again.
+        # we could attempt to only refresh the one record but with these endpoints that's not simple
+        # NOTE: the individual perf summary endpoint does not have rating data, so it's cache is not cleared
+        self.get_performance_summaries_dict.cache_clear()
 
-            if summary:
-                return summary
-
-        raise exc.ResourceNotFoundError(f"Performance summary {class_history_uuid} not found.")
+        return self.get_performance_summary(performance_summary_id)
 
     def rate_class_from_performance_summary(
         self,
-        perf_summary: models.PerformanceSummaryEntry | models.PerformanceSummaryDetail,
+        perf_summary: models.PerformanceSummary,
         class_rating: Literal[0, 1, 2, 3],
         coach_rating: Literal[0, 1, 2, 3],
-    ) -> models.PerformanceSummaryEntry:
+    ) -> models.PerformanceSummary:
         """Rate a class and coach. The class rating must be 0, 1, 2, or 3. 0 is the same as dismissing the prompt to
             rate the class/coach. 1 - 3 is a range from bad to good.
 
         Args:
-            perf_summary (PerformanceSummaryEntry): The performance summary entry to rate.
+            perf_summary (PerformanceSummary): The performance summary to rate.
             class_rating (int): The class rating. Must be 0, 1, 2, or 3.
             coach_rating (int): The coach rating. Must be 0, 1, 2, or 3.
 
         Returns:
-            PerformanceSummaryEntry: The updated performance summary entry.
+            PerformanceSummary: The updated performance summary.
 
         Raises:
-            ValueError: If `perf_summary` is not a PerformanceSummaryEntry.
             AlreadyRatedError: If the performance summary is already rated.
             ClassNotRatableError: If the performance summary is not rateable.
             ValueError: If the performance summary does not have an associated class.
         """
 
-        if isinstance(perf_summary, models.PerformanceSummaryDetail):
-            perf_summary = self._get_performance_summary_entry_from_id(perf_summary.class_history_uuid)
-
-        if not isinstance(perf_summary, models.PerformanceSummaryEntry):
-            raise ValueError(f"`perf_summary` must be a PerformanceSummaryEntry, got {type(perf_summary)}")
-
         if perf_summary.is_rated:
-            raise exc.AlreadyRatedError(f"Performance summary {perf_summary.class_history_uuid} is already rated.")
+            raise exc.AlreadyRatedError(f"Performance summary {perf_summary.performance_summary_id} is already rated.")
 
         if not perf_summary.ratable:
-            raise exc.ClassNotRatableError(f"Performance summary {perf_summary.class_history_uuid} is not rateable.")
+            raise exc.ClassNotRatableError(
+                f"Performance summary {perf_summary.performance_summary_id} is not rateable."
+            )
 
         if not perf_summary.otf_class or not perf_summary.otf_class.class_uuid:
             raise ValueError(
-                f"Performance summary {perf_summary.class_history_uuid} does not have an associated class."
+                f"Performance summary {perf_summary.performance_summary_id} does not have an associated class."
             )
 
         return self._rate_class(
-            perf_summary.otf_class.class_uuid, perf_summary.class_history_uuid, class_rating, coach_rating
+            perf_summary.otf_class.class_uuid, perf_summary.performance_summary_id, class_rating, coach_rating
         )
 
     # the below do not return any data for me, so I can't test them
@@ -1288,10 +1474,7 @@ class Otf:
         Returns:
             Any: The member's services.
         """
-        active_only_str = "true" if active_only else "false"
-        data = self._default_request(
-            "GET", f"/member/members/{self.member_uuid}/services", params={"activeOnly": active_only_str}
-        )
+        data = self._get_member_services_raw(active_only)
         return data
 
     def _get_aspire_data(self, datetime: str | None = None, unit: str | None = None) -> Any:
@@ -1306,7 +1489,5 @@ class Otf:
         Returns:
             Any: The member's aspire data.
         """
-        params = {"datetime": datetime, "unit": unit}
-
-        data = self._default_request("GET", f"/member/wearables/{self.member_uuid}/wearable-daily", params=params)
+        data = self._get_aspire_data_raw(datetime, unit)
         return data