otf-api 0.10.2__py3-none-any.whl → 0.11.1__py3-none-any.whl

otf_api/auth/__init__.py

@@ -1,4 +1,4 @@
+from .auth import HttpxCognitoAuth
 from .user import OtfUser
-from .utils import HttpxCognitoAuth
 
 __all__ = ["OTF_AUTH_TYPE", "HttpxCognitoAuth", "OtfAuth", "OtfUser"]

otf_api/auth/auth.py

@@ -1,13 +1,19 @@
+# pyright: reportTypedDictNotRequiredAccess=none
 import platform
 import typing
+from collections.abc import Generator
 from logging import getLogger
 from pathlib import Path
 from time import sleep
 from typing import Any, ClassVar
 
+import httpx
 from boto3 import Session
 from botocore import UNSIGNED
+from botocore.auth import SigV4Auth
+from botocore.awsrequest import AWSRequest
 from botocore.config import Config
+from botocore.credentials import Credentials
 from botocore.exceptions import ClientError
 from pycognito import AWSSRP, Cognito
 from pycognito.aws_srp import generate_hash_device
@@ -15,6 +21,7 @@ from pycognito.aws_srp import generate_hash_device
 from otf_api.utils import CacheableData
 
 if typing.TYPE_CHECKING:
+    from mypy_boto3_cognito_identity import CognitoIdentityClient
     from mypy_boto3_cognito_idp import CognitoIdentityProviderClient
     from mypy_boto3_cognito_idp.type_defs import InitiateAuthResponseTypeDef
 
@@ -22,7 +29,9 @@ LOGGER = getLogger(__name__)
 CLIENT_ID = "1457d19r0pcjgmp5agooi0rb1b"  # from android app
 USER_POOL_ID = "us-east-1_dYDxUeyL1"
 REGION = "us-east-1"
-COGNITO_IDP_URL = f"https://cognito-idp.{REGION}.amazonaws.com/"
+
+ID_POOL_ID = "us-east-1:4943c880-fb02-4fd7-bc37-2f4c32ecb2a3"
+PROVIDER_KEY = f"cognito-idp.{REGION}.amazonaws.com/{USER_POOL_ID}"
 
 BOTO_CONFIG = Config(region_name=REGION, signature_version=UNSIGNED)
 CRED_CACHE = CacheableData("creds", Path("~/.otf-api"))
@@ -82,6 +91,11 @@ class OtfCognito(Cognito):
         self.mfa_tokens: dict[str, Any] = {}
         self.pool_domain_url: str | None = None
 
+        self.handle_login(username, password, id_token, access_token)
+
+    def handle_login(
+        self, username: str | None, password: str | None, id_token: str | None = None, access_token: str | None = None
+    ) -> None:
         try:
             dd = CRED_CACHE.get_cached_data(DEVICE_KEYS)
         except Exception:
@@ -93,9 +107,13 @@ class OtfCognito(Cognito):
         self.device_group_key = dd.get("device_group_key")  # type: ignore
         self.device_password = dd.get("device_password")  # type: ignore
 
-        self.client: CognitoIdentityProviderClient = Session().client(
+        self.idp_client: CognitoIdentityProviderClient = Session().client(
             "cognito-idp", config=BOTO_CONFIG, region_name=REGION
-        )
+        )  # type: ignore
+
+        self.id_client: CognitoIdentityClient = Session().client(
+            "cognito-identity", config=BOTO_CONFIG, region_name=REGION
+        )  # type: ignore
 
         try:
             token_cache = CRED_CACHE.get_cached_data(TOKEN_KEYS)
@@ -114,10 +132,28 @@ class OtfCognito(Cognito):
             self.access_token = token_cache["access_token"]
             self.refresh_token = token_cache["refresh_token"]
 
-        self.check_token()
+        try:
+            self.check_token()
+        except ClientError as e:
+            if e.response["Error"]["Code"] == "NotAuthorizedException":
+                LOGGER.warning("Tokens expired, attempting to login with username and password")
+                CRED_CACHE.clear_cache()
+                if not username or not password:
+                    raise NoCredentialsError("No credentials provided and no tokens cached, cannot authenticate")
+                self.handle_login(username, password)
+
         self.verify_tokens()
         CRED_CACHE.write_to_cache(self.tokens)
 
