otf-api 0.8.2__py3-none-any.whl → 0.9.1__py3-none-any.whl

otf_api/models/performance_summary_detail.py

@@ -1,4 +1,6 @@
-from pydantic import Field
+from datetime import datetime, time
+
+from pydantic import AliasPath, Field, field_validator
 
 from otf_api.models.base import OtfItemBase
 
@@ -19,61 +21,64 @@ class HeartRate(OtfItemBase):
     avg_hr_percent: int
 
 
-class PerformanceMetricFloat(OtfItemBase):
-    display_value: float
+class PerformanceMetric(OtfItemBase):
+    display_value: time | float
     display_unit: str
     metric_value: float
 
+    @field_validator("display_value", mode="before")
+    @classmethod
+    def convert_to_time_format(cls, value) -> time | float:
+        if not value:
+            return value
 
-class PerformanceMetricString(OtfItemBase):
-    display_value: str
-    display_unit: str
-    metric_value: str
+        if isinstance(value, float | int):
+            return value
+
+        if isinstance(value, str) and ":" in value:
+            if value.count(":") == 1:
+                minutes, seconds = value.split(":")
+                return time(minute=int(minutes), second=int(seconds))
+            if value.count(":") == 2:
+                hours, minutes, seconds = value.split(":")
+                return time(hour=int(hours), minute=int(minutes), second=int(seconds))
+
+        return value
 
 
 class BaseEquipment(OtfItemBase):
-    avg_pace: PerformanceMetricString
-    avg_speed: PerformanceMetricFloat
-    max_pace: PerformanceMetricString
-    max_speed: PerformanceMetricFloat
-    moving_time: PerformanceMetricString
-    total_distance: PerformanceMetricFloat
+    avg_pace: PerformanceMetric
+    avg_speed: PerformanceMetric
+    max_pace: PerformanceMetric
+    max_speed: PerformanceMetric
+    moving_time: PerformanceMetric
+    total_distance: PerformanceMetric
 
 
 class Treadmill(BaseEquipment):
-    avg_incline: PerformanceMetricFloat
-    elevation_gained: PerformanceMetricFloat
-    max_incline: PerformanceMetricFloat
+    avg_incline: PerformanceMetric
+    elevation_gained: PerformanceMetric
+    max_incline: PerformanceMetric
 
 
 class Rower(BaseEquipment):
-    avg_cadence: PerformanceMetricFloat
-    avg_power: PerformanceMetricFloat
-    max_cadence: PerformanceMetricFloat
-
-
-class EquipmentData(OtfItemBase):
-    treadmill: Treadmill
-    rower: Rower
-
-
-class Details(OtfItemBase):
-    calories_burned: int
-    splat_points: int
-    step_count: int
-    active_time_seconds: int
-    zone_time_minutes: ZoneTimeMinutes
-    heart_rate: HeartRate
-    equipment_data: EquipmentData
-
-
-class Class(OtfItemBase):
-    starts_at_local: str
-    name: str
+    avg_cadence: PerformanceMetric
+    avg_power: PerformanceMetric
+    max_cadence: PerformanceMetric
 
 
 class PerformanceSummaryDetail(OtfItemBase):
     id: str
-    details: Details
-    ratable: bool
-    otf_class: Class = Field(..., alias="class")
+    class_name: str | None = Field(None, alias=AliasPath("class", "name"))
+    class_starts_at: datetime | None = Field(None, alias=AliasPath("class", "starts_at_local"))
+
+    ratable: bool | None = None
+    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"))
+    active_time_seconds: int | None = Field(None, alias=AliasPath("details", "active_time_seconds"))
+    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"))

otf_api/models/performance_summary_list.py

@@ -1,4 +1,6 @@
-from pydantic import Field
+from datetime import datetime
+
+from pydantic import AliasPath, Field
 
 from otf_api.models.base import OtfItemBase
 
@@ -11,32 +13,11 @@ class ZoneTimeMinutes(OtfItemBase):
     red: int
 
 
-class Details(OtfItemBase):
-    calories_burned: int
-    splat_points: int
-    step_count: int
-    active_time_seconds: int
-    zone_time_minutes: ZoneTimeMinutes
-
-
-class Coach(OtfItemBase):
-    image_url: str | None = None
-    first_name: str
-
-
-class Studio(OtfItemBase):
-    id: str
-    license_number: str
-    name: str
-
-
 class Class(OtfItemBase):
