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

otf_api/models/lifetime_stats.py

@@ -1,20 +1,20 @@
 from typing import Generic, TypeVar
 
-from pydantic import BaseModel, Field
+from pydantic import Field
 
 from otf_api.models.base import OtfItemBase
 from otf_api.models.enums import StatsTime
 
-T = TypeVar("T", bound=BaseModel)
+T = TypeVar("T", bound=OtfItemBase)
 
 
-class OutStudioMixin(OtfItemBase):
+class OutStudioMixin:
     walking_distance: float | None = Field(None, alias="walkingDistance")
     running_distance: float | None = Field(None, alias="runningDistance")
     cycling_distance: float | None = Field(None, alias="cyclingDistance")
 
 
-class InStudioMixin(OtfItemBase):
+class InStudioMixin:
     treadmill_distance: float | None = Field(None, alias="treadmillDistance")
     treadmill_elevation_gained: float | None = Field(None, alias="treadmillElevationGained")
     rower_distance: float | None = Field(None, alias="rowerDistance")
@@ -72,19 +72,7 @@ class TimeStats(OtfItemBase, Generic[T]):
                 return self.all_time
 
 
-class OutStudioTimeStats(TimeStats[OutStudioStatsData]):
-    pass
-
-
-class InStudioTimeStats(TimeStats[InStudioStatsData]):
-    pass
-
-
-class AllStatsTimeStats(TimeStats[AllStatsData]):
-    pass
-
-
 class StatsResponse(OtfItemBase):
-    all_stats: AllStatsTimeStats = Field(..., alias="allStats")
-    in_studio: InStudioTimeStats = Field(..., alias="inStudio")
-    out_studio: OutStudioTimeStats = Field(..., alias="outStudio")
+    all_stats: TimeStats[AllStatsData] = Field(..., alias="allStats")
+    in_studio: TimeStats[InStudioStatsData] = Field(..., alias="inStudio")
+    out_studio: TimeStats[OutStudioStatsData] = Field(..., alias="outStudio")

otf_api/models/member_detail.py

@@ -7,7 +7,7 @@ from otf_api.models.mixins import AddressMixin
 from otf_api.models.studio_detail import StudioDetail
 
 
-class Address(AddressMixin):
+class Address(AddressMixin, OtfItemBase):
     member_address_uuid: str | None = Field(None, alias="memberAddressUUId", exclude=True, repr=False)
     type: str | None = None
 

otf_api/models/mixins.py

@@ -1,23 +1,29 @@
 from pydantic import AliasChoices, Field, field_validator, model_validator
 
-from otf_api.models.base import OtfItemBase
 
-
-class PhoneLongitudeLatitudeMixin(OtfItemBase):
-    phone_number: str | None = Field(None, alias=AliasChoices("phone", "phoneNumber"))
-    latitude: float | None = Field(None, alias=AliasChoices("latitude"))
-    longitude: float | None = Field(None, alias=AliasChoices("longitude"))
-
-
-class AddressMixin(OtfItemBase):
-    address_line1: str | None = Field(None, alias=AliasChoices("line1", "address1", "address", "physicalAddress"))
-    address_line2: str | None = Field(None, alias=AliasChoices("line2", "address2", "physicalAddress2"))
-    city: str | None = Field(None, alias=AliasChoices("city", "physicalCity", "suburb"))
-    postal_code: str | None = Field(None, alias=AliasChoices("postal_code", "postalCode", "physicalPostalCode"))
-    state: str | None = Field(None, alias=AliasChoices("state", "physicalState", "territory"))
-    country: str | None = Field(None, alias=AliasChoices("country", "physicalCountry"))
-    region: str | None = Field(None, exclude=True, repr=False, alias=AliasChoices("physicalRegion", "region"))
-    country_id: int | None = Field(None, exclude=True, repr=False, alias=AliasChoices("physicalCountryId", "countryId"))
+class PhoneLongitudeLatitudeMixin:
+    phone_number: str | None = Field(None, validation_alias=AliasChoices("phone", "phoneNumber"))
+    latitude: float | None = Field(None, validation_alias=AliasChoices("latitude"))
+    longitude: float | None = Field(None, validation_alias=AliasChoices("longitude"))
+
+
+class AddressMixin:
+    address_line1: str | None = Field(
+        None, validation_alias=AliasChoices("line1", "address1", "address", "physicalAddress")
+    )
+    address_line2: str | None = Field(None, validation_alias=AliasChoices("line2", "address2", "physicalAddress2"))
+    city: str | None = Field(None, validation_alias=AliasChoices("city", "physicalCity", "suburb"))
+    postal_code: str | None = Field(
+        None, validation_alias=AliasChoices("postal_code", "postalCode", "physicalPostalCode")
+    )
+    state: str | None = Field(None, validation_alias=AliasChoices("state", "physicalState", "territory"))
+    country: str | None = Field(None, validation_alias=AliasChoices("country", "physicalCountry"))
+    region: str | None = Field(
+        None, exclude=True, repr=False, validation_alias=AliasChoices("physicalRegion", "region")
+    )
+    country_id: int | None = Field(
+        None, exclude=True, repr=False, validation_alias=AliasChoices("physicalCountryId", "countryId")
+    )
 
     @model_validator(mode="before")
     @classmethod