+    def get_identity_credentials(self):
+        """Get the AWS credentials for the user using the Cognito Identity Pool.
+        This is used to access AWS resources using the Cognito Identity Pool."""
+        cognito_id = self.id_client.get_id(IdentityPoolId=ID_POOL_ID, Logins={PROVIDER_KEY: self.id_token})
+        creds = self.id_client.get_credentials_for_identity(
+            IdentityId=cognito_id["IdentityId"], Logins={PROVIDER_KEY: self.id_token}
+        )
+        return creds["Credentials"]
+
     @property
     def tokens(self) -> dict[str, str]:
         tokens = {
@@ -146,7 +182,7 @@ class OtfCognito(Cognito):
             password=password,
             pool_id=USER_POOL_ID,
             client_id=CLIENT_ID,
-            client=self.client,
+            client=self.idp_client,
         )
         try:
             tokens: InitiateAuthResponseTypeDef = aws.authenticate_user()
@@ -177,10 +213,10 @@ class OtfCognito(Cognito):
             self.device_group_key, self.device_key
         )
 
-        self.client.confirm_device(
+        self.idp_client.confirm_device(
             AccessToken=self.access_token,
             DeviceKey=self.device_key,
-            DeviceSecretVerifierConfig=device_secret_verifier_config,
+            DeviceSecretVerifierConfig=device_secret_verifier_config,  # type: ignore (pycognito is untyped)
             DeviceName=self.device_name,
         )
 
@@ -206,7 +242,7 @@ class OtfCognito(Cognito):
         if not self.refresh_token:
             raise ValueError("No refresh token set - cannot renew access token")
 
-        refresh_response = self.client.initiate_auth(
+        refresh_response = self.idp_client.initiate_auth(
             ClientId=self.client_id,
             AuthFlow="REFRESH_TOKEN_AUTH",
             AuthParameters={"REFRESH_TOKEN": self.refresh_token, "DEVICE_KEY": self.device_key},
@@ -221,6 +257,9 @@ class OtfCognito(Cognito):
         auth_result = tokens["AuthenticationResult"]
         device_metadata = auth_result.get("NewDeviceMetadata", {})
 
+        assert "AccessToken" in auth_result, "AccessToken not found in AuthenticationResult"
+        assert "IdToken" in auth_result, "IdToken not found in AuthenticationResult"
+
         # tokens - refresh token defaults to existing value if not present
         # note: verify_token also sets the token attribute
         self.verify_token(auth_result["AccessToken"], "access_token", "access")
@@ -232,3 +271,71 @@ class OtfCognito(Cognito):
         self.device_key = device_metadata.get("DeviceKey", self.device_key)
         self.device_group_key = device_metadata.get("DeviceGroupKey", self.device_group_key)
         CRED_CACHE.write_to_cache(self.device_metadata)
+
+
+class HttpxCognitoAuth(httpx.Auth):
+    http_header: str = "Authorization"
+    http_header_prefix: str = "Bearer "
+
+    def __init__(self, cognito: OtfCognito):
+        """HTTPX Authentication extension for Cognito User Pools.
+
+        Args:
+            cognito (Cognito): A Cognito instance.
+        """
+
+        self.cognito = cognito
+
+    def auth_flow(self, request: httpx.Request) -> Generator[httpx.Request, Any, None]:
+        self.cognito.check_token(renew=True)
+
+        token = self.cognito.id_token
+
+        assert isinstance(token, str), "Token is not a string"
+
+        request.headers[self.http_header] = self.http_header_prefix + token
+
+        # If the request has the SIGV4AUTH_REQUIRED header, sign the request
+        # used by very few endpoints, but I expect that may change in the future
+        if request.headers.get("SIGV4AUTH_REQUIRED"):
+            del request.headers["SIGV4AUTH_REQUIRED"]
+            yield from self.sign_httpx_request(request)
+            return
+
+        yield request
+
+    def sign_httpx_request(self, request: httpx.Request) -> Generator[httpx.Request, Any, None]:
+        """
+        Sign an HTTP request using AWS SigV4 for use with httpx.
+        """
+        headers = request.headers.copy()
+
+        # ensure this header is not included, it will break the signature
+        headers.pop("connection", None)
+
+        body = b"" if request.method in ("GET", "HEAD") else request.content or b""
+
+        if hasattr(body, "read"):
+            raise ValueError("Streaming bodies are not supported in signed requests")
+
+        creds = self.cognito.get_identity_credentials()
+
+        credentials = Credentials(
+            access_key=creds["AccessKeyId"], secret_key=creds["SecretKey"], token=creds["SessionToken"]
+        )
+
+        aws_request = AWSRequest(method=request.method, url=str(request.url), data=body, headers=headers)
+
+        SigV4Auth(credentials, "execute-api", REGION).add_auth(aws_request)
+
+        signed_headers = dict(aws_request.headers.items())
+
+        # Return a brand new request object with signed headers
+        signed_request = httpx.Request(
+            method=request.method,
+            url=request.url,
+            headers=signed_headers,
+            content=body,
+        )
+
+        yield signed_request

otf_api/auth/user.py

@@ -2,8 +2,8 @@ from logging import getLogger
 
 import attrs
 
-from otf_api.auth.auth import CRED_CACHE, NoCredentialsError, OtfCognito
-from otf_api.auth.utils import HttpxCognitoAuth, can_provide_input, prompt_for_username_and_password
+from otf_api.auth.auth import CRED_CACHE, HttpxCognitoAuth, NoCredentialsError, OtfCognito
+from otf_api.auth.utils import can_provide_input, get_credentials_from_env, prompt_for_username_and_password
 
 LOGGER = getLogger(__name__)
 
@@ -47,12 +47,19 @@ class OtfUser:
                 refresh_token=refresh_token,
             )
         except NoCredentialsError:
-            if not can_provide_input():
-                LOGGER.error("Unable to prompt for credentials in a non-interactive shell")
-                raise
+            username, password = get_credentials_from_env()
+            if not username or not password:
+                if not can_provide_input():
+                    LOGGER.error("Unable to prompt for credentials in a non-interactive shell")
+                    raise
+                username, password = prompt_for_username_and_password()
+                if not username or not password:
+                    raise NoCredentialsError("No credentials provided and no tokens cached, cannot authenticate")
+        except Exception as e:
+            LOGGER.exception("Failed to authenticate with Cognito")
+            raise e
 
-            username, password = prompt_for_username_and_password()
-            self.cognito = OtfCognito(username=username, password=password)
+        self.cognito = OtfCognito(username=username, password=password)
 
         self.cognito_id = self.cognito.access_claims["sub"]
         self.member_uuid = self.cognito.id_claims["cognito:username"]

otf_api/auth/utils.py

@@ -1,14 +1,8 @@
 import os
 import sys
-from collections.abc import Generator
 from functools import partial
 from getpass import getpass
 from logging import getLogger
-from typing import Any
-
-import httpx
-from httpx import Request
-from pycognito import Cognito
 
 LOGGER = getLogger(__name__)
 USERNAME_PROMPT = "Enter your Orangetheory Fitness username/email: "
@@ -17,9 +11,9 @@ PASSWORD_PROMPT = "Enter your Orangetheory Fitness password: "
 
 def _show_error_message(message: str) -> None:
     try:
-        from rich import print  # type: ignore
+        from rich import get_console  # type: ignore
 
-        print(message, style="bold red")
+        get_console().print(message, style="bold red")
     except ImportError:
         print(message)
 
@@ -84,6 +78,23 @@ def _prompt_for_password() -> str:
     return password
 
 
+def get_credentials_from_env() -> tuple[str, str]:
+    """Get credentials from environment variables.
+
+    Returns:
+        tuple[str, str]: A tuple containing the username and password.
+    """
+
+    username = os.getenv("OTF_EMAIL")
+    password = os.getenv("OTF_PASSWORD")
+
+    if not username or not password:
+        _show_error_message("Environment variables OTF_EMAIL and OTF_PASSWORD are required")
+        return "", ""
+
+    return username, password
+
+
 def prompt_for_username_and_password() -> tuple[str, str]:
     """Prompt for a username and password.
 
@@ -91,8 +102,8 @@ def prompt_for_username_and_password() -> tuple[str, str]:
         tuple[str, str]: A tuple containing the username and password.
     """
 
-    username = os.getenv("OTF_EMAIL") or _prompt_for_username()
-    password = os.getenv("OTF_PASSWORD") or _prompt_for_password()
+    username = _prompt_for_username()
+    password = _prompt_for_password()
 
     return username, password
 
@@ -104,26 +115,3 @@ def can_provide_input() -> bool:
         bool: True if the script is running in an interactive shell.
     """
     return os.isatty(sys.stdin.fileno()) and os.isatty(sys.stdout.fileno())
-
-
-class HttpxCognitoAuth(httpx.Auth):
-    http_header: str = "Authorization"
-    http_header_prefix: str = "Bearer "
-
-    def __init__(self, cognito: Cognito):
-        """HTTPX Authentication extension for Cognito User Pools.
-
-        Args:
-            cognito (Cognito): A Cognito instance.
-        """
-
-        self.cognito = cognito
-
-    def auth_flow(self, request: Request) -> Generator[Request, Any, None]:
-        self.cognito.check_token(renew=True)
-
-        token = self.cognito.id_token
-
-        request.headers[self.http_header] = self.http_header_prefix + token
-
-        yield request

otf_api/models/__init__.py

@@ -1,5 +1,6 @@
 from .body_composition_list import BodyCompositionData
 from .bookings import Booking
+from .bookings_v2 import BookingV2, BookingV2Class
 from .challenge_tracker_content import ChallengeTracker
 from .challenge_tracker_detail import FitnessBenchmark
 from .classes import OtfClass
@@ -13,22 +14,26 @@ from .enums import (
     StatsTime,
     StudioStatus,
 )
-from .lifetime_stats import StatsResponse, TimeStats
+from .lifetime_stats import InStudioStatsData, OutStudioStatsData, StatsResponse, TimeStats
 from .member_detail import MemberDetail
 from .member_membership import MemberMembership
 from .member_purchases import MemberPurchase
 from .notifications import EmailNotificationSettings, SmsNotificationSettings
 from .out_of_studio_workout_history import OutOfStudioWorkoutHistory
 from .performance_summary import PerformanceSummary
+from .ratings import get_class_rating_value, get_coach_rating_value
 from .studio_detail import StudioDetail
 from .studio_services import StudioService
 from .telemetry import Telemetry, TelemetryHistoryItem
+from .workout import Workout
 
 __all__ = [
     "HISTORICAL_BOOKING_STATUSES",
     "BodyCompositionData",
     "Booking",
     "BookingStatus",
+    "BookingV2",
+    "BookingV2Class",
     "ChallengeCategory",
     "ChallengeTracker",
     "ClassType",
@@ -36,11 +41,13 @@ __all__ = [
     "EmailNotificationSettings",
     "EquipmentType",
     "FitnessBenchmark",
+    "InStudioStatsData",
     "MemberDetail",
     "MemberMembership",
     "MemberPurchase",
     "OtfClass",
     "OutOfStudioWorkoutHistory",
+    "OutStudioStatsData",
     "PerformanceSummary",
     "SmsNotificationSettings",
     "StatsResponse",
@@ -51,4 +58,7 @@ __all__ = [
     "Telemetry",
     "TelemetryHistoryItem",
     "TimeStats",
+    "Workout",
+    "get_class_rating_value",
+    "get_coach_rating_value",
 ]

otf_api/models/bookings_v2.py

@@ -0,0 +1,171 @@
+from datetime import datetime
+from logging import getLogger
+
+import pendulum
+from pydantic import AliasPath, Field
+
+from otf_api.models.base import OtfItemBase
+from otf_api.models.enums import BookingStatus, ClassType
+from otf_api.models.mixins import AddressMixin, PhoneLongitudeLatitudeMixin
+from otf_api.models.performance_summary import ZoneTimeMinutes
+
+LOGGER = getLogger(__name__)
+
+
+class Address(AddressMixin, OtfItemBase): ...
+
+
+def get_end_time(start_time: datetime, class_type: ClassType) -> datetime:
+    """
+    Get the end time of a class based on the start time and class type.
+    """
+
+    start_time = pendulum.instance(start_time)
+
+    match class_type:
+        case ClassType.ORANGE_60:
+            return start_time.add(minutes=60)
+        case ClassType.ORANGE_90:
+            return start_time.add(minutes=90)
+        case ClassType.STRENGTH_50 | ClassType.TREAD_50:
+            return start_time.add(minutes=50)
+        case ClassType.OTHER:
+            LOGGER.warning(
+                f"Class type {class_type} does not have defined length, returning start time plus 60 minutes"
+            )
+            return start_time.add(minutes=60)
+        case _:
+            LOGGER.warning(f"Class type {class_type} is not recognized, returning start time plus 60 minutes")
+            return start_time.add(minutes=60)
+
+
+class Rating(OtfItemBase):
+    id: str
+    description: str
+    value: int
+
+
+class BookingV2Studio(PhoneLongitudeLatitudeMixin, OtfItemBase):
+    studio_uuid: str = Field(alias="id")
+    name: str | None = None
+    time_zone: str | None = None
+    email: str | None = None
+    address: Address | None = None
+
+    currency_code: str | None = Field(None, repr=False, exclude=True)
+    mbo_studio_id: str | None = Field(None, description="MindBody attr", repr=False, exclude=True)
+
+
+class BookingV2Class(OtfItemBase):
+    class_id: str = Field(alias="id", description="Matches the `class_id` attribute of the OtfClass model")
+    name: str
+    class_type: ClassType = Field(alias="type")
+    starts_at: datetime = Field(
+        alias="starts_at_local",
+        description="The start time of the class. Reflects local time, but the object does not have a timezone.",
+    )
+    studio: BookingV2Studio | None = None
+    coach: str | None = Field(None, validation_alias=AliasPath("coach", "first_name"))
+
+    class_uuid: str | None = Field(
+        None, alias="ot_base_class_uuid", description="Only present when class is ratable", exclude=True, repr=False
+    )
+    starts_at_utc: datetime | None = Field(None, alias="starts_at", exclude=True, repr=False)
+
+    def __str__(self) -> str:
+        starts_at_str = self.starts_at.strftime("%a %b %d, %I:%M %p")
+        return f"Class: {starts_at_str} {self.name} - {self.coach}"
+
+
+class BookingV2Workout(OtfItemBase):
+    id: str
+    performance_summary_id: str = Field(..., alias="id", description="Alias to id, to simplify the API")
+    calories_burned: int
+    splat_points: int
+    step_count: int
+    active_time_seconds: int
+    zone_time_minutes: ZoneTimeMinutes
+
+
+class BookingV2(OtfItemBase):
+    booking_id: str = Field(
+        ..., alias="id", description="The booking ID used to cancel the booking - must be canceled through new endpoint"
+    )
+
+    member_uuid: str = Field(..., alias="member_id")
+    service_name: str | None = Field(None, description="Represents tier of member")
+
+    cross_regional: bool | None = None
+    intro: bool | None = None
+    checked_in: bool
+    canceled: bool
+    late_canceled: bool | None = None
+    canceled_at: datetime | None = None
+    ratable: bool
+
+    otf_class: BookingV2Class = Field(..., alias="class")
+    workout: BookingV2Workout | None = None
+    coach_rating: Rating | None = Field(None, validation_alias=AliasPath("ratings", "coach"))
+    class_rating: Rating | None = Field(None, validation_alias=AliasPath("ratings", "class"))
+
+    paying_studio_id: str | None = None
+    mbo_booking_id: str | None = None
+    mbo_unique_id: str | None = None
+    mbo_paying_unique_id: str | None = None
+    person_id: str
+
+    created_at: datetime | None = Field(
+        None,
+        description="Date the booking was created in the system, not when the booking was made",
+        exclude=True,
+        repr=False,
+    )
+    updated_at: datetime | None = Field(
+        None, description="Date the booking was updated, not when the booking was made", exclude=True, repr=False
+    )
+
+    @property
+    def status(self) -> BookingStatus:
+        """Emulates the booking status from the old API, but with less specificity"""
+        if self.late_canceled:
+            return BookingStatus.LateCancelled
+
+        if self.checked_in:
+            return BookingStatus.CheckedIn
+
+        if self.canceled:
+            return BookingStatus.Cancelled
+
+        return BookingStatus.Booked
+
+    @property
+    def studio_uuid(self) -> str:
+        """Shortcut to get the studio UUID"""
+        if self.otf_class.studio is None:
+            return ""
+        return self.otf_class.studio.studio_uuid
+
+    @property
+    def class_uuid(self) -> str:
+        """Shortcut to get the class UUID"""
+        if self.otf_class.class_uuid is None:
+            return ""
+        return self.otf_class.class_uuid
+
+    @property
+    def starts_at(self) -> datetime:
+        """Shortcut to get the class start time"""
+        return self.otf_class.starts_at
+
+    @property
+    def ends_at(self) -> datetime:
+        """Shortcut to get the class end time"""
+        return get_end_time(self.otf_class.starts_at, self.otf_class.class_type)
+
+    def __str__(self) -> str:
+        starts_at_str = self.otf_class.starts_at.strftime("%a %b %d, %I:%M %p")
+        class_name = self.otf_class.name
+        coach_name = self.otf_class.coach
+        booked_str = self.status.value
+
+        return f"Booking: {starts_at_str} {class_name} - {coach_name} ({booked_str})"

otf_api/models/challenge_tracker_content.py

@@ -11,7 +11,7 @@ endpoint.
 from pydantic import Field
 
 from otf_api.models.base import OtfItemBase
-from otf_api.models.enums import ChallengeCategory, EquipmentType
+from otf_api.models.enums import EquipmentType
 
 
 class Year(OtfItemBase):
@@ -39,7 +39,7 @@ class Challenge(OtfItemBase):
     # all related to the ChallengeType enums or the few SubCategory enums I've
     # been able to puzzle out. I haven't been able to link them to any code
     # in the OTF app. Due to that, they are being excluded from the model for now.
-    challenge_category_id: ChallengeCategory | None = Field(None, alias="ChallengeCategoryId")
+    challenge_category_id: int | None = Field(None, alias="ChallengeCategoryId")
     challenge_sub_category_id: int | None = Field(None, alias="ChallengeSubCategoryId")
     challenge_name: str | None = Field(None, alias="ChallengeName")
     years: list[Year] = Field(default_factory=list, alias="Years")

otf_api/models/challenge_tracker_detail.py

@@ -4,7 +4,7 @@ from typing import Any
 from pydantic import Field
 
 from otf_api.models.base import OtfItemBase
-from otf_api.models.enums import ChallengeCategory, EquipmentType
+from otf_api.models.enums import EquipmentType
 
 
 class MetricEntry(OtfItemBase):
@@ -74,7 +74,7 @@ class Goal(OtfItemBase):
 
 
 class FitnessBenchmark(OtfItemBase):
-    challenge_category_id: ChallengeCategory | None = Field(None, alias="ChallengeCategoryId")
+    challenge_category_id: int | None = Field(None, alias="ChallengeCategoryId")
     challenge_sub_category_id: int | None = Field(None, alias="ChallengeSubCategoryId")
     equipment_id: EquipmentType = Field(None, alias="EquipmentId")
     equipment_name: str | None = Field(None, alias="EquipmentName")

otf_api/models/classes.py

@@ -9,9 +9,11 @@ from otf_api.models.studio_detail import StudioDetail
 
 class OtfClass(OtfItemBase):
     class_uuid: str = Field(alias="ot_base_class_uuid", description="The OTF class UUID")
+    class_id: str | None = Field(None, alias="id", description="Matches new booking endpoint class id")
+
     name: str | None = Field(None, description="The name of the class")
     class_type: ClassType = Field(alias="type")
-    coach: str | None = Field(None, alias=AliasPath("coach", "first_name"))
+    coach: str | None = Field(None, validation_alias=AliasPath("coach", "first_name"))
     ends_at: datetime = Field(
         alias="ends_at_local",
         description="The end time of the class. Reflects local time, but the object does not have a timezone.",
@@ -27,16 +29,11 @@ class OtfClass(OtfItemBase):
     full: bool | None = None
     max_capacity: int | None = None
     waitlist_available: bool | None = None
-    waitlist_size: int | None = None
+    waitlist_size: int | None = Field(None, description="The number of people on the waitlist")
     is_booked: bool | None = Field(None, description="Custom helper field to determine if class is already booked")
     is_cancelled: bool | None = Field(None, alias="canceled")
     is_home_studio: bool | None = Field(None, description="Custom helper field to determine if at home studio")
 
-    # unused fields
-    class_id: str | None = Field(
-        None, alias="id", exclude=True, repr=False, description="Matches new booking endpoint class id"
-    )
-
     created_at: datetime | None = Field(None, exclude=True, repr=False)
     ends_at_utc: datetime | None = Field(None, alias="ends_at", exclude=True, repr=False)
     mbo_class_description_id: str | None = Field(None, exclude=True, repr=False, description="MindBody attr")

otf_api/models/enums.py

@@ -157,6 +157,7 @@ class ChallengeCategory(IntEnum):
     RemixInSix = 65
     Push = 66
     QuarterMileTreadmill = 69
+    OneThousandMeterRow = 70
 
 
 class DriTriChallengeSubCategory(IntEnum):