-    ot_base_class_uuid: str | None = None
-    starts_at_local: str
+    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")
     name: str | None = None
     type: str | None = None
-    coach: Coach
-    studio: Studio
 
 
 class CoachRating(OtfItemBase):
@@ -51,18 +32,19 @@ class ClassRating(OtfItemBase):
     value: int
 
 
-class Ratings(OtfItemBase):
-    coach: CoachRating
-    otf_class: ClassRating = Field(..., alias="class")
-
-
 class PerformanceSummaryEntry(OtfItemBase):
     id: str = Field(..., alias="id")
-    details: Details
-    ratable: bool
-    otf_class: Class = Field(..., alias="class")
-    ratings: Ratings | None = None
-
-
-class PerformanceSummaryList(OtfItemBase):
-    summaries: list[PerformanceSummaryEntry]
+    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"))
+    active_time_seconds: int | None = Field(None, alias=AliasPath("details", "active_time_seconds"))
+    zone_time_minutes: ZoneTimeMinutes | None = Field(None, alias=AliasPath("details", "zone_time_minutes"))
+    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"))
+
+    @property
+    def is_rated(self) -> bool:
+        return self.coach_rating is not None or self.class_rating is not None

otf_api/models/studio_detail.py

@@ -1,109 +1,62 @@
 from datetime import datetime
 
-from pydantic import Field
+from pydantic import AliasChoices, AliasPath, Field
 
 from otf_api.models.base import OtfItemBase
+from otf_api.models.enums import StudioStatus
+from otf_api.models.mixins import AddressMixin
 
 
-class Country(OtfItemBase):
-    country_id: int = Field(..., alias="countryId")
-    country_currency_code: str | None = Field(None, alias="countryCurrencyCode")
-    country_currency_name: str | None = Field(None, alias="countryCurrencyName")
-    currency_alphabetic_code: str | None = Field(None, alias="currencyAlphabeticCode")
+class StudioLocation(AddressMixin):
+    phone_number: str | None = Field(None, alias=AliasChoices("phone", "phoneNumber"))
+    latitude: float = Field(..., alias=AliasChoices("latitude"))
+    longitude: float = Field(..., alias=AliasChoices("longitude"))
 
-
-class StudioLocation(OtfItemBase):
-    physical_address: str | None = Field(None, alias="physicalAddress")
-    physical_address2: str | None = Field(None, alias="physicalAddress2")
-    physical_city: str | None = Field(None, alias="physicalCity")
-    physical_state: str | None = Field(None, alias="physicalState")
-    physical_postal_code: str | None = Field(None, alias="physicalPostalCode")
-    physical_region: str | None = Field(None, alias="physicalRegion", exclude=True)
-    physical_country: str | None = Field(None, alias="physicalCountry", exclude=True)
-    country: Country | None = Field(None, exclude=True)
-    phone_number: str | None = Field(None, alias="phoneNumber")
-    latitude: float | None = Field(None, exclude=True)
-    longitude: float | None = Field(None, exclude=True)
-
-
-class Language(OtfItemBase):
-    language_id: None = Field(None, alias="languageId")
-    language_code: None = Field(None, alias="languageCode")
-    language_name: None = Field(None, alias="languageName")
-
-
-class StudioLocationLocalized(OtfItemBase):
-    language: Language | None = Field(None, exclude=True)
-    studio_name: str | None = Field(None, alias="studioName")
-    studio_address: str | None = Field(None, alias="studioAddress")
-
-
-class StudioProfiles(OtfItemBase):
-    is_web: bool | None = Field(None, alias="isWeb")
-    intro_capacity: int | None = Field(None, alias="introCapacity")
-    is_crm: bool | None = Field(None, alias="isCrm")
-
-
-class SocialMediaLink(OtfItemBase):
-    id: str
-    language_id: str | None = Field(None, alias="languageId")
-    name: str
-    value: str
+    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)
 
 
 class StudioDetail(OtfItemBase):
