otf-api 0.12.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

otf_api/models/__init__.py

@@ -1,31 +1,35 @@
-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
-from .enums import (
+from .bookings import (
     HISTORICAL_BOOKING_STATUSES,
+    Booking,
     BookingStatus,
-    ChallengeCategory,
+    BookingV2,
+    BookingV2Class,
     ClassType,
     DoW,
+    OtfClass,
+    get_class_rating_value,
+    get_coach_rating_value,
+)
+from .members import MemberDetail, MemberMembership, MemberPurchase
+from .members.notifications import EmailNotificationSettings, SmsNotificationSettings
+from .studios import StudioDetail, StudioService, StudioStatus
+from .workouts import (
+    BodyCompositionData,
+    ChallengeCategory,
+    ChallengeTracker,
     EquipmentType,
+    FitnessBenchmark,
+    InStudioStatsData,
+    OutOfStudioWorkoutHistory,
+    OutStudioStatsData,
+    PerformanceSummary,
+    StatsResponse,
     StatsTime,
-    StudioStatus,
+    Telemetry,
+    TelemetryHistoryItem,
+    TimeStats,
+    Workout,
 )
-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",

otf_api/models/bookings/__init__.py

@@ -0,0 +1,23 @@
+from .bookings import Booking
+from .bookings_v2 import BookingV2, BookingV2Class, BookingV2Studio, BookingV2Workout, Rating
+from .classes import OtfClass
+from .enums import HISTORICAL_BOOKING_STATUSES, BookingStatus, ClassType, DoW
+from .filters import ClassFilter
+from .ratings import get_class_rating_value, get_coach_rating_value
+
+__all__ = [
+    "HISTORICAL_BOOKING_STATUSES",
+    "Booking",
+    "BookingStatus",
+    "BookingV2",
+    "BookingV2Class",
+    "BookingV2Studio",
+    "BookingV2Workout",
+    "ClassFilter",
+    "ClassType",
+    "DoW",
+    "OtfClass",
+    "Rating",
+    "get_class_rating_value",
+    "get_coach_rating_value",
+]

otf_api/models/bookings/bookings.py

@@ -0,0 +1,134 @@
+from datetime import datetime
+
+from pydantic import Field
+
+from otf_api.models.base import OtfItemBase
+from otf_api.models.mixins import ApiMixin
+from otf_api.models.studios import StudioDetail
+
+from .enums import BookingStatus
+
+
+class Coach(OtfItemBase):
+    coach_uuid: str = Field(validation_alias="coachUUId")
+    first_name: str | None = Field(None, validation_alias="firstName")
+    last_name: str | None = Field(None, validation_alias="lastName")
+
+    # unused fields
+    name: str = Field(exclude=True, repr=False)
+
+    @property
+    def full_name(self) -> str:
+        """Returns the full name of the coach."""
+        return f"{self.first_name} {self.last_name}"
+
+
+class OtfClass(OtfItemBase):
+    class_uuid: str = Field(validation_alias="classUUId")
+    name: str
+    starts_at: datetime = Field(validation_alias="startDateTime", description="Start time in local timezone")
+    ends_at: datetime = Field(validation_alias="endDateTime", description="End time in local timezone")
+    is_available: bool = Field(validation_alias="isAvailable")
+    is_cancelled: bool = Field(validation_alias="isCancelled")
+    studio: StudioDetail
+    coach: Coach
+
+    # unused fields
+    coach_id: int | None = Field(
+        None, validation_alias="coachId", exclude=True, repr=False, description="Not used by API"
+    )
+    description: str | None = Field(None, exclude=True, repr=False)
+    program_name: str | None = Field(None, validation_alias="programName", exclude=True, repr=False)
+    virtual_class: bool | None = Field(None, validation_alias="virtualClass", exclude=True, repr=False)
+
+    @property
+    def coach_name(self) -> str:
+        """Shortcut to get the coach's name, to be compatible with new BookingV2Class."""
+        return self.coach.first_name or ""
+
+    def __str__(self) -> str:
+        """Returns a string representation of the class."""
+        starts_at_str = self.starts_at.strftime("%a %b %d, %I:%M %p")
+        return f"Class: {starts_at_str} {self.name} - {self.coach.first_name}"
+
+
+class Booking(ApiMixin, OtfItemBase):
+    booking_uuid: str = Field(validation_alias="classBookingUUId", description="ID used to cancel the booking")
+    is_intro: bool = Field(validation_alias="isIntro")
+    status: BookingStatus
+    booked_date: datetime | None = Field(None, validation_alias="bookedDate")
+    checked_in_date: datetime | None = Field(None, validation_alias="checkedInDate")
+    cancelled_date: datetime | None = Field(None, validation_alias="cancelledDate")
+    created_date: datetime = Field(validation_alias="createdDate")
+    updated_date: datetime = Field(validation_alias="updatedDate")
+    is_deleted: bool = Field(validation_alias="isDeleted")
+    waitlist_position: int | None = Field(None, validation_alias="waitlistPosition")
+    otf_class: OtfClass = Field(validation_alias="class")
+    is_home_studio: bool | None = Field(None, description="Custom helper field to determine if at home studio")
+
+    # unused fields
+    class_booking_id: int = Field(
+        validation_alias="classBookingId", exclude=True, repr=False, description="Not used by API"
+    )
+    class_id: int = Field(validation_alias="classId", exclude=True, repr=False, description="Not used by API")
+    created_by: str = Field(validation_alias="createdBy", exclude=True, repr=False)
+    mbo_class_id: int | None = Field(
+        None, validation_alias="mboClassId", exclude=True, repr=False, description="MindBody attr"
+    )
+    mbo_member_id: str | None = Field(
+        None, validation_alias="mboMemberId", exclude=True, repr=False, description="MindBody attr"
+    )
+    mbo_sync_message: str | None = Field(
+        None, validation_alias="mboSyncMessage", exclude=True, repr=False, description="MindBody attr"
+    )
+    mbo_visit_id: int | None = Field(
+        None, validation_alias="mboVisitId", exclude=True, repr=False, description="MindBody attr"
+    )
+    mbo_waitlist_entry_id: int | None = Field(None, validation_alias="mboWaitlistEntryId", exclude=True, repr=False)
+    member_id: int = Field(validation_alias="memberId", exclude=True, repr=False, description="Not used by API")
+    studio_id: int = Field(validation_alias="studioId", exclude=True, repr=False, description="Not used by API")
+    updated_by: str = Field(validation_alias="updatedBy", exclude=True, repr=False)
+
+    @property
+    def studio_uuid(self) -> str:
+        """Shortcut to get the studio UUID."""
+        return self.otf_class.studio.studio_uuid
+
+    @property
+    def class_uuid(self) -> str:
+        """Shortcut to get the class UUID."""
+        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 self.otf_class.ends_at
+
+    @property
+    def id_value(self) -> str:
+        """Returns the booking_uuid, to be compatible with new BookingV2 model."""
+        return self.booking_uuid
+
+    def __str__(self) -> str:
+        """Returns a string representation of the booking."""
+        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.name
+        booked_str = self.status.value
+
+        return f"Booking: {starts_at_str} {class_name} - {coach_name} ({booked_str})"
+
+    def cancel(self) -> None:
+        """Cancels the booking by calling the proper API method.
+
+        Raises:
+            ValueError: If the API instance is not set.
+        """
+        self.raise_if_api_not_set()
+
+        self._api.bookings.cancel_booking(self)

otf_api/models/{bookings_v2.py → bookings/bookings_v2.py}

@@ -5,9 +5,10 @@ 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
+from otf_api.models.mixins import AddressMixin, ApiMixin, PhoneLongitudeLatitudeMixin
+
+# from otf_api.models.performance_summary import ZoneTimeMinutes
+from .enums import BookingStatus, ClassType
 
 LOGGER = getLogger(__name__)
 
@@ -16,10 +17,7 @@ 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.
-    """
-
+    """Get the end time of a class based on the start time and class type."""
     start_time = pendulum.instance(start_time)
 
     match class_type:
@@ -46,7 +44,7 @@ class Rating(OtfItemBase):
 
 
 class BookingV2Studio(PhoneLongitudeLatitudeMixin, OtfItemBase):
-    studio_uuid: str = Field(alias="id")
+    studio_uuid: str = Field(validation_alias="id")
     name: str | None = None
     time_zone: str | None = None
     email: str | None = None
@@ -56,53 +54,85 @@ class BookingV2Studio(PhoneLongitudeLatitudeMixin, OtfItemBase):
     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")
+class BookingV2Class(ApiMixin, OtfItemBase):
+    class_id: str = Field(validation_alias="id", description="Matches the `class_id` attribute of the OtfClass model")
     name: str
-    class_type: ClassType = Field(alias="type")
+    class_type: ClassType = Field(validation_alias="type")
     starts_at: datetime = Field(
-        alias="starts_at_local",
+        validation_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
+        None,
+        validation_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)
+    starts_at_utc: datetime | None = Field(None, validation_alias="starts_at", exclude=True, repr=False)
 
     @property
     def coach_name(self) -> str:
-        """Shortcut to get the coach's name, to be compatible with old Booking OtfClass model"""
+        """Shortcut to get the coach's name, to be compatible with old Booking OtfClass model."""
         return self.coach or ""
 
     @property
     def ends_at(self) -> datetime:
-        """Emulates the end time of the class, to be compatible with old Booking OtfClass model"""
+        """Emulates the end time of the class, to be compatible with old Booking OtfClass model."""
         return get_end_time(self.starts_at, self.class_type)
 
     def __str__(self) -> str:
+        """Returns a string representation of the class."""
         starts_at_str = self.starts_at.strftime("%a %b %d, %I:%M %p")
         return f"Class: {starts_at_str} {self.name} - {self.coach}"
 
+    def get_booking(self) -> "BookingV2":
+        """Returns a BookingV2 instance for this class.
+
+        Raises:
+            BookingNotFoundError: If the booking does not exist.
+            ValueError: If class_uuid is None or empty string or if the API instance is not set.
+        """
+        self.raise_if_api_not_set()
+
+        if not self.class_uuid:
+            raise ValueError("class_uuid is required to get the booking")
+
+        return self._api.bookings.get_booking_from_class_new(self)
+
+    def cancel_booking(self) -> None:
+        """Cancels the booking by calling the proper API method.
+
+        Raises:
+            BookingNotFoundError: If the booking does not exist.
+            ValueError: If class_uuid is None or empty string or if the API instance is not set.
+        """
+        self.raise_if_api_not_set()
+
+        self.get_booking().cancel()
+
 
 class BookingV2Workout(OtfItemBase):
     id: str
-    performance_summary_id: str = Field(..., alias="id", description="Alias to id, to simplify the API")
+    performance_summary_id: str = Field(..., validation_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
+    # zone_time_minutes: ZoneTimeMinutes
 
 
-class BookingV2(OtfItemBase):
+class BookingV2(ApiMixin, OtfItemBase):
     booking_id: str = Field(
-        ..., alias="id", description="The booking ID used to cancel the booking - must be canceled through new endpoint"
+        ...,
+        validation_alias="id",
+        description="The booking ID used to cancel the booking - must be canceled through new endpoint",
     )
 
-    member_uuid: str = Field(..., alias="member_id")
+    member_uuid: str = Field(..., validation_alias="member_id")
     service_name: str | None = Field(None, description="Represents tier of member")
 
     cross_regional: bool | None = None
@@ -113,7 +143,7 @@ class BookingV2(OtfItemBase):
     canceled_at: datetime | None = None
     ratable: bool
 
-    otf_class: BookingV2Class = Field(..., alias="class")
+    otf_class: BookingV2Class = Field(..., validation_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"))
@@ -130,13 +160,13 @@ class BookingV2(OtfItemBase):
         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
+    updated_at: datetime = Field(
+        ..., 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"""
+        """Emulates the booking status from the old API, but with less specificity."""
         if self.late_canceled:
             return BookingStatus.LateCancelled
 
@@ -150,42 +180,53 @@ class BookingV2(OtfItemBase):
 
     @property
     def studio_uuid(self) -> str:
-        """Shortcut to get the studio UUID"""
+        """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"""
+        """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"""
+        """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"""
+        """Shortcut to get the class end time."""
         return self.otf_class.ends_at
 
     @property
     def cancelled_date(self) -> datetime | None:
-        """Returns the canceled_at value in a backward-compatible way"""
+        """Returns the canceled_at value in a backward-compatible way."""
         return self.canceled_at
 
     @property
     def id_value(self) -> str:
-        """Returns the booking_id, to be compatible with old Booking model"""
+        """Returns the booking_id, to be compatible with old Booking model."""
         return self.booking_id
 
     def __str__(self) -> str:
+        """Returns a string representation of the booking."""
         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})"
+
+    def cancel(self) -> None:
+        """Cancels the booking by calling the proper API method.
+
+        Raises:
+            ValueError: If the API instance is not set.
+        """
+        self.raise_if_api_not_set()
+
+        self._api.bookings.cancel_booking_new(self)

otf_api/models/bookings/classes.py

@@ -0,0 +1,124 @@
+import typing
+from datetime import datetime
+
+from pydantic import AliasPath, Field
+
+from otf_api import exceptions as exc
+from otf_api.models.base import OtfItemBase
+from otf_api.models.mixins import ApiMixin
+from otf_api.models.studios import StudioDetail
+
+from .enums import ClassType, DoW
+
+if typing.TYPE_CHECKING:
+    from otf_api.models.bookings import Booking, BookingV2
+
+
+class OtfClass(ApiMixin, OtfItemBase):
+    class_uuid: str = Field(validation_alias="ot_base_class_uuid", description="The OTF class UUID")
+    class_id: str | None = Field(None, validation_alias="id", description="Matches new booking endpoint class id")
+
+    name: str | None = Field(None, description="The name of the class")
+    class_type: ClassType = Field(validation_alias="type")
+    coach: str | None = Field(None, validation_alias=AliasPath("coach", "first_name"))
+    ends_at: datetime = Field(
+        validation_alias="ends_at_local",
+        description="The end time of the class. Reflects local time, but the object does not have a timezone.",
+    )
+    starts_at: datetime = Field(
+        validation_alias="starts_at_local",
+        description="The start time of the class. Reflects local time, but the object does not have a timezone.",
+    )
+    studio: StudioDetail
+
+    # capacity/status fields
+    booking_capacity: int | None = None
+    full: bool | None = None
+    max_capacity: int | None = None
+    waitlist_available: bool | 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, validation_alias="canceled")
+    is_home_studio: bool | None = Field(None, description="Custom helper field to determine if at home studio")
+
+    created_at: datetime | None = Field(None, exclude=True, repr=False)
+    ends_at_utc: datetime | None = Field(None, validation_alias="ends_at", exclude=True, repr=False)
+    mbo_class_description_id: str | None = Field(None, exclude=True, repr=False, description="MindBody attr")
+    mbo_class_id: str | None = Field(None, exclude=True, repr=False, description="MindBody attr")
+    mbo_class_schedule_id: str | None = Field(None, exclude=True, repr=False, description="MindBody attr")
+    starts_at_utc: datetime | None = Field(None, validation_alias="starts_at", exclude=True, repr=False)
+    updated_at: datetime | None = Field(None, exclude=True, repr=False)
+
+    @property
+    def day_of_week(self) -> DoW:
+        """Returns the day of the week as an enum."""
+        dow = self.starts_at.strftime("%A")
+        return DoW(dow)
+
+    def __str__(self) -> str:
+        """Returns a string representation of the class."""
+        starts_at_str = self.starts_at.strftime("%a %b %d, %I:%M %p")
+        booked_str = ""
+        if self.is_booked:
+            booked_str = "Booked"
+        elif self.has_availability:
+            booked_str = "Available"
+        elif self.waitlist_available:
+            booked_str = "Waitlist Available"
+        else:
+            booked_str = "Full"
+        return f"Class: {starts_at_str} {self.name} - {self.coach} ({booked_str})"
+
+    @property
+    def has_availability(self) -> bool:
+        """Represents if the class has availability."""
+        return not self.full
+
+    @property
+    def day_of_week_enum(self) -> DoW:
+        """Returns the day of the week as an enum."""
+        dow = self.starts_at.strftime("%A").upper()
+        return DoW(dow)
+
+    def book_class(self) -> "Booking":
+        """Book a class by providing either the class_uuid or the OtfClass object.
+
+        Returns:
+            Booking: The booking.
+
+        Raises:
+            AlreadyBookedError: If the class is already booked.
+            OutsideSchedulingWindowError: If the class is outside the scheduling window.
+            ValueError: If class_uuid is None or empty string.
+            OtfException: If there is an error booking the class.
+        """
+        self.raise_if_api_not_set()
+        new_booking = self._api.bookings.book_class(self.class_uuid)
+        self.is_booked = True
+        return new_booking
+
+    def cancel_booking(self) -> None:
+        """Cancels the class booking.
+
+        Raises:
+            BookingNotFoundError: If the booking does not exist.
+            ValueError: If booking_uuid is None or empty string or the API is not set.
+        """
+        self.raise_if_api_not_set()
+        self.get_booking().cancel()
+
+    def get_booking(self) -> "Booking | BookingV2":
+        """Get the booking for this class.
+
+        Returns:
+            Booking | BookingV2: The booking associated with this class.
+
+        Raises:
+            BookingNotFoundError: If the booking does not exist.
+            ValueError: If the API is not set.
+        """
+        self.raise_if_api_not_set()
+        try:
+            return self._api.bookings.get_booking_from_class(self)
+        except exc.BookingNotFoundError:
+            return self._api.bookings.get_booking_from_class_new(self)

otf_api/models/{enums.py → bookings/enums.py}

@@ -1,14 +1,5 @@
-from enum import IntEnum, StrEnum
-
-
-class StudioStatus(StrEnum):
-    OTHER = "OTHER"
-    ACTIVE = "Active"
-    INACTIVE = "Inactive"
-    COMING_SOON = "Coming Soon"
-    TEMP_CLOSED = "Temporarily Closed"
-    PERM_CLOSED = "Permanently Closed"
-    UNKNOWN = "Unknown"
+from enum import StrEnum
+from typing import Self
 
 
 class BookingStatus(StrEnum):
@@ -98,84 +89,19 @@ class ClassType(StrEnum):
     TREAD_50 = "TREAD_50"
 
     @classmethod
-    def get_case_insensitive(cls, value: str) -> str:
+    def get_case_insensitive(cls, value: str) -> "Self":
+        """Returns the actual value of the enum, regardless of case."""
         value = (value or "").strip()
         value = value.replace(" ", "_")
-        lcase_to_actual = {item.value.lower(): item.value for item in cls}
+        lcase_to_actual = {item.value.lower(): item for item in cls}
         return lcase_to_actual[value.lower()]
 
     @staticmethod
     def get_standard_class_types() -> list["ClassType"]:
-        """Returns 2G/3G/Tornado - 60/90 minute classes"""
+        """Returns 2G/3G/Tornado - 60/90 minute classes."""
         return [ClassType.ORANGE_60, ClassType.ORANGE_90]
 
     @staticmethod
     def get_tread_strength_class_types() -> list["ClassType"]:
-        """Returns Tread/Strength 50 minute classes"""
+        """Returns Tread/Strength 50 minute classes."""
         return [ClassType.TREAD_50, ClassType.STRENGTH_50]
-
-
-class StatsTime(StrEnum):
-    LastYear = "lastYear"
-    ThisYear = "thisYear"
-    LastMonth = "lastMonth"
-    ThisMonth = "thisMonth"
-    LastWeek = "lastWeek"
-    ThisWeek = "thisWeek"
-    AllTime = "allTime"
-
-
-class EquipmentType(IntEnum):
-    Treadmill = 2
-    Strider = 3
-    Rower = 4
-    Bike = 5
-    WeightFloor = 6
-    PowerWalker = 7
-
-
-class ChallengeCategory(IntEnum):
-    Other = 0
-    DriTri = 2
-    Infinity = 3
-    MarathonMonth = 5
-    OrangeEverest = 9
-    CatchMeIfYouCan = 10
-    TwoHundredMeterRow = 15
-    FiveHundredMeterRow = 16
-    TwoThousandMeterRow = 17
-    TwelveMinuteTreadmill = 18
-    OneMileTreadmill = 19
-    TenMinuteRow = 20
-    HellWeek = 52
-    Inferno = 55
-    Mayhem = 58
-    BackAtIt = 60
-    FourteenMinuteRow = 61
-    TwelveDaysOfFitness = 63
-    TransformationChallenge = 64
-    RemixInSix = 65
-    Push = 66
-    QuarterMileTreadmill = 69
-    OneThousandMeterRow = 70
-
-
-class DriTriChallengeSubCategory(IntEnum):
-    FullRun = 1
-    SprintRun = 3
-    Relay = 4
-    StrengthRun = 1500
-
-
-class MarathonMonthChallengeSubCategory(IntEnum):
-    Original = 1
-    Full = 14
-    Half = 15
-    Ultra = 16
-
-
-# only Other, DriTri, and MarathonMonth have subcategories
-
-# BackAtIt and Transformation are multi-week challenges
-
-# RemixInSix, Mayhem, HellWeek, Push, and TwelveDaysOfFitness are multi-day challenges