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

otf_api/models/{body_composition_list.py → workouts/body_composition_list.py}

@@ -35,6 +35,15 @@ class BodyFatPercentIndicator(StrEnum):
 def get_percent_body_fat_descriptor(
     percent_body_fat: float, body_fat_percent_dividers: list[float]
 ) -> BodyFatPercentIndicator:
+    """Get the body fat percent descriptor based on the percent body fat and dividers.
+
+    Args:
+        percent_body_fat (float): The percent body fat to check
+        body_fat_percent_dividers (list[float]): The dividers for the percent body fat
+
+    Returns:
+        BodyFatPercentIndicator: The body fat percent descriptor
+    """
     if not percent_body_fat or not body_fat_percent_dividers[3]:
         return BodyFatPercentIndicator.NO_INDICATOR
 
@@ -48,6 +57,15 @@ def get_percent_body_fat_descriptor(
 
 
 def get_relative_descriptor(in_body_value: float, in_body_dividers: list[float]) -> AverageType:
+    """Get the relative descriptor for the InBody value.
+
+    Args:
+        in_body_value (float): The InBody value to check
+        in_body_dividers (list[float]): The dividers for the InBody value
+
+    Returns:
+        AverageType: The relative descriptor for the InBody value
+    """
     if in_body_value <= in_body_dividers[2]:
         return AverageType.BELOW_AVERAGE
 
@@ -58,6 +76,17 @@ def get_relative_descriptor(in_body_value: float, in_body_dividers: list[float])
 
 
 def get_body_fat_percent_dividers(age: int, gender: Literal["M", "F"]) -> list[float]:
+    """Get the body fat percent dividers based on age and gender.
+
+    Converted more or less directly from the Java code in the OTF app.
+
+    Args:
+        age (int): The age of the person
+        gender (Literal["M", "F"]): The gender from the member details
+
+    Returns:
+        list[float]: The body fat percent dividers
+    """
     if gender == "M":
         return get_body_fat_percent_dividers_male(age)
 
@@ -65,6 +94,16 @@ def get_body_fat_percent_dividers(age: int, gender: Literal["M", "F"]) -> list[f
 
 
 def get_body_fat_percent_dividers_male(age: int) -> list[float]:
+    """Get the body fat percent dividers for males based on age.
+
+    Converted more or less directly from the Java code in the OTF app.
+
+    Args:
+        age (int): The age of the person
+
+    Returns:
+        list[float]: The body fat percent dividers
+    """
     match age:
         case age if 0 <= age < 30:
             return [0.0, 13.1, 21.1, 100.0]
@@ -81,6 +120,16 @@ def get_body_fat_percent_dividers_male(age: int) -> list[float]:
 
 
 def get_body_fat_percent_dividers_female(age: int) -> list[float]:
+    """Get the body fat percent dividers for females based on age.
+
+    Converted more or less directly from the Java code in the OTF app.
+
+    Args:
+        age (int): The age of the person
+
+    Returns:
+        list[float]: The body fat percent dividers
+    """
     match age:
         case age if 0 <= age < 30:
             return [0.0, 19.1, 26.1, 100.0]
@@ -97,106 +146,110 @@ def get_body_fat_percent_dividers_female(age: int) -> list[float]:
 
 
 class LeanBodyMass(OtfItemBase):
-    left_arm: float = Field(..., alias="lbmOfLeftArm")
-    left_leg: float = Field(..., alias="lbmOfLeftLeg")
-    right_arm: float = Field(..., alias="lbmOfRightArm")
-    right_leg: float = Field(..., alias="lbmOfRightLeg")
-    trunk: float = Field(..., alias="lbmOfTrunk")
+    left_arm: float = Field(..., validation_alias="lbmOfLeftArm")
+    left_leg: float = Field(..., validation_alias="lbmOfLeftLeg")
+    right_arm: float = Field(..., validation_alias="lbmOfRightArm")
+    right_leg: float = Field(..., validation_alias="lbmOfRightLeg")
+    trunk: float = Field(..., validation_alias="lbmOfTrunk")
 
 
 class LeanBodyMassPercent(OtfItemBase):
-    left_arm: float = Field(..., alias="lbmPercentOfLeftArm")
-    left_leg: float = Field(..., alias="lbmPercentOfLeftLeg")
-    right_arm: float = Field(..., alias="lbmPercentOfRightArm")
-    right_leg: float = Field(..., alias="lbmPercentOfRightLeg")
-    trunk: float = Field(..., alias="lbmPercentOfTrunk")
+    left_arm: float = Field(..., validation_alias="lbmPercentOfLeftArm")
+    left_leg: float = Field(..., validation_alias="lbmPercentOfLeftLeg")
+    right_arm: float = Field(..., validation_alias="lbmPercentOfRightArm")
+    right_leg: float = Field(..., validation_alias="lbmPercentOfRightLeg")
+    trunk: float = Field(..., validation_alias="lbmPercentOfTrunk")
 
 
 class BodyFatMass(OtfItemBase):
-    control: float = Field(..., alias="bfmControl")
-    left_arm: float = Field(..., alias="bfmOfLeftArm")
-    left_leg: float = Field(..., alias="bfmOfLeftLeg")
-    right_arm: float = Field(..., alias="bfmOfRightArm")
-    right_leg: float = Field(..., alias="bfmOfRightLeg")
-    trunk: float = Field(..., alias="bfmOfTrunk")
+    control: float = Field(..., validation_alias="bfmControl")
+    left_arm: float = Field(..., validation_alias="bfmOfLeftArm")
+    left_leg: float = Field(..., validation_alias="bfmOfLeftLeg")
+    right_arm: float = Field(..., validation_alias="bfmOfRightArm")
+    right_leg: float = Field(..., validation_alias="bfmOfRightLeg")
+    trunk: float = Field(..., validation_alias="bfmOfTrunk")
 
 
 class BodyFatMassPercent(OtfItemBase):
-    left_arm: float = Field(..., alias="bfmPercentOfLeftArm")
-    left_leg: float = Field(..., alias="bfmPercentOfLeftLeg")
-    right_arm: float = Field(..., alias="bfmPercentOfRightArm")
-    right_leg: float = Field(..., alias="bfmPercentOfRightLeg")
-    trunk: float = Field(..., alias="bfmPercentOfTrunk")
+    left_arm: float = Field(..., validation_alias="bfmPercentOfLeftArm")
+    left_leg: float = Field(..., validation_alias="bfmPercentOfLeftLeg")
+    right_arm: float = Field(..., validation_alias="bfmPercentOfRightArm")
+    right_leg: float = Field(..., validation_alias="bfmPercentOfRightLeg")
+    trunk: float = Field(..., validation_alias="bfmPercentOfTrunk")
 
 
 class TotalBodyWeight(OtfItemBase):
-    right_arm: float = Field(..., alias="tbwOfRightArm")
-    left_arm: float = Field(..., alias="tbwOfLeftArm")
-    trunk: float = Field(..., alias="tbwOfTrunk")
-    right_leg: float = Field(..., alias="tbwOfRightLeg")
-    left_leg: float = Field(..., alias="tbwOfLeftLeg")
+    right_arm: float = Field(..., validation_alias="tbwOfRightArm")
+    left_arm: float = Field(..., validation_alias="tbwOfLeftArm")
+    trunk: float = Field(..., validation_alias="tbwOfTrunk")
+    right_leg: float = Field(..., validation_alias="tbwOfRightLeg")
+    left_leg: float = Field(..., validation_alias="tbwOfLeftLeg")
 
 
 class IntraCellularWater(OtfItemBase):
-    right_arm: float = Field(..., alias="icwOfRightArm")
-    left_arm: float = Field(..., alias="icwOfLeftArm")
-    trunk: float = Field(..., alias="icwOfTrunk")
-    right_leg: float = Field(..., alias="icwOfRightLeg")
-    left_leg: float = Field(..., alias="icwOfLeftLeg")
+    right_arm: float = Field(..., validation_alias="icwOfRightArm")
+    left_arm: float = Field(..., validation_alias="icwOfLeftArm")
+    trunk: float = Field(..., validation_alias="icwOfTrunk")
+    right_leg: float = Field(..., validation_alias="icwOfRightLeg")
+    left_leg: float = Field(..., validation_alias="icwOfLeftLeg")
 
 
 class ExtraCellularWater(OtfItemBase):
-    right_arm: float = Field(..., alias="ecwOfRightArm")
-    left_arm: float = Field(..., alias="ecwOfLeftArm")
-    trunk: float = Field(..., alias="ecwOfTrunk")
-    right_leg: float = Field(..., alias="ecwOfRightLeg")
-    left_leg: float = Field(..., alias="ecwOfLeftLeg")
+    right_arm: float = Field(..., validation_alias="ecwOfRightArm")
+    left_arm: float = Field(..., validation_alias="ecwOfLeftArm")
+    trunk: float = Field(..., validation_alias="ecwOfTrunk")
+    right_leg: float = Field(..., validation_alias="ecwOfRightLeg")
+    left_leg: float = Field(..., validation_alias="ecwOfLeftLeg")
 
 
 class ExtraCellularWaterOverTotalBodyWater(OtfItemBase):
-    right_arm: float = Field(..., alias="ecwOverTBWOfRightArm")
-    left_arm: float = Field(..., alias="ecwOverTBWOfLeftArm")
-    trunk: float = Field(..., alias="ecwOverTBWOfTrunk")
-    right_leg: float = Field(..., alias="ecwOverTBWOfRightLeg")
-    left_leg: float = Field(..., alias="ecwOverTBWOfLeftLeg")
+    right_arm: float = Field(..., validation_alias="ecwOverTBWOfRightArm")
+    left_arm: float = Field(..., validation_alias="ecwOverTBWOfLeftArm")
+    trunk: float = Field(..., validation_alias="ecwOverTBWOfTrunk")
+    right_leg: float = Field(..., validation_alias="ecwOverTBWOfRightLeg")
+    left_leg: float = Field(..., validation_alias="ecwOverTBWOfLeftLeg")
 
 
 class BodyCompositionData(OtfItemBase):
     # NOTE: weight is hardcoded to be pounds here, regardless of the unit shown in the member details
 
-    member_uuid: str = Field(..., alias="memberUUId")
-    member_id: str | int = Field(..., alias="memberId")
-    scan_result_uuid: str = Field(..., alias="scanResultUUId")
-    inbody_id: str = Field(..., alias="id", exclude=True, repr=False, description="InBody ID, same as email address")
+    member_uuid: str = Field(..., validation_alias="memberUUId")
+    member_id: str | int = Field(..., validation_alias="memberId")
+    scan_result_uuid: str = Field(..., validation_alias="scanResultUUId")
+    inbody_id: str = Field(
+        ..., validation_alias="id", exclude=True, repr=False, description="InBody ID, same as email address"
+    )
     email: str
     height: str = Field(..., description="Height in cm")
     gender: Literal["M", "F"]
     age: int
-    scan_datetime: datetime = Field(..., alias="testDatetime")
+    scan_datetime: datetime = Field(..., validation_alias="testDatetime")
     provided_weight: float = Field(
-        ..., alias="weight", description="Weight in pounds, provided by member at time of scan"
+        ..., validation_alias="weight", description="Weight in pounds, provided by member at time of scan"
     )
 
     lean_body_mass_details: LeanBodyMass
     lean_body_mass_percent_details: LeanBodyMassPercent
 
-    total_body_weight: float = Field(..., alias="tbw", description="Total body weight in pounds, based on scan results")
-    dry_lean_mass: float = Field(..., alias="dlm")
-    body_fat_mass: float = Field(..., alias="bfm")
-    lean_body_mass: float = Field(..., alias="lbm")
-    skeletal_muscle_mass: float = Field(..., alias="smm")
-    body_mass_index: float = Field(..., alias="bmi")
-    percent_body_fat: float = Field(..., alias="pbf")
-    basal_metabolic_rate: float = Field(..., alias="bmr")
-    in_body_type: str = Field(..., alias="inBodyType")
+    total_body_weight: float = Field(
+        ..., validation_alias="tbw", description="Total body weight in pounds, based on scan results"
+    )
+    dry_lean_mass: float = Field(..., validation_alias="dlm")
+    body_fat_mass: float = Field(..., validation_alias="bfm")
+    lean_body_mass: float = Field(..., validation_alias="lbm")
+    skeletal_muscle_mass: float = Field(..., validation_alias="smm")
+    body_mass_index: float = Field(..., validation_alias="bmi")
+    percent_body_fat: float = Field(..., validation_alias="pbf")
+    basal_metabolic_rate: float = Field(..., validation_alias="bmr")
+    in_body_type: str = Field(..., validation_alias="inBodyType")
 
     # excluded because they are only useful for end result of calculations
-    body_fat_mass_dividers: list[float] = Field(..., alias="bfmGraphScale", exclude=True, repr=False)
-    body_fat_mass_plot_point: float = Field(..., alias="pfatnew", exclude=True, repr=False)
-    skeletal_muscle_mass_dividers: list[float] = Field(..., alias="smmGraphScale", exclude=True, repr=False)
-    skeletal_muscle_mass_plot_point: float = Field(..., alias="psmm", exclude=True, repr=False)
-    weight_dividers: list[float] = Field(..., alias="wtGraphScale", exclude=True, repr=False)
-    weight_plot_point: float = Field(..., alias="pwt", exclude=True, repr=False)
+    body_fat_mass_dividers: list[float] = Field(..., validation_alias="bfmGraphScale", exclude=True, repr=False)
+    body_fat_mass_plot_point: float = Field(..., validation_alias="pfatnew", exclude=True, repr=False)
+    skeletal_muscle_mass_dividers: list[float] = Field(..., validation_alias="smmGraphScale", exclude=True, repr=False)
+    skeletal_muscle_mass_plot_point: float = Field(..., validation_alias="psmm", exclude=True, repr=False)
+    weight_dividers: list[float] = Field(..., validation_alias="wtGraphScale", exclude=True, repr=False)
+    weight_plot_point: float = Field(..., validation_alias="pwt", exclude=True, repr=False)
 
     # excluded due to 0 values
     body_fat_mass_details: BodyFatMass = Field(..., exclude=True, repr=False)
@@ -207,13 +260,13 @@ class BodyCompositionData(OtfItemBase):
     extra_cellular_water_over_total_body_water_details: ExtraCellularWaterOverTotalBodyWater = Field(
         ..., exclude=True, repr=False
     )
-    visceral_fat_level: float = Field(..., alias="vfl", exclude=True, repr=False)
-    visceral_fat_area: float = Field(..., alias="vfa", exclude=True, repr=False)
-    body_comp_measurement: float = Field(..., alias="bcm", exclude=True, repr=False)
-    total_body_weight_over_lean_body_mass: float = Field(..., alias="tbwOverLBM", exclude=True, repr=False)
-    intracellular_water: float = Field(..., alias="icw", exclude=True, repr=False)
-    extracellular_water: float = Field(..., alias="ecw", exclude=True, repr=False)
-    lean_body_mass_control: float = Field(..., alias="lbmControl", exclude=True, repr=False)
+    visceral_fat_level: float = Field(..., validation_alias="vfl", exclude=True, repr=False)
+    visceral_fat_area: float = Field(..., validation_alias="vfa", exclude=True, repr=False)
+    body_comp_measurement: float = Field(..., validation_alias="bcm", exclude=True, repr=False)
+    total_body_weight_over_lean_body_mass: float = Field(..., validation_alias="tbwOverLBM", exclude=True, repr=False)
+    intracellular_water: float = Field(..., validation_alias="icw", exclude=True, repr=False)
+    extracellular_water: float = Field(..., validation_alias="ecw", exclude=True, repr=False)
+    lean_body_mass_control: float = Field(..., validation_alias="lbmControl", exclude=True, repr=False)
 
     def __init__(self, **data):
         # Convert the nested dictionaries to the appropriate classes
@@ -235,12 +288,28 @@ class BodyCompositionData(OtfItemBase):
 
     @field_validator("skeletal_muscle_mass_dividers", "weight_dividers", "body_fat_mass_dividers", mode="before")
     @classmethod
-    def convert_dividers_to_float_list(cls, v: str):
+    def convert_dividers_to_float_list(cls, v: str) -> list[float]:
+        """Convert the dividers from a string to a list of floats.
+
+        Args:
+            v (str): The dividers as a string, separated by semicolons.
+
+        Returns:
+            list[float]: The dividers as a list of floats.
+        """
         return [float(i) for i in v.split(";")]
 
     @field_validator("total_body_weight", mode="before")
     @classmethod
-    def convert_body_weight_from_kg_to_pounds(cls, v: float):
+    def convert_body_weight_from_kg_to_pounds(cls, v: float) -> float:
+        """Convert the body weight from kg to pounds.
+
+        Args:
+            v (float): The body weight in kg.
+
+        Returns:
+            float: The body weight in pounds.
+        """
         return ureg.Quantity(v, ureg.kilogram).to(ureg.pound).magnitude
 
     @property

otf_api/models/workouts/challenge_tracker_content.py

@@ -0,0 +1,50 @@
+from pydantic import Field
+
+from otf_api.models.base import OtfItemBase
+
+from .enums import EquipmentType
+
+
+class Year(OtfItemBase):
+    year: int | None = Field(None, validation_alias="Year")
+    is_participated: bool | None = Field(None, validation_alias="IsParticipated")
+    in_progress: bool | None = Field(None, validation_alias="InProgress")
+
+
+class Program(OtfItemBase):
+    """A program represents multi-day/week challenges that members can participate in."""
+
+    # NOTE: These ones do seem to match the ChallengeType enums in the OTF app.
+    # Leaving them as int for now though in case older data or other user's
+    # data doesn't match up.
+    challenge_category_id: int | None = Field(None, validation_alias="ChallengeCategoryId")
+    challenge_sub_category_id: int | None = Field(None, validation_alias="ChallengeSubCategoryId")
+    challenge_name: str | None = Field(None, validation_alias="ChallengeName")
+    years: list[Year] = Field(default_factory=list, validation_alias="Years")
+
+
+class Challenge(OtfItemBase):
+    """A challenge represents a single day or event that members can participate in."""
+
+    # NOTE: The challenge category/subcategory ids here do not seem to be at
+    # 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: int | None = Field(None, validation_alias="ChallengeCategoryId")
+    challenge_sub_category_id: int | None = Field(None, validation_alias="ChallengeSubCategoryId")
+    challenge_name: str | None = Field(None, validation_alias="ChallengeName")
+    years: list[Year] = Field(default_factory=list, validation_alias="Years")
+
+
+class Benchmark(OtfItemBase):
+    """A benchmark represents a specific workout that members can participate in."""
+
+    equipment_id: EquipmentType | None = Field(None, validation_alias="EquipmentId")
+    equipment_name: str | None = Field(None, validation_alias="EquipmentName")
+    years: list[Year] = Field(default_factory=list, validation_alias="Years")
+
+
+class ChallengeTracker(OtfItemBase):
+    programs: list[Program] = Field(default_factory=list, validation_alias="Programs")
+    challenges: list[Challenge] = Field(default_factory=list, validation_alias="Challenges")
+    benchmarks: list[Benchmark] = Field(default_factory=list, validation_alias="Benchmarks")

otf_api/models/workouts/challenge_tracker_detail.py

@@ -0,0 +1,99 @@
+from datetime import datetime
+from typing import Any
+
+from pydantic import Field
+
+from otf_api.models.base import OtfItemBase
+
+from .enums import EquipmentType
+
+
+class MetricEntry(OtfItemBase):
+    title: str | None = Field(None, validation_alias="Title")
+    equipment_id: EquipmentType | None = Field(None, validation_alias="EquipmentId")
+    entry_type: str | None = Field(None, validation_alias="EntryType")
+    metric_key: str | None = Field(None, validation_alias="MetricKey")
+    min_value: str | None = Field(None, validation_alias="MinValue")
+    max_value: str | None = Field(None, validation_alias="MaxValue")
+
+
+class BenchmarkHistory(OtfItemBase):
+    studio_name: str | None = Field(None, validation_alias="StudioName")
+    equipment_id: EquipmentType | None = Field(None, validation_alias="EquipmentId")
+    class_time: datetime | None = Field(None, validation_alias="ClassTime")
+    challenge_sub_category_id: int | None = Field(None, validation_alias="ChallengeSubCategoryId")
+    weight_lbs: int | None = Field(None, validation_alias="WeightLBS")
+    class_name: str | None = Field(None, validation_alias="ClassName")
+    coach_name: str | None = Field(None, validation_alias="CoachName")
+    result: float | str | None = Field(None, validation_alias="Result")
+    workout_type_id: int | None = Field(None, validation_alias="WorkoutTypeId", exclude=True, repr=False)
+    workout_id: int | None = Field(None, validation_alias="WorkoutId", exclude=True, repr=False)
+    linked_challenges: list[Any] | None = Field(None, validation_alias="LinkedChallenges", exclude=True, repr=False)
+
+    date_created: datetime | None = Field(
+        None,
+        validation_alias="DateCreated",
+        exclude=True,
+        repr=False,
+        description="When the entry was created in database, not useful to users",
+    )
+    date_updated: datetime | None = Field(
+        None,
+        validation_alias="DateUpdated",
+        exclude=True,
+        repr=False,
+        description="When the entry was updated in database, not useful to users",
+    )
+    class_id: int | None = Field(
+        None, validation_alias="ClassId", exclude=True, repr=False, description="Not used by API"
+    )
+    substitute_id: int | None = Field(
+        None,
+        validation_alias="SubstituteId",
+        exclude=True,
+        repr=False,
+        description="Not used by API, also always seems to be 0",
+    )
+
+
+class ChallengeHistory(OtfItemBase):
+    studio_name: str | None = Field(None, validation_alias="StudioName")
+    start_date: datetime | None = Field(None, validation_alias="StartDate")
+    end_date: datetime | None = Field(None, validation_alias="EndDate")
+    total_result: float | str | None = Field(None, validation_alias="TotalResult")
+    is_finished: bool | None = Field(None, validation_alias="IsFinished")
+    benchmark_histories: list[BenchmarkHistory] = Field(default_factory=list, validation_alias="BenchmarkHistories")
+
+    challenge_id: int | None = Field(
+        None, validation_alias="ChallengeId", exclude=True, repr=False, description="Not used by API"
+    )
+    studio_id: int | None = Field(
+        None, validation_alias="StudioId", exclude=True, repr=False, description="Not used by API"
+    )
+    challenge_objective: str | None = Field(
+        None, validation_alias="ChallengeObjective", exclude=True, repr=False, description="Always the string 'None'"
+    )
+
+
+class Goal(OtfItemBase):
+    goal: int | None = Field(None, validation_alias="Goal")
+    goal_period: str | None = Field(None, validation_alias="GoalPeriod")
+    overall_goal: int | None = Field(None, validation_alias="OverallGoal")
+    overall_goal_period: str | None = Field(None, validation_alias="OverallGoalPeriod")
+    min_overall: int | None = Field(None, validation_alias="MinOverall")
+    min_overall_period: str | None = Field(None, validation_alias="MinOverallPeriod")
+
+
+class FitnessBenchmark(OtfItemBase):
+    challenge_category_id: int | None = Field(None, validation_alias="ChallengeCategoryId")
+    challenge_sub_category_id: int | None = Field(None, validation_alias="ChallengeSubCategoryId")
+    equipment_id: EquipmentType | None = Field(None, validation_alias="EquipmentId")
+    equipment_name: str | None = Field(None, validation_alias="EquipmentName")
+    metric_entry: MetricEntry | None = Field(None, validation_alias="MetricEntry")
+    challenge_name: str | None = Field(None, validation_alias="ChallengeName")
+    best_record: float | str | None = Field(None, validation_alias="BestRecord")
+    last_record: float | str | None = Field(None, validation_alias="LastRecord")
+    previous_record: float | str | None = Field(None, validation_alias="PreviousRecord")
+    unit: str | None = Field(None, validation_alias="Unit")
+    goals: Goal | None = Field(None, validation_alias="Goals")
+    challenge_histories: list[ChallengeHistory] = Field(default_factory=list, validation_alias="ChallengeHistories")

otf_api/models/workouts/enums.py

@@ -0,0 +1,70 @@
+from enum import IntEnum, StrEnum
+
+
+class StatsTime(StrEnum):
+    """Enum representing the different time periods for workout statistics."""
+
+    LastYear = "lastYear"
+    ThisYear = "thisYear"
+    LastMonth = "lastMonth"
+    ThisMonth = "thisMonth"
+    LastWeek = "lastWeek"
+    ThisWeek = "thisWeek"
+    AllTime = "allTime"
+
+
+class EquipmentType(IntEnum):
+    """Enum representing the type of equipment used in workouts."""
+
+    Treadmill = 2
+    Strider = 3
+    Rower = 4
+    Bike = 5
+    WeightFloor = 6
+    PowerWalker = 7
+
+
+class ChallengeCategory(IntEnum):
+    """Enum representing the different challenge categories."""
+
+    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):
+    """Enum representing the subcategories of the DriTri challenge."""
+
+    FullRun = 1
+    SprintRun = 3
+    Relay = 4
+    StrengthRun = 1500
+
+
+class MarathonMonthChallengeSubCategory(IntEnum):
+    """Enum representing the subcategories of the Marathon Month challenge."""
+
+    Original = 1
+    Full = 14
+    Half = 15
+    Ultra = 16

otf_api/models/workouts/lifetime_stats.py

@@ -0,0 +1,96 @@
+from typing import Generic, TypeVar
+
+from pydantic import Field, field_serializer
+
+from otf_api.models.base import OtfItemBase
+
+from .enums import StatsTime
+
+T = TypeVar("T", bound=OtfItemBase)
+
+
+class OutStudioMixin:
+    walking_distance: float | None = Field(None, validation_alias="walkingDistance")
+    running_distance: float | None = Field(None, validation_alias="runningDistance")
+    cycling_distance: float | None = Field(None, validation_alias="cyclingDistance")
+
+    @field_serializer("walking_distance", "running_distance", "cycling_distance")
+    @staticmethod
+    def limit_floats(value: float | int | None) -> float | None:
+        """Limit the float values to 2 decimal places."""
+        if value is not None:
+            return round(value, 2)
+        return value
+
+
+class InStudioMixin:
+    treadmill_distance: float | None = Field(None, validation_alias="treadmillDistance")
+    treadmill_elevation_gained: float | None = Field(None, validation_alias="treadmillElevationGained")
+    rower_distance: float | None = Field(None, validation_alias="rowerDistance")
+    rower_watt: float | None = Field(None, validation_alias="rowerWatt")
+
+    @field_serializer("treadmill_distance", "treadmill_elevation_gained", "rower_distance", "rower_watt")
+    @staticmethod
+    def limit_floats(value: float | int | None) -> float | None:
+        """Limit the float values to 2 decimal places."""
+        if value is not None:
+            return round(value, 2)
+        return value
+
+
+class BaseStatsData(OtfItemBase):
+    calories: float | None = None
+    splat_point: float | None = Field(None, validation_alias="splatPoint")
+    total_black_zone: float | None = Field(None, validation_alias="totalBlackZone")
+    total_blue_zone: float | None = Field(None, validation_alias="totalBlueZone")
+    total_green_zone: float | None = Field(None, validation_alias="totalGreenZone")
+    total_orange_zone: float | None = Field(None, validation_alias="totalOrangeZone")
+    total_red_zone: float | None = Field(None, validation_alias="totalRedZone")
+    workout_duration: float | None = Field(None, validation_alias="workoutDuration")
+    step_count: float | None = Field(None, validation_alias="stepCount")
+
+
+class InStudioStatsData(InStudioMixin, BaseStatsData):
+    pass
+
+
+class OutStudioStatsData(OutStudioMixin, BaseStatsData):
+    pass
+
+
+class AllStatsData(OutStudioMixin, InStudioMixin, BaseStatsData):
+    pass
+
+
+class TimeStats(OtfItemBase, Generic[T]):
+    last_year: T = Field(..., validation_alias="lastYear")
+    this_year: T = Field(..., validation_alias="thisYear")
+    last_month: T = Field(..., validation_alias="lastMonth")
+    this_month: T = Field(..., validation_alias="thisMonth")
+    last_week: T = Field(..., validation_alias="lastWeek")
+    this_week: T = Field(..., validation_alias="thisWeek")
+    all_time: T = Field(..., validation_alias="allTime")
+
+    def get_by_time(self, stats_time: StatsTime) -> T:
+        """Get the stats data by time."""
+        match stats_time:
+            case StatsTime.LastYear:
+                return self.last_year
+            case StatsTime.ThisYear:
+                return self.this_year
+            case StatsTime.LastMonth:
+                return self.last_month
+            case StatsTime.ThisMonth:
+                return self.this_month
+            case StatsTime.LastWeek:
+                return self.last_week
+            case StatsTime.ThisWeek:
+                return self.this_week
+            case StatsTime.AllTime:
+                return self.all_time
+
+
+class StatsResponse(OtfItemBase):
+    all_stats: TimeStats[AllStatsData] = Field(..., validation_alias="allStats")
+    in_studio: TimeStats[InStudioStatsData] = Field(..., validation_alias="inStudio")
+    out_studio: TimeStats[OutStudioStatsData] = Field(..., validation_alias="outStudio")

otf_api/models/workouts/out_of_studio_workout_history.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+
+from pydantic import AliasPath, Field
+
+from otf_api.models.base import OtfItemBase
+
+
+class OutOfStudioWorkoutHistory(OtfItemBase):
+    member_uuid: str = Field(..., validation_alias="memberUUId")
+    workout_uuid: str = Field(..., validation_alias="workoutUUId")
+
+    workout_date: datetime | None = Field(None, validation_alias="workoutDate")
+    start_time: datetime | None = Field(None, validation_alias="startTime")
+    end_time: datetime | None = Field(None, validation_alias="endTime")
+    duration: float | None = None
+    duration_unit: str | None = Field(None, validation_alias="durationUnit")
+    total_calories: int | None = Field(None, validation_alias="totalCalories")
+    hr_percent_max: int | None = Field(None, validation_alias="hrPercentMax")
+    distance_unit: str | None = Field(None, validation_alias="distanceUnit")
+    total_distance: float | None = Field(None, validation_alias="totalDistance")
+    splat_points: int | None = Field(None, validation_alias="splatPoints")
+    target_heart_rate: int | None = Field(None, validation_alias="targetHeartRate")
+    total_steps: int | None = Field(None, validation_alias="totalSteps")
+    has_detailed_data: bool | None = Field(None, validation_alias="hasDetailedData")
+    avg_heartrate: int | None = Field(None, validation_alias="avgHeartrate")
+    max_heartrate: int | None = Field(None, validation_alias="maxHeartrate")
+    workout_type: str | None = Field(None, validation_alias=AliasPath("workoutType", "displayName"))
+    red_zone_seconds: int | None = Field(None, validation_alias="redZoneSeconds")
+    orange_zone_seconds: int | None = Field(None, validation_alias="orangeZoneSeconds")
+    green_zone_seconds: int | None = Field(None, validation_alias="greenZoneSeconds")
+    blue_zone_seconds: int | None = Field(None, validation_alias="blueZoneSeconds")
+    grey_zone_seconds: int | None = Field(None, validation_alias="greyZoneSeconds")