-    studio_id: int = Field(..., alias="studioId", exclude=True)
-    studio_uuid: str = Field(..., alias="studioUUId")
-    studio_location_localized: StudioLocationLocalized | None = Field(
-        None, alias="studioLocationLocalized", exclude=True
-    )
-    studio_location: StudioLocation | None = Field(None, alias="studioLocation")
-    studio_name: str | None = Field(None, alias="studioName")
-    studio_number: str | None = Field(None, alias="studioNumber", exclude=True)
-    studio_physical_location_id: int | None = Field(None, alias="studioPhysicalLocationId", exclude=True)
-    studio_profiles: StudioProfiles | None = Field(None, alias="studioProfiles", exclude=True)
-    studio_status: str | None = Field(None, alias="studioStatus", exclude=True)
-    studio_token: str | None = Field(None, alias="studioToken", exclude=True)
-    studio_type_id: int | None = Field(None, alias="studioTypeId", exclude=True)
-    studio_version: str | None = Field(None, alias="studioVersion", exclude=True)
-    mbo_studio_id: int | None = Field(None, alias="mboStudioId", exclude=True)
-    accepts_ach: bool | None = Field(None, alias="acceptsAch", exclude=True)
-    accepts_american_express: bool | None = Field(None, alias="acceptsAmericanExpress", exclude=True)
-    accepts_discover: bool | None = Field(None, alias="acceptsDiscover", exclude=True)
-    accepts_visa_master_card: bool | None = Field(None, alias="acceptsVisaMasterCard", exclude=True)
-    allows_cr_waitlist: bool | None = Field(None, alias="allowsCrWaitlist", exclude=True)
-    allows_dashboard_access: bool | None = Field(None, alias="allowsDashboardAccess", exclude=True)
-    area_id: int | None = Field(None, alias="areaId", exclude=True)
-    commission_percent: int | None = Field(None, alias="commissionPercent", exclude=True)
-    contact_email: str | None = Field(None, alias="contactEmail", exclude=True)
-    cr_waitlist_flag_last_updated: datetime | None = Field(None, alias="crWaitlistFlagLastUpdated", exclude=True)
-    description: str | None = Field(None, exclude=True)
-    distance: float | None = Field(None, exclude=True)
-    environment: str | None = Field(None, exclude=True)
-    is_integrated: bool | None = Field(None, alias="isIntegrated", exclude=True)
-    is_mobile: bool | None = Field(None, alias="isMobile", exclude=True)
-    is_otbeat: bool | None = Field(None, alias="isOtbeat", exclude=True)
-    logo_url: str | None = Field(None, alias="logoUrl", exclude=True)
-    market_id: int | None = Field(None, alias="marketId", exclude=True)
-    marketing_fund_rate: int | None = Field(None, alias="marketingFundRate", exclude=True)
-    open_date: datetime | None = Field(None, alias="openDate", exclude=True)
-    pos_type_id: int | None = Field(None, alias="posTypeId", exclude=True)
-    pricing_level: str | None = Field(None, alias="pricingLevel", exclude=True)
-    re_open_date: datetime | None = Field(None, alias="reOpenDate", exclude=True)
-    royalty_rate: int | None = Field(None, alias="royaltyRate", exclude=True)
-    sms_package_enabled: bool | None = Field(None, alias="smsPackageEnabled", exclude=True)
-    social_media_links: list[SocialMediaLink] | None = Field(None, alias="socialMediaLinks", exclude=True)
-    state_id: int | None = Field(None, alias="stateId", exclude=True)
-    tax_rate: str | None = Field(None, alias="taxRate", exclude=True)
-    time_zone: str | None = Field(None, alias="timeZone", exclude=True)
-
-
-class Pagination(OtfItemBase):
-    page_index: int | None = Field(None, alias="pageIndex")
-    page_size: int | None = Field(None, alias="pageSize")
-    total_count: int | None = Field(None, alias="totalCount")
-    total_pages: int | None = Field(None, alias="totalPages")
-
+    studio_uuid: str = Field(..., alias="studioUUId", description="The OTF studio UUID")
 