otf_api/models/out_of_studio_workout_history.py

@@ -24,7 +24,7 @@ class OutOfStudioWorkoutHistory(OtfItemBase):
     has_detailed_data: bool | None = Field(None, alias="hasDetailedData")
     avg_heartrate: int | None = Field(None, alias="avgHeartrate")
     max_heartrate: int | None = Field(None, alias="maxHeartrate")
-    workout_type: str | None = Field(None, alias=AliasPath("workoutType", "displayName"))
+    workout_type: str | None = Field(None, validation_alias=AliasPath("workoutType", "displayName"))
     red_zone_seconds: int | None = Field(None, alias="redZoneSeconds")
     orange_zone_seconds: int | None = Field(None, alias="orangeZoneSeconds")
     green_zone_seconds: int | None = Field(None, alias="greenZoneSeconds")

otf_api/models/performance_summary.py

@@ -1,11 +1,8 @@
-from datetime import datetime, time
-from typing import Any
+from datetime import time
 
 from pydantic import AliasPath, Field, field_validator
 
 from otf_api.models.base import OtfItemBase
-from otf_api.models.enums import ClassType
-from otf_api.models.studio_detail import StudioDetail
 
 
 class ZoneTimeMinutes(OtfItemBase):
@@ -16,18 +13,6 @@ class ZoneTimeMinutes(OtfItemBase):
     red: int
 
 
-class CoachRating(OtfItemBase):
-    id: str
-    description: str
-    value: int
-
-
-class ClassRating(OtfItemBase):
-    id: str
-    description: str
-    value: int
-
-
 class HeartRate(OtfItemBase):
     max_hr: int
     peak_hr: int
@@ -36,14 +21,6 @@ class HeartRate(OtfItemBase):
     avg_hr_percent: int
 
 
-class Class(OtfItemBase):
-    class_uuid: str | None = Field(None, description="Only populated if class is ratable", alias="ot_base_class_uuid")
-    starts_at: datetime | None = Field(None, alias="starts_at_local")
-    type: ClassType | None = None
-    studio: StudioDetail | None = None
-    name: str | None = None
-
-
 class PerformanceMetric(OtfItemBase):
     display_value: time | float
     display_unit: str
@@ -66,7 +43,7 @@ class PerformanceMetric(OtfItemBase):
                 hours, minutes, seconds = value.split(":")
                 return time(hour=int(hours), minute=int(minutes), second=int(seconds))
 
-        return value
+        return value  # type: ignore
 
 
 class BaseEquipment(OtfItemBase):
@@ -91,79 +68,20 @@ class Rower(BaseEquipment):
 
 
 class PerformanceSummary(OtfItemBase):
-    """Represents a workout performance summary - the same data that is shown in the OTF app after a workout"
-
-    This data comes from two different endpoints that do not actually match, because of course not.
-    The summary endpoint returns one distinct set of data plus some detailed data - this is the only place we can get
-    the studio information. The detail endpoint returns more performance data but does not have much class data and does
-    not have the studio.
-
-    * The summary endpoint data is missing step_count, the value is always 0.
-    * The detail endpoint data is missing active_time_seconds, the value is always 0.
-    * The detail endpoint class name is more generic than the summary endpoint class name.
-
+    """Represents a workout performance summary - much of the same data as in the app, but not all.
 
