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

otf_api/models/auth.py

@@ -5,13 +5,13 @@ from typing import ClassVar
 from pycognito import Cognito, TokenVerificationException
 from pydantic import Field
 
-from otf_api.models.base import OtfBaseModel
+from otf_api.models.base import OtfItemBase
 
 CLIENT_ID = "65knvqta6p37efc2l3eh26pl5o"  # from otlive
 USER_POOL_ID = "us-east-1_dYDxUeyL1"
 
 
-class IdClaimsData(OtfBaseModel):
+class IdClaimsData(OtfItemBase):
     sub: str
     email_verified: bool
     iss: str
@@ -28,6 +28,7 @@ class IdClaimsData(OtfBaseModel):
     iat: int
     family_name: str
     email: str
+    koji_person_id: str = Field(alias="custom:koji_person_id")
 
     @property
     def member_uuid(self) -> str:
@@ -38,7 +39,7 @@ class IdClaimsData(OtfBaseModel):
         return f"{self.given_name} {self.family_name}"
 
 
-class AccessClaimsData(OtfBaseModel):
+class AccessClaimsData(OtfItemBase):
     sub: str
     device_key: str
     iss: str
@@ -91,18 +92,25 @@ class User:
         self.token_path.write_text(json.dumps(data))
 
     @classmethod
-    def load_from_disk(cls, username: str | None = None, password: str | None = None) -> "User":
+    def cache_file_exists(cls) -> bool:
+        return cls.token_path.exists()
+
+    @classmethod
+    def username_from_disk(cls) -> str:
+        val: str = json.loads(cls.token_path.read_text())["username"]
+        return val
+
+    @classmethod
+    def load_from_disk(cls, username: str, password: str) -> "User":
         """Load a User instance from disk. If the token is invalid, reauthenticate with the provided credentials.
 
         Args:
-            username (str | None): The username to reauthenticate with.
-            password (str | None): The password to reauthenticate with.
+            username (str): The username to reauthenticate with.
+            password (str): The password to reauthenticate with.
 
         Returns:
             User: The loaded user.
 
-        Raises:
-            ValueError: If the token is invalid and no username and password are provided.
         """
         attr_dict = json.loads(cls.token_path.read_text())
 
@@ -111,10 +119,8 @@ class User:
             cognito_user.verify_tokens()
             return cls(cognito=cognito_user)
         except TokenVerificationException:
-            if username and password:
-                user = cls.login(username, password)
-                return user
-            raise
+            user = cls.login(username, password)
+            return user
 
     @classmethod
     def login(cls, username: str, password: str) -> "User":

otf_api/models/base.py

@@ -1,7 +1,210 @@
-from typing import ClassVar
+import inspect
+import typing
+from enum import Enum
+from typing import Any, ClassVar, TypeVar
 
+from box import Box
+from inflection import humanize
 from pydantic import BaseModel, ConfigDict
+from rich.style import Style
+from rich.styled import Styled
+from rich.table import Table
 
+if typing.TYPE_CHECKING:
+    from pydantic.main import IncEx
 