-class StudioDetailList(OtfItemBase):
-    studios: list[StudioDetail]
+    contact_email: str | None = Field(None, alias="contactEmail")
+    distance: float | None = Field(
+        None,
+        description="Distance from latitude and longitude provided to `search_studios_by_geo` method,\
+              NULL if that method was not used",
+    )
+    location: StudioLocation = Field(..., alias="studioLocation")
+    name: str | None = Field(None, alias="studioName")
+    status: StudioStatus | None = Field(
+        None, alias="studioStatus", description="Active, Temporarily Closed, Coming Soon"
+    )
+    time_zone: str | None = Field(None, alias="timeZone")
+
+    # flags
+    accepts_ach: bool | None = Field(None, alias="acceptsAch", exclude=True, repr=False)
+    accepts_american_express: bool | None = Field(None, alias="acceptsAmericanExpress", exclude=True, repr=False)
+    accepts_discover: bool | None = Field(None, alias="acceptsDiscover", exclude=True, repr=False)
+    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_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)
+    sms_package_enabled: bool | None = Field(None, alias="smsPackageEnabled", exclude=True, repr=False)
+
+    # misc
+    studio_id: int | None = Field(None, alias="studioId", description="Not used by API", exclude=True, repr=False)
+    mbo_studio_id: int | None = Field(None, alias="mboStudioId", exclude=True, repr=False, description="MindBody attr")
+    open_date: datetime | None = Field(None, alias="openDate", exclude=True, repr=False)
+    pricing_level: str | None = Field(
+        None, alias="pricingLevel", exclude=True, repr=False, description="Pro, Legacy, Accelerate, or empty"
+    )
+    re_open_date: datetime | None = Field(None, alias="reOpenDate", exclude=True, repr=False)
+    studio_number: str | None = Field(None, alias="studioNumber", exclude=True, repr=False)
+    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)

otf_api/models/studio_services.py

@@ -3,55 +3,34 @@ from datetime import datetime
 from pydantic import Field
 
 from otf_api.models.base import OtfItemBase
-
-
-class Currency(OtfItemBase):
-    currency_alphabetic_code: str = Field(..., alias="currencyAlphabeticCode")
-
-
-class DefaultCurrency(OtfItemBase):
-    currency_id: int = Field(..., alias="currencyId")
-    currency: Currency
-
-
-class Country(OtfItemBase):
-    country_currency_code: str = Field(..., alias="countryCurrencyCode")
-    default_currency: DefaultCurrency = Field(..., alias="defaultCurrency")
-
-
-class StudioLocation(OtfItemBase):
-    studio_location_id: int = Field(..., alias="studioLocationId")
-    country: Country
-
-
-class Studio(OtfItemBase):
-    studio_id: int = Field(..., alias="studioId")
-    studio_location: StudioLocation = Field(..., alias="studioLocation")
+from otf_api.models.studio_detail import StudioDetail
 
 
 class StudioService(OtfItemBase):
-    service_id: int = Field(..., alias="serviceId")
+    studio: StudioDetail = Field(..., exclude=True, repr=False)
     service_uuid: str = Field(..., alias="serviceUUId")
-    studio_id: int = Field(..., alias="studioId")
-    name: str
-    price: str
-    qty: int
-    mbo_program_id: int = Field(..., alias="mboProgramId")
-    mbo_description_id: str = Field(..., alias="mboDescriptionId")
-    mbo_product_id: int = Field(..., alias="mboProductId")
-    online_price: str = Field(..., alias="onlinePrice")
-    tax_rate: str = Field(..., alias="taxRate")
-    current: bool
-    is_web: bool = Field(..., alias="isWeb")
-    is_crm: bool = Field(..., alias="isCrm")
-    is_mobile: bool = Field(..., alias="isMobile")
-    created_by: str = Field(..., alias="createdBy")
-    created_date: datetime = Field(..., alias="createdDate")
-    updated_by: str = Field(..., alias="updatedBy")
-    updated_date: datetime = Field(..., alias="updatedDate")
-    is_deleted: bool = Field(..., alias="isDeleted")
-    studio: Studio
-
-
-class StudioServiceList(OtfItemBase):
-    data: list[StudioService]
+    name: str | None = None
+    price: str | None = None
+    qty: int | None = None
+    online_price: str | None = Field(None, alias="onlinePrice")
+    tax_rate: str | None = Field(None, alias="taxRate")
+    current: bool | None = None
+    is_deleted: bool | None = Field(None, alias="isDeleted")
+    created_date: datetime | None = Field(None, alias="createdDate")
+    updated_date: datetime | None = Field(None, alias="updatedDate")
+
+    # unused fields
+
+    # ids
+    mbo_program_id: int | None = Field(None, alias="mboProgramId", exclude=True, repr=False)
+    mbo_description_id: str | None = Field(None, alias="mboDescriptionId", exclude=True, repr=False)
+    mbo_product_id: int | None = Field(None, alias="mboProductId", exclude=True, repr=False)
+    service_id: int | None = Field(None, alias="serviceId", exclude=True, repr=False)
+    studio_id: int | None = Field(None, alias="studioId", exclude=True, repr=False)
+    created_by: str | None = Field(None, alias="createdBy", exclude=True, repr=False)
+    updated_by: str | None = Field(None, alias="updatedBy", exclude=True, repr=False)
+
+    # flags
+    is_web: bool | None = Field(None, alias="isWeb", exclude=True, repr=False)
+    is_crm: bool | None = Field(None, alias="isCrm", exclude=True, repr=False)
+    is_mobile: bool | None = Field(None, alias="isMobile", exclude=True, repr=False)