+    You likely want to use the `Workout` model and `get_workouts` method instead.
     """
 
     performance_summary_id: str = Field(..., alias="id", description="Unique identifier for this performance summary")
     class_history_uuid: str = Field(..., alias="id", description="Same as performance_summary_id")
     ratable: bool | None = None
-    otf_class: Class | None = Field(None, alias="class")
-    coach: str | None = Field(None, alias=AliasPath("class", "coach", "first_name"))
-    coach_rating: CoachRating | None = Field(None, alias=AliasPath("ratings", "coach"))
-    class_rating: ClassRating | None = Field(None, alias=AliasPath("ratings", "class"))
-
-    active_time_seconds: int | None = Field(None, alias=AliasPath("details", "active_time_seconds"))
-    calories_burned: int | None = Field(None, alias=AliasPath("details", "calories_burned"))
-    splat_points: int | None = Field(None, alias=AliasPath("details", "splat_points"))
-    step_count: int | None = Field(None, alias=AliasPath("details", "step_count"))
-    zone_time_minutes: ZoneTimeMinutes | None = Field(None, alias=AliasPath("details", "zone_time_minutes"))
-    heart_rate: HeartRate | None = Field(None, alias=AliasPath("details", "heart_rate"))
-
-    rower_data: Rower | None = Field(None, alias=AliasPath("details", "equipment_data", "rower"))
-    treadmill_data: Treadmill | None = Field(None, alias=AliasPath("details", "equipment_data", "treadmill"))
-
-    @property
-    def is_rated(self) -> bool:
-        return self.coach_rating is not None or self.class_rating is not None
-
-    @property
-    def studio(self) -> StudioDetail | None:
-        return self.otf_class.studio if self.otf_class else None
-
-    def __init__(self, **kwargs) -> None:
-        summary_detail = kwargs.pop("details", {}) or {}
-        true_detail = kwargs.pop("detail", {}) or {}
-
-        summary_class = kwargs.pop("class", {})
-        detail_class = true_detail.pop("class", {})
-
-        kwargs["class"] = combine_class_data(summary_class, detail_class)
-        kwargs["details"] = combine_detail_data(summary_detail, true_detail.pop("details", {}))
-
-        super().__init__(**kwargs)
-
-
-def combine_class_data(summary_class: dict[str, str], detail_class: dict[str, str]) -> dict[str, str]:
-    class_data = {}
-
-    class_data["ot_base_class_uuid"] = summary_class.get("ot_base_class_uuid")
-    class_data["starts_at_local"] = summary_class.get("starts_at_local") or detail_class.get("starts_at_local")
-    class_data["type"] = summary_class.get("type")
-    class_data["studio"] = summary_class.get("studio")
-    class_data["name"] = detail_class.get("name") or summary_class.get("name")
-    class_data["coach"] = summary_class.get("coach")
-
-    return class_data
-
-
-def combine_detail_data(summary_detail: dict[str, Any], true_detail: dict[str, Any]) -> dict[str, Any]:
-    # active time seconds always 0 in detail
-    del true_detail["active_time_seconds"]
-
-    # step count always 0 in summary
-    summary_detail["step_count"] = true_detail["step_count"]
 
-    combined_details = summary_detail | true_detail
+    calories_burned: int | None = Field(None, validation_alias=AliasPath("details", "calories_burned"))
+    splat_points: int | None = Field(None, validation_alias=AliasPath("details", "splat_points"))
+    step_count: int | None = Field(None, validation_alias=AliasPath("details", "step_count"))
+    zone_time_minutes: ZoneTimeMinutes | None = Field(None, validation_alias=AliasPath("details", "zone_time_minutes"))
+    heart_rate: HeartRate | None = Field(None, validation_alias=AliasPath("details", "heart_rate"))
 
-    return combined_details
+    rower_data: Rower | None = Field(None, validation_alias=AliasPath("details", "equipment_data", "rower"))
+    treadmill_data: Treadmill | None = Field(None, validation_alias=AliasPath("details", "equipment_data", "treadmill"))

otf_api/models/ratings.py

@@ -0,0 +1,28 @@
+# com/orangetheoryfitness/fragment/rating/RateStatus.java
+
+# we convert these to the new values that the app uses
+# mainly because we don't want to cause any issues with the API and/or with OTF corporate
+# wondering where the old values are coming from
+
+COACH_RATING_MAP = {0: 0, 1: 16, 2: 17, 3: 18}
+CLASS_RATING_MAP = {0: 0, 1: 19, 2: 20, 3: 21}
+
+
+def get_class_rating_value(class_rating: int) -> int:
+    """
+    Convert the class rating from the old values to the new values.
+    """
+    if class_rating not in CLASS_RATING_MAP:
+        raise ValueError(f"Invalid class rating {class_rating}")
+
+    return CLASS_RATING_MAP[class_rating]
+
+
+def get_coach_rating_value(coach_rating: int) -> int:
+    """
+    Convert the coach rating from the old values to the new values.
+    """
+    if coach_rating not in COACH_RATING_MAP:
+        raise ValueError(f"Invalid coach rating {coach_rating}")
+
+    return COACH_RATING_MAP[coach_rating]

otf_api/models/studio_detail.py

@@ -7,10 +7,10 @@ from otf_api.models.enums import StudioStatus
 from otf_api.models.mixins import AddressMixin
 
 
-class StudioLocation(AddressMixin):
-    phone_number: str | None = Field(None, alias=AliasChoices("phone", "phoneNumber"))
-    latitude: float | None = Field(None, alias=AliasChoices("latitude"))
-    longitude: float | None = Field(None, alias=AliasChoices("longitude"))
+class StudioLocation(AddressMixin, OtfItemBase):
+    phone_number: str | None = Field(None, validation_alias=AliasChoices("phone", "phoneNumber"))
+    latitude: float | None = Field(None, validation_alias=AliasChoices("latitude"))
+    longitude: float | None = Field(None, validation_alias=AliasChoices("longitude"))
 
     physical_region: str | None = Field(None, alias="physicalRegion", exclude=True, repr=False)
     physical_country_id: int | None = Field(None, alias="physicalCountryId", exclude=True, repr=False)
@@ -27,7 +27,7 @@ class StudioDetail(OtfItemBase):
         exclude=True,
         repr=False,
     )
-    location: StudioLocation = Field(..., alias="studioLocation", default_factory=StudioLocation)
+    location: StudioLocation = Field(..., alias="studioLocation", default_factory=StudioLocation)  # type: ignore
     name: str | None = Field(None, alias="studioName")
     status: StudioStatus | None = Field(
         None, alias="studioStatus", description="Active, Temporarily Closed, Coming Soon"
@@ -41,13 +41,13 @@ class StudioDetail(OtfItemBase):
     accepts_visa_master_card: bool | None = Field(None, alias="acceptsVisaMasterCard", exclude=True, repr=False)
     allows_cr_waitlist: bool | None = Field(None, alias="allowsCrWaitlist", exclude=True, repr=False)
     allows_dashboard_access: bool | None = Field(None, alias="allowsDashboardAccess", exclude=True, repr=False)
-    is_crm: bool | None = Field(None, alias=AliasPath("studioProfiles", "isCrm"), exclude=True, repr=False)
+    is_crm: bool | None = Field(None, validation_alias=AliasPath("studioProfiles", "isCrm"), exclude=True, repr=False)
     is_integrated: bool | None = Field(
         None, alias="isIntegrated", exclude=True, repr=False, description="Always 'True'"
     )
     is_mobile: bool | None = Field(None, alias="isMobile", exclude=True, repr=False)
     is_otbeat: bool | None = Field(None, alias="isOtbeat", exclude=True, repr=False)
-    is_web: bool | None = Field(None, alias=AliasPath("studioProfiles", "isWeb"), exclude=True, repr=False)
+    is_web: bool | None = Field(None, validation_alias=AliasPath("studioProfiles", "isWeb"), exclude=True, repr=False)
     sms_package_enabled: bool | None = Field(None, alias="smsPackageEnabled", exclude=True, repr=False)
 
     # misc
@@ -62,3 +62,10 @@ class StudioDetail(OtfItemBase):
     studio_physical_location_id: int | None = Field(None, alias="studioPhysicalLocationId", exclude=True, repr=False)
     studio_token: str | None = Field(None, alias="studioToken", exclude=True, repr=False)
     studio_type_id: int | None = Field(None, alias="studioTypeId", exclude=True, repr=False)
+
+    @classmethod
+    def create_empty_model(cls, studio_uuid: str) -> "StudioDetail":
+        """Create an empty model with the given studio_uuid."""
+
+        # pylance doesn't know that the rest of the fields default to None, so we use type: ignore
+        return StudioDetail(studioUUId=studio_uuid, studioName="Studio Not Found", studioStatus="Unknown")  # type: ignore

otf_api/models/telemetry.py

@@ -1,7 +1,7 @@
 from datetime import datetime, timedelta
 from typing import Any
 
-from pydantic import AliasPath, Field
+from pydantic import AliasPath, Field, field_serializer
 
 from otf_api.models.base import OtfItemBase
 
@@ -62,12 +62,22 @@ class Telemetry(OtfItemBase):
     def __init__(self, **data: dict[str, Any]):
         super().__init__(**data)
         for telem in self.telemetry:
+            if self.class_start_time is None:
+                continue
+
             telem.timestamp = self.class_start_time + timedelta(seconds=telem.relative_timestamp)
 
+    @field_serializer("telemetry", when_used="json")
+    def reduce_telemetry_list(self, value: list[TelemetryItem]) -> list[TelemetryItem]:
+        """Reduces the telemetry list to only include the first 10 items."""
+        if len(value) > 10:
+            return value[:5] + value[-5:]
+        return value
+
 
 class TelemetryHistoryItem(OtfItemBase):
-    max_hr_type: str | None = Field(None, alias=AliasPath("maxHr", "type"))
-    max_hr_value: int | None = Field(None, alias=AliasPath("maxHr", "value"))
+    max_hr_type: str | None = Field(None, validation_alias=AliasPath("maxHr", "type"))
+    max_hr_value: int | None = Field(None, validation_alias=AliasPath("maxHr", "value"))
     zones: Zones | None = None
     change_from_previous: int | None = Field(None, alias="changeFromPrevious")
     change_bucket: str | None = Field(None, alias="changeBucket")

otf_api/models/workout.py

@@ -0,0 +1,81 @@
+from pydantic import AliasPath, Field
+
+from otf_api.models.base import OtfItemBase
+from otf_api.models.bookings_v2 import (
+    BookingV2,
+    BookingV2Class,
+    BookingV2Studio,
+    BookingV2Workout,
+    Rating,
+    ZoneTimeMinutes,
+)
+from otf_api.models.performance_summary import HeartRate, Rower, Treadmill
+from otf_api.models.telemetry import Telemetry
+
+
+class Workout(OtfItemBase):
+    """Represents a workout - this combines the performance summary, data from the new bookings endpoint, and
+    telemetry data.
+
+    The final product contains all the performance summary data, the detailed data over time, as well as the class,
+    coach, studio, and rating data from the new endpoint.
+
+    This should match the data that is shown in the OTF app after a workout.
+    """
+
+    performance_summary_id: str = Field(..., alias="id", description="Unique identifier for this performance summary")
+    class_history_uuid: str = Field(..., alias="id", description="Same as performance_summary_id")
+    booking_id: str = Field(..., description="The booking id for the new bookings endpoint.")
+    class_uuid: str | None = Field(
+        None, description="Used by the ratings endpoint - seems to fall off after a few months"
+    )
+    coach: str | None = Field(None, description="First name of the coach")
+
+    ratable: bool | None = None
+
+    calories_burned: int | None = Field(None, validation_alias=AliasPath("details", "calories_burned"))
+    splat_points: int | None = Field(None, validation_alias=AliasPath("details", "splat_points"))
+    step_count: int | None = Field(None, validation_alias=AliasPath("details", "step_count"))
+    zone_time_minutes: ZoneTimeMinutes | None = Field(None, validation_alias=AliasPath("details", "zone_time_minutes"))
+    heart_rate: HeartRate | None = Field(None, validation_alias=AliasPath("details", "heart_rate"))
+    active_time_seconds: int | None = None
+
+    rower_data: Rower | None = Field(None, validation_alias=AliasPath("details", "equipment_data", "rower"))
+    treadmill_data: Treadmill | None = Field(None, validation_alias=AliasPath("details", "equipment_data", "treadmill"))
+
+    class_rating: Rating | None = None
+    coach_rating: Rating | None = None
+
+    otf_class: BookingV2Class
+    studio: BookingV2Studio
+    telemetry: Telemetry | None = None
+
+    def __init__(self, **data):
+        v2_booking = data.get("v2_booking")
+        if not v2_booking:
+            raise ValueError("v2_booking is required")
+
+        assert isinstance(v2_booking, BookingV2), "v2_booking must be an instance of BookingV2"
+
+        otf_class = v2_booking.otf_class
+        v2_workout = v2_booking.workout
+        assert isinstance(otf_class, BookingV2Class), "otf_class must be an instance of BookingV2Class"
+        assert isinstance(v2_workout, BookingV2Workout), "v2_workout must be an instance of BookingV2Workout"
+
+        data["otf_class"] = otf_class
+        data["studio"] = otf_class.studio
+        data["coach"] = otf_class.coach
+        data["ratable"] = v2_booking.ratable  # this seems to be more accurate
+
+        data["booking_id"] = v2_booking.booking_id
+        data["active_time_seconds"] = v2_workout.active_time_seconds
+        data["class_rating"] = v2_booking.class_rating
+        data["coach_rating"] = v2_booking.coach_rating
+
+        telemetry = data.get("telemetry")
+        if telemetry and isinstance(telemetry, Telemetry):
+            # max_hr seems to be left out of the heart rate data - it has peak_hr but they do not match
+            # so if we have telemetry data, we can get the max_hr from there
+            data["details"]["heart_rate"]["max_hr"] = telemetry.max_hr
+
+        super().__init__(**data)

otf_api/utils.py

@@ -8,13 +8,12 @@ from typing import Any
 import attrs
 
 if typing.TYPE_CHECKING:
-    from otf_api.models.bookings import Booking
-    from otf_api.models.classes import OtfClass
+    from otf_api import models
 
 LOGGER = getLogger(__name__)
 
 
-def get_booking_uuid(booking_or_uuid: "str | Booking") -> str:
+def get_booking_uuid(booking_or_uuid: "str | models.Booking") -> str:
     from otf_api.models.bookings import Booking
 
     if isinstance(booking_or_uuid, str):
@@ -26,16 +25,29 @@ def get_booking_uuid(booking_or_uuid: "str | Booking") -> str:
     raise ValueError(f"Expected Booking or str, got {type(booking_or_uuid)}")
 
 
-def get_class_uuid(class_or_uuid: "str | OtfClass") -> str:
-    from otf_api.models.classes import OtfClass
+def get_booking_id(booking_or_id: "str | models.BookingV2") -> str:
+    from otf_api.models.bookings_v2 import BookingV2
+
+    if isinstance(booking_or_id, str):
+        return booking_or_id
+
+    if isinstance(booking_or_id, BookingV2):
+        return booking_or_id.booking_id
+
+    raise ValueError(f"Expected BookingV2 or str, got {type(booking_or_id)}")
 
+
+def get_class_uuid(class_or_uuid: "str | models.OtfClass | models.BookingV2Class") -> str:
     if isinstance(class_or_uuid, str):
         return class_or_uuid
 
-    if isinstance(class_or_uuid, OtfClass):
-        return class_or_uuid.class_uuid
+    if hasattr(class_or_uuid, "class_uuid"):
+        class_uuid = getattr(class_or_uuid, "class_uuid", None)
+        if class_uuid:
+            return class_uuid
+        raise ValueError("Class does not have a class_uuid")
 
-    raise ValueError(f"Expected OtfClass or str, got {type(class_or_uuid)}")
+    raise ValueError(f"Expected OtfClass, BookingV2Class, or str, got {type(class_or_uuid)}")
 
 
 def ensure_list(obj: list | Any | None) -> list:
@@ -46,6 +58,22 @@ def ensure_list(obj: list | Any | None) -> list:
     return obj
 
 
+def ensure_datetime(date_str: str | datetime | None) -> datetime | None:
+    if not date_str:
+        return None
+
+    if isinstance(date_str, str):
+        return datetime.fromisoformat(date_str)
+
+    if isinstance(date_str, datetime):
+        return date_str
+
+    if isinstance(date_str, date):
+        return datetime.combine(date_str, datetime.min.time())
+
+    raise ValueError(f"Expected str or datetime, got {type(date_str)}")
+
+
 def ensure_date(date_str: str | date | None) -> date | None:
     if not date_str:
         return None

{otf_api-0.10.2.dist-info → otf_api-0.11.1.dist-info}/METADATA

@@ -1,36 +1,33 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: otf-api
-Version: 0.10.2
+Version: 0.11.1
 Summary: Python OrangeTheory Fitness API Client
-License: MIT
-Author: Jessica Smith
-Author-email: j.smith.git1@gmail.com
-Requires-Python: >=3.11,<4.0
+Author-email: Jessica Smith <j.smith.git1@gmail.com>
+License-Expression: MIT
+Project-URL: Documentation, https://otf-api.readthedocs.io/en/stable/
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Internet :: WWW/HTTP
-Classifier: Topic :: Software Development :: Libraries
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: attrs (>=24.3.0,<25.0.0)
-Requires-Dist: cachetools (>=5.5.0)
-Requires-Dist: httpx (>=0.27.2)
-Requires-Dist: humanize (>=4.9.0,<5.0.0)
-Requires-Dist: inflection (==0.5.*)
-Requires-Dist: mypy-boto3-cognito-idp (>=1.35.93,<2.0.0)
-Requires-Dist: pint (==0.24.*)
-Requires-Dist: pycognito (==2024.5.1)
-Requires-Dist: pydantic (>=2.7.3)
-Requires-Dist: tenacity (>=9.0.0,<10.0.0)
-Requires-Dist: yarl (>=1.18.3,<2.0.0)
-Project-URL: Documentation, https://otf-api.readthedocs.io/en/stable/
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: attrs<25,>=24.3.0
+Requires-Dist: httpx>=0.27.2
+Requires-Dist: humanize<5,>=4.9.0
+Requires-Dist: inflection==0.5.*
+Requires-Dist: pint==0.24.*
+Requires-Dist: pycognito==2024.5.1
+Requires-Dist: pydantic>=2.7.3
+Requires-Dist: yarl<2,>=1.18.3
+Requires-Dist: tenacity<10,>=9.0.0
+Requires-Dist: cachetools>=5.5.0
+Requires-Dist: pendulum>=3.1.0
+Dynamic: license-file
 
 Simple API client for interacting with the OrangeTheory Fitness APIs.
 
@@ -62,4 +59,3 @@ otf = Otf()
 otf = Otf(user=OtfUser(<email_address>,<password>))
 
 ```
-

otf_api-0.11.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+otf_api/__init__.py,sha256=VlLjNep7gdvPfnIDl1YbY8uY5eRM1vE4XJvNhI4mIB8,205
+otf_api/api.py,sha256=95qIszuc2zjneEk-VhS9e-F5f2EnUs4lHGehL7rU2G4,67511
+otf_api/exceptions.py,sha256=GISekwF5dPt0Ol0WCU55kE5ODc5VxicNEEhmlguuE0U,1815
+otf_api/filters.py,sha256=fk2bFGi3srjS96qZlaDx-ARZRaj93NUTUdMJ01TX420,3702
+otf_api/logging.py,sha256=PRZpCaJ1F1Xya3L9Efkt3mKS5_QNr3sXjEUERSxYjvE,563
+otf_api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+otf_api/utils.py,sha256=TATPgb5-t3nEAqo_iGY2p2PKzJA564alN1skb23OCMQ,4817
+otf_api/auth/__init__.py,sha256=PuhtiZ02GVP8zVSn1O-fhaYm7JM_tq5yUFATk_-8upk,132
+otf_api/auth/auth.py,sha256=5cPELC9Soif5knDDHm55ii1OMEPkJlGUphAdbOEmaRo,13278
+otf_api/auth/user.py,sha256=XlK3nbqJA4fF5UFmw2tt0eAle4QOQd6trnW72QrBsx4,2681
+otf_api/auth/utils.py,sha256=vc2pEyU-3yKdv0mR6r_zSHZyMw92j5UeIN_kzcb6TeE,2909
+otf_api/models/__init__.py,sha256=MSinaMQaBTGscL-YRKJ3axFiItQ1HoH62wC2xdaBMgk,1876
+otf_api/models/base.py,sha256=KJlIxl_sRj6f-g5vKYPw4yV6fGDk-fwZ93EO0JGPYMw,202
+otf_api/models/body_composition_list.py,sha256=jGdR-9ScvIOtULJNB99aYh2INk2ihoHAnTWtbQCIea4,12202
+otf_api/models/bookings.py,sha256=Lj-IHN1k-w4vF-5aIKbsiQ6Uq-I5_ELoPUKXPGkfbgM,4440
+otf_api/models/bookings_v2.py,sha256=9HyXGnDNDmIqmr4r0_3pR1mFtN_Lfp9nP-4bCiwe5QA,5865
+otf_api/models/challenge_tracker_content.py,sha256=5Ucu1n4W15v1rzhoXNvAD9tCSg3JTUiR92HHiDAxRec,2597
+otf_api/models/challenge_tracker_detail.py,sha256=c2Ds7Kv2-VaPtxoXSUTI5zrmU1A1dcSaM1UIolwSVxU,4323
+otf_api/models/classes.py,sha256=aKV6LGEh0YiPxyOaoMD0gaQOSHqs69cYHhP9H_2p_jY,3051
+otf_api/models/enums.py,sha256=6P7wOYwvZkBLfNckKaNWv6Po94yg6lq0qyNNNOSqEFg,4633
+otf_api/models/lifetime_stats.py,sha256=qpPCJuL68KhEbsIZ6cTx1dhh7RzDH5xWEAnLIsq8mZE,2853
+otf_api/models/member_detail.py,sha256=UzUttKuF_P3bvzEy_ZXBwDVwj52JtpDhGuPuAtQqT0I,6611
+otf_api/models/member_membership.py,sha256=jZwHzwtVyMUr8dWGlFbMYj9qveCbiOblWW5szXDUFFo,1338
+otf_api/models/member_purchases.py,sha256=Ne7ByEbGTqTJhuEyCgywWe8I3nc-D46qw09up7ys38s,1627
+otf_api/models/mixins.py,sha256=RBuAvAN1lYQpas0brACBof-6R4EqwGJL8HWHt41eQNg,2368
+otf_api/models/notifications.py,sha256=AkmIfiIiU6wox_7puyenbhCX10SFvBD5eBAovcurRgY,833
+otf_api/models/out_of_studio_workout_history.py,sha256=Kjkb8HW7k0qGMW3rAKXxZQju4MYglmmSRUdRx6FW_MQ,1714
+otf_api/models/performance_summary.py,sha256=vUQJum2lW6zHnYMOvdWwClWwrIwef6WojfKqyXUxTno,2914
+otf_api/models/ratings.py,sha256=RVsOGqx_eaB5i60pMRNR4xqYkQZhwRrLeSvmcFEDTgw,934
+otf_api/models/studio_detail.py,sha256=2gq0A27NOZGz_PTBvsB-dkzm01nYc9FHmx1NON6xp6U,4187
+otf_api/models/studio_services.py,sha256=aGLQMQmjGVpI6YxzAl-mcp3Y9cHPXuH9dIqrl6E-78E,1665
+otf_api/models/telemetry.py,sha256=PQ_CbADW5-t-U2iEQJGugNy-c4rD0q76TfyIqeFnTho,3170
+otf_api/models/workout.py,sha256=P3xVTvcYrm_RdU6qi3Xm2BXTxxvhvF0dgoEcODY41AA,3678
+otf_api-0.11.1.dist-info/licenses/LICENSE,sha256=UaPT9ynYigC3nX8n22_rC37n-qmTRKLFaHrtUwF9ktE,1071
+otf_api-0.11.1.dist-info/METADATA,sha256=BEppb5v_YlMUirZck7aKOtVkTemE7Uvantq2Gk8_00Y,2145
+otf_api-0.11.1.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+otf_api-0.11.1.dist-info/top_level.txt,sha256=KAhYg1X2YG0LkTuVRhUV1I_AReNZUVNdEan7cp0pEE4,8
+otf_api-0.11.1.dist-info/RECORD,,

{otf_api-0.10.2.dist-info → otf_api-0.11.1.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.2
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

otf_api-0.11.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+otf_api