-class OtfBaseModel(BaseModel):
+T = TypeVar("T", bound="OtfItemBase")
+
+
+class BetterDumperMixin:
+    """A better dumper for Pydantic models that includes properties in the dumped data. Must be mixed
+    into a Pydantic model, as it overrides the `model_dump` method.
+
+    Includes support for nested models, and has an option to not include properties when dumping.
+    """
+
+    def get_properties(self) -> list[str]:
+        """Get the properties of the model."""
+        cls = type(self)
+
+        properties: list[str] = []
+        methods = inspect.getmembers(self, lambda f: not (inspect.isroutine(f)))
+        for prop_name, _ in methods:
+            if hasattr(cls, prop_name) and isinstance(getattr(cls, prop_name), property):
+                properties.append(prop_name)
+
+        return properties
+
+    @typing.overload
+    def model_dump(
+        self,
+        *,
+        mode: typing.Literal["json", "python"] | str = "python",
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+        include_properties: bool = True,
+    ) -> Box[str, typing.Any]: ...
+
+    @typing.overload
+    def model_dump(
+        self,
+        *,
+        mode: typing.Literal["json", "python"] | str = "python",
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+        include_properties: bool = False,
+    ) -> dict[str, typing.Any]: ...
+
+    def model_dump(
+        self,
+        *,
+        mode: typing.Literal["json", "python"] | str = "python",
+        include: "IncEx" = None,
+        exclude: "IncEx" = None,
+        by_alias: bool = False,
+        exclude_unset: bool = False,
+        exclude_defaults: bool = False,
+        exclude_none: bool = False,
+        round_trip: bool = False,
+        warnings: bool = True,
+        include_properties: bool = True,
+    ) -> dict[str, typing.Any] | Box[str, typing.Any]:
+        """Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump
+
+        Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
+
+        Args:
+            mode: The mode in which `to_python` should run.
+                If mode is 'json', the dictionary will only contain JSON serializable types.
+                If mode is 'python', the dictionary may contain any Python objects.
+            include: A list of fields to include in the output.
+            exclude: A list of fields to exclude from the output.
+            by_alias: Whether to use the field's alias in the dictionary key if defined.
+            exclude_unset: Whether to exclude fields that are unset or None from the output.
+            exclude_defaults: Whether to exclude fields that are set to their default value from the output.
+            exclude_none: Whether to exclude fields that have a value of `None` from the output.
+            round_trip: Whether to enable serialization and deserialization round-trip support.
+            warnings: Whether to log warnings when invalid fields are encountered.
+            include_properties: Whether to include properties in the dumped data.
+
+        Returns:
+            A dictionary representation of the model. Will be a `Box` if `include_properties` is `True`, otherwise a
+            regular dictionary.
+
+        """
+        dumped_data = typing.cast(BaseModel, super()).model_dump(
+            mode=mode,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            round_trip=round_trip,
+            warnings=warnings,
+        )
+
+        if not include_properties:
+            return dumped_data
+
+        properties = self.get_properties()
+
+        # set properties to their values
+        for prop_name in properties:
+            dumped_data[prop_name] = getattr(self, prop_name)
+
+        # if the property is a Pydantic model, dump it as well
+        for k, v in dumped_data.items():
+            if issubclass(type(getattr(self, k)), BaseModel):
+                dumped_data[k] = getattr(self, k).model_dump()
+            elif hasattr(v, "model_dump"):
+                dumped_data[k] = v.model_dump()
+
+        return Box(dumped_data)
+
+
+class OtfItemBase(BetterDumperMixin, BaseModel):
     model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
+
+    def convert_row_value_types(self, row: list[Any]) -> list[str]:
+        for i, val in enumerate(row):
+            if isinstance(val, bool):
+                row[i] = str(val)
+                continue
+
+            if isinstance(val, Enum):
+                row[i] = val.name
+                continue
+
+            if val is None:
+                row[i] = ""
+                continue
+
+            row[i] = str(val)
+
+        return row
+
+    def get_style(self, is_selected: bool = False) -> Style:
+        return Style(color="blue", bold=True) if is_selected else Style(color="white")
+
+    def to_row(self, attributes: list[str], is_selected: bool = False) -> list[Styled]:
+        style = self.get_style(is_selected)
+
+        boxed_self = Box(self.model_dump(), box_dots=True)
+        row = [boxed_self.get(attr, "") for attr in attributes]
+        row = self.convert_row_value_types(row)
+        styled = [Styled(cell, style=style) for cell in row]
+
+        prefix = "> " if is_selected else "  "
+        styled.insert(0, Styled(prefix, style=style))
+
+        return styled
+
+    @property
+    def sidebar_data(self) -> Table | None:
+        return None
+
+    @classmethod
+    def attr_to_column_header(cls, attr: str) -> str:
+        attr_map = {k: humanize(k) for k in cls.model_fields}
+
+        return attr_map.get(attr, attr)
+
+
+class OtfListBase(BaseModel):
+    model_config: ClassVar[ConfigDict] = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
+    collection_field: ClassVar[str] = "data"
+
+    @property
+    def collection(self) -> list[OtfItemBase]:
+        return getattr(self, self.collection_field)
+
+    def to_table(self, columns: list[str]) -> Table:
+        table = Table(expand=True, show_header=True, show_footer=False)
+
+        table.add_column()
+        for column in columns:
+            table.add_column(OtfItemBase.attr_to_column_header(column))
+
+        for item in self.collection:
+            table.add_row(*item.to_row(columns))
+
+        return table
+
+    def to_json(self, **kwargs) -> str:
+        kwargs.setdefault("indent", 4)
+        kwargs.setdefault("exclude_none", True)
+
+        return self.model_dump_json(**kwargs)