otf_api/models/telemetry.py

@@ -1,7 +1,7 @@
 from datetime import datetime, timedelta
 from typing import Any
 
-from pydantic import Field
+from pydantic import AliasPath, Field
 
 from otf_api.models.base import OtfItemBase
 
@@ -50,13 +50,22 @@ class TelemetryItem(OtfItemBase):
 class Telemetry(OtfItemBase):
     member_uuid: str = Field(..., alias="memberUuid")
     class_history_uuid: str = Field(..., alias="classHistoryUuid")
-    class_start_time: datetime = Field(..., alias="classStartTime")
-    max_hr: int = Field(..., alias="maxHr")
+    class_start_time: datetime | None = Field(None, alias="classStartTime")
+    max_hr: int | None = Field(None, alias="maxHr")
     zones: Zones
-    window_size: int = Field(..., alias="windowSize")
-    telemetry: list[TelemetryItem]
+    window_size: int | None = Field(None, alias="windowSize")
+    telemetry: list[TelemetryItem] = Field(default_factory=list)
 
     def __init__(self, **data: dict[str, Any]):
         super().__init__(**data)
         for telem in self.telemetry:
             telem.timestamp = self.class_start_time + timedelta(seconds=telem.relative_timestamp)
+
+
+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"))
+    zones: Zones | None = None
+    change_from_previous: int | None = Field(None, alias="changeFromPrevious")
+    change_bucket: str | None = Field(None, alias="changeBucket")
+    assigned_at: datetime | None = Field(None, alias="assignedAt")

otf_api/utils.py