otf_api/models/responses/__init__.py

@@ -1,17 +1,10 @@
-from .bookings import BookingList
+from .book_class import BookClass
+from .bookings import BookingList, BookingStatus
+from .cancel_booking import CancelBooking
 from .challenge_tracker_content import ChallengeTrackerContent
 from .challenge_tracker_detail import ChallengeTrackerDetailList
 from .classes import OtfClassList
-from .enums import (
-    ALL_CLASS_STATUS,
-    ALL_HISTORY_CLASS_STATUS,
-    ALL_STUDIO_STATUS,
-    BookingStatus,
-    ChallengeType,
-    EquipmentType,
-    HistoryClassStatus,
-    StudioStatus,
-)
+from .enums import ChallengeType, EquipmentType, HistoryClassStatus
 from .favorite_studios import FavoriteStudioList
 from .latest_agreement import LatestAgreement
 from .member_detail import MemberDetail
@@ -52,9 +45,8 @@ __all__ = [
     "TelemetryMaxHr",
     "StudioDetail",
     "StudioDetailList",
-    "ALL_CLASS_STATUS",
-    "ALL_HISTORY_CLASS_STATUS",
-    "ALL_STUDIO_STATUS",
     "PerformanceSummaryDetail",
     "PerformanceSummaryList",
+    "BookClass",
+    "CancelBooking",
 ]

otf_api/models/responses/body_composition_list.py