@@ -0,0 +1,134 @@
+import json
+import typing
+from datetime import date, datetime
+from logging import getLogger
+from pathlib import Path
+from typing import Any
+
+import attrs
+
+if typing.TYPE_CHECKING:
+    from otf_api.models.bookings import Booking
+    from otf_api.models.classes import OtfClass
+
+LOGGER = getLogger(__name__)
+
+
+def get_booking_uuid(booking_or_uuid: "str | Booking") -> str:
+    from otf_api.models.bookings import Booking
+
+    if isinstance(booking_or_uuid, str):
+        return booking_or_uuid
+
+    if isinstance(booking_or_uuid, Booking):
+        return booking_or_uuid.booking_uuid
+
+    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
+
+    if isinstance(class_or_uuid, str):
+        return class_or_uuid
+
+    if isinstance(class_or_uuid, OtfClass):
+        return class_or_uuid.class_uuid
+
+    raise ValueError(f"Expected OtfClass or str, got {type(class_or_uuid)}")
+
+
+def ensure_list(obj: list | Any | None) -> list:
+    if obj is None:
+        return []
+    if not isinstance(obj, list):
+        return [obj]
+    return obj
+
+
+def ensure_date(date_str: str | date | None) -> date | None:
+    if not date_str:
+        return None
+
+    if isinstance(date_str, str):
+        return datetime.fromisoformat(date_str).date()
+
+    if isinstance(date_str, datetime):
+        return date_str.date()
+
+    return date_str
+
+
+@attrs.define
+class CacheableData:
+    """Represents a cacheable data object, with methods to read and write to cache."""
+
+    name: str
+    cache_dir: Path
+
+    def __attrs_post_init__(self):
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    @property
+    def cache_path(self) -> Path:
+        """The path to the cache file."""
+        return self.cache_dir.expanduser().joinpath(f"{self.name}_cache.json")
+
+    def get_cached_data(self, keys: list[str] | None = None) -> dict[str, str]:
+        """Reads the cache file and returns the data if it exists and is valid.
+
+        Returns:
+            dict[str, str]: The cached data, or an empty dictionary if the cache is invalid or missing.
+        """
+        LOGGER.debug(f"Loading {self.name} from cache ({self.cache_path})")
+        try:
+            if not self.cache_path.exists():
+                return {}
+
+            if self.cache_path.stat().st_size == 0:
+                return {}
+
+            data: dict[str, str] = json.loads(self.cache_path.read_text())
+            if not keys:
+                return data
+
+            if set(data.keys()).issuperset(set(keys)):
+                return {k: v for k, v in data.items() if k in keys}
+            raise ValueError(f"Data must contain all keys: {keys}")
+        except Exception:
+            LOGGER.exception(f"Failed to read {self.cache_path.name}")
+            return {}
+
+    def write_to_cache(self, data: dict[str, str]) -> None:
+        """Writes the data to the cache file."""
+        LOGGER.debug(f"Writing {self.name} to cache ({self.cache_path})")
+
+        # double check everything exists
+        if not self.cache_path.parent.exists():
+            self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+
+        if not self.cache_path.exists():
+            self.cache_path.touch()
+
+        existing_data = self.get_cached_data()
+        data = {**existing_data, **data}
+
+        self.cache_path.write_text(json.dumps(data, indent=4, default=str))
+
+    def clear_cache(self, keys: list[str] | None = None) -> None:
+        """Deletes the cache file if it exists."""
+        if not self.cache_path.exists():
+            return
+
+        if not keys:
+            self.cache_path.unlink()
+            LOGGER.debug(f"{self.name} cache deleted")
+            return
+
+        assert isinstance(keys, list), "Keys must be a list"
+
+        data = self.get_cached_data()
+        for key in keys:
+            data.pop(key, None)
+
+        self.write_to_cache(data)

{otf_api-0.8.2.dist-info → otf_api-0.9.1.dist-info}/METADATA

@@ -1,17 +1,16 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: otf-api
-Version: 0.8.2
+Version: 0.9.1
 Summary: Python OrangeTheory Fitness API Client
 License: MIT
 Author: Jessica Smith
 Author-email: j.smith.git1@gmail.com
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.11,<4.0
 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.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -19,12 +18,15 @@ 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: aiohttp (==3.10.*)
+Requires-Dist: attrs (>=24.3.0,<25.0.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: pydantic (>=2.7.3)
+Requires-Dist: yarl (>=1.18.3,<2.0.0)
 Project-URL: Documentation, https://otf-api.readthedocs.io/en/stable/
 Description-Content-Type: text/markdown
 
@@ -42,11 +44,20 @@ pip install otf-api
 
 ## Overview
 
-To use the API, you need to create an instance of the `Otf` class, providing your email address and password. This will authenticate you with the API and allow you to make requests. When the `Otf` object is created it automatically grabs your member details and home studio, to simplify the process of making requests.
+To use the API, you need to create an instance of the `Otf` class. This will authenticate you with the API and allow you to make requests. When the `Otf` object is created it automatically grabs your member details and home studio, to simplify the process of making requests.
 
+You can either pass an `OtfUser` object to the `OtfClass` or you can pass nothing and allow it to prompt you for your username and password.
 
-See the [examples](./examples) for more information on how to use the API.
+You can also export environment variables `OTF_EMAIL` and `OTF_PASSWORD` to get these from the environment.
 
-Disclaimer:
-This project is in no way affiliated with OrangeTheory Fitness.
+```python
+from otf_api import Otf, OtfUser
+
+otf = Otf()
+
+# OR
+
+otf = Otf(user=OtfUser(<email_address>,<password>))
+
+```