@@ -0,0 +1,304 @@
+import inspect
+from datetime import datetime
+from enum import Enum
+
+import pint
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+ureg = pint.UnitRegistry()
+
+DEFAULT_WEIGHT_DIVIDERS = [55.0, 70.0, 85.0, 100.0, 115.0, 130.0, 145.0, 160.0, 175.0, 190.0, 205.0]
+DEFAULT_SKELETAL_MUSCLE_MASS_DIVIDERS = [70.0, 80.0, 90.0, 100.0, 110.0, 120.0, 130.0, 140.0, 150.0, 160.0, 170.0]
+DEFAULT_BODY_FAT_MASS_DIVIDERS = [40.0, 60.0, 80.0, 100.0, 160.0, 220.0, 280.0, 340.0, 400.0, 460.0, 520.0]
+
+
+class AverageType(str, Enum):
+    BELOW_AVERAGE = "BELOW_AVERAGE"
+    AVERAGE = "AVERAGE"
+    ABOVE_AVERAGE = "ABOVE_AVERAGE"
+    MINIMUM = "MINIMUM"  # unused
+
+
+class BodyFatPercentIndicator(str, Enum):
+    NO_INDICATOR = "NO_INDICATOR"
+    MINIMUM_BODY_FAT = "MINIMUM_BODY_FAT"  # unused
+    LOW_BODY_FAT = "LOW_BODY_FAT"  # unused
+    HEALTHY_BODY_FAT = "HEALTHY_BODY_FAT"
+    GOAL_SETTING_FAT = "GOAL_SETTING_FAT"
+    HIGH_BODY_FAT = "HIGH_BODY_FAT"
+    OBESE_BODY_FAT = "OBESE_BODY_FAT"  # unused
+
+
+class Gender(str, Enum):
+    MALE = "M"
+    FEMALE = "F"
+
+
+def get_percent_body_fat_descriptor(
+    percent_body_fat: float, body_fat_percent_dividers: list[float]
+) -> BodyFatPercentIndicator:
+    if not percent_body_fat or not body_fat_percent_dividers[3]:
+        return BodyFatPercentIndicator.NO_INDICATOR
+
+    if percent_body_fat < body_fat_percent_dividers[1]:
+        return BodyFatPercentIndicator.HEALTHY_BODY_FAT
+
+    if percent_body_fat < body_fat_percent_dividers[2]:
+        return BodyFatPercentIndicator.GOAL_SETTING_FAT
+
+    return BodyFatPercentIndicator.HIGH_BODY_FAT
+
+
+def get_relative_descriptor(in_body_value: float, in_body_dividers: list[float]) -> AverageType:
+    if in_body_value <= in_body_dividers[2]:
+        return AverageType.BELOW_AVERAGE
+
+    if in_body_value <= in_body_dividers[4]:
+        return AverageType.AVERAGE
+
+    return AverageType.ABOVE_AVERAGE
+
+
+def get_body_fat_percent_dividers(age: int, gender: Gender) -> list[float]:
+    if gender == Gender.MALE:
+        return get_body_fat_percent_dividers_male(age)
+
+    return get_body_fat_percent_dividers_female(age)
+
+
+def get_body_fat_percent_dividers_male(age: int) -> list[float]:
+    match age:
+        case age if 0 <= age < 30:
+            return [0.0, 13.1, 21.1, 100.0]
+        case age if 30 <= age < 40:
+            return [0.0, 17.1, 23.1, 100.0]
+        case age if 40 <= age < 50:
+            return [0.0, 20.1, 25.1, 100.0]
+        case age if 50 <= age < 60:
+            return [0.0, 21.1, 26.1, 100.0]
+        case age if 60 <= age < 70:
+            return [0.0, 22.1, 27.1, 100.0]
+        case _:
+            return [0.0, 0.0, 0.0, 0.0]
+
+
+def get_body_fat_percent_dividers_female(age: int) -> list[float]:
+    match age:
+        case age if 0 <= age < 30:
+            return [0.0, 19.1, 26.1, 100.0]
+        case age if 30 <= age < 40:
+            return [0.0, 20.1, 27.1, 100.0]
+        case age if 40 <= age < 50:
+            return [0.0, 22.1, 30.1, 100.0]
+        case age if 50 <= age < 60:
+            return [0.0, 25.1, 32.1, 100.0]
+        case age if 60 <= age < 70:
+            return [0.0, 26.1, 33.1, 100.0]
+        case _:
+            return [0.0, 0.0, 0.0, 0.0]
+
+
+class LeanBodyMass(BaseModel):
+    model_config: ConfigDict = ConfigDict(extra="ignore")
+    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")
+
+
+class LeanBodyMassPercent(BaseModel):
+    model_config: ConfigDict = ConfigDict(extra="ignore")
+    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")
+
+
+class BodyFatMass(BaseModel):
+    model_config: ConfigDict = ConfigDict(extra="ignore")
+    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")
+
+
+class BodyFatMassPercent(BaseModel):
+    model_config: ConfigDict = ConfigDict(extra="ignore")
+    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")
+
+
+class TotalBodyWeight(BaseModel):
+    model_config: ConfigDict = ConfigDict(extra="ignore")
+    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")
+
+
+class IntraCellularWater(BaseModel):
+    model_config: ConfigDict = ConfigDict(extra="ignore")
+    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")
+
+
+class ExtraCellularWater(BaseModel):
+    model_config: ConfigDict = ConfigDict(extra="ignore")
+    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")
+
+
+class ExtraCellularWaterOverTotalBodyWater(BaseModel):
+    model_config: ConfigDict = ConfigDict(extra="ignore")
+    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")
+
+
+class BodyCompositionData(BaseModel):
+    member_uuid: str = Field(..., alias="memberUUId")
+    member_id: str = Field(..., alias="memberId")
+    scan_result_uuid: str = Field(..., alias="scanResultUUId")
+    inbody_id: str = Field(..., alias="id", exclude=True, description="InBody ID, same as email address")
+    email: str
+    height: str = Field(..., description="Height in cm")
+    gender: Gender
+    age: int
+    scan_datetime: datetime = Field(..., alias="testDatetime")
+    provided_weight: float = Field(
+        ..., 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")
+
+    body_fat_mass: float = Field(..., alias="bfm")
+    skeletal_muscle_mass: float = Field(..., alias="smm")
+
+    # excluded because they are only useful for end result of calculations
+    body_fat_mass_dividers: list[float] = Field(..., alias="bfmGraphScale", exclude=True)
+    body_fat_mass_plot_point: float = Field(..., alias="pfatnew", exclude=True)
+    skeletal_muscle_mass_dividers: list[float] = Field(..., alias="smmGraphScale", exclude=True)
+    skeletal_muscle_mass_plot_point: float = Field(..., alias="psmm", exclude=True)
+    weight_dividers: list[float] = Field(..., alias="wtGraphScale", exclude=True)
+    weight_plot_point: float = Field(..., alias="pwt", exclude=True)
+
+    # excluded due to 0 values
+    body_fat_mass_details: BodyFatMass = Field(..., exclude=True)
+    body_fat_mass_percent_details: BodyFatMassPercent = Field(..., exclude=True)
+    total_body_weight_details: TotalBodyWeight = Field(..., exclude=True)
+    intra_cellular_water_details: IntraCellularWater = Field(..., exclude=True)
+    extra_cellular_water_details: ExtraCellularWater = Field(..., exclude=True)
+    extra_cellular_water_over_total_body_water_details: ExtraCellularWaterOverTotalBodyWater = Field(..., exclude=True)
+    visceral_fat_level: float = Field(..., alias="vfl", exclude=True)
+    visceral_fat_area: float = Field(..., alias="vfa", exclude=True)
+    body_comp_measurement: float = Field(..., alias="bcm", exclude=True)
+    total_body_weight_over_lean_body_mass: float = Field(..., alias="tbwOverLBM", exclude=True)
+    intracellular_water: float = Field(..., alias="icw", exclude=True)
+    extracellular_water: float = Field(..., alias="ecw", exclude=True)
+    lean_body_mass_control: float = Field(..., alias="lbmControl", exclude=True)
+
+    def __init__(self, **data):
+        # populate child models
+        child_model_dict = {
+            k: v.annotation
+            for k, v in self.model_fields.items()
+            if inspect.isclass(v.annotation) and issubclass(v.annotation, BaseModel)
+        }
+        for k, v in child_model_dict.items():
+            data[k] = v(**data)
+
+        super().__init__(**data)
+
+    @field_validator("member_id", mode="before")
+    @classmethod
+    def int_to_str(cls, v: int):
+        return str(v)
+
+    @field_validator("skeletal_muscle_mass_dividers", "weight_dividers", "body_fat_mass_dividers", mode="before")
+    @classmethod
+    def convert_dividers_to_float_list(cls, v: str):
+        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):
+        return ureg.Quantity(v, ureg.kilogram).to(ureg.pound).magnitude
+
+    @property
+    def body_fat_mass_relative_descriptor(self) -> AverageType:
+        """Get the relative descriptor for the body fat mass plot point.
+
+        For this item, a lower value is better.
+
+        Returns:
+            AverageType: The relative descriptor for the body fat mass plot point
+        """
+        dividers = self.body_fat_mass_dividers or DEFAULT_BODY_FAT_MASS_DIVIDERS
+        return get_relative_descriptor(self.body_fat_mass_plot_point, dividers)
+
+    @property
+    def skeletal_muscle_mass_relative_descriptor(self) -> AverageType:
+        """Get the relative descriptor for the skeletal muscle mass plot point.
+
+        For this item, a higher value is better.
+
+        Returns:
+            AverageType: The relative descriptor for the skeletal muscle mass plot point
+
+        """
+        dividers = self.skeletal_muscle_mass_dividers or DEFAULT_SKELETAL_MUSCLE_MASS_DIVIDERS
+        return get_relative_descriptor(self.skeletal_muscle_mass_plot_point, dividers)
+
+    @property
+    def weight_relative_descriptor(self) -> AverageType:
+        """Get the relative descriptor for the weight plot point.
+
+        For this item, a lower value is better.
+
+        Returns:
+            AverageType: The relative descriptor for the weight
+        """
+        dividers = self.weight_dividers or DEFAULT_WEIGHT_DIVIDERS
+        return get_relative_descriptor(self.weight_plot_point, dividers)
+
+    @property
+    def body_fat_percent_relative_descriptor(self) -> BodyFatPercentIndicator:
+        """Get the relative descriptor for the percent body fat.
+
+        Returns:
+            BodyFatPercentIndicator: The relative descriptor for the percent body fat
+        """
+        return get_percent_body_fat_descriptor(
+            self.percent_body_fat, get_body_fat_percent_dividers(self.age, self.gender)
+        )
+
+
+class BodyCompositionList(BaseModel):
+    data: list[BodyCompositionData]