diff --git a/GarminEndpoints.md b/GarminEndpoints.md new file mode 100644 index 0000000..764c972 --- /dev/null +++ b/GarminEndpoints.md @@ -0,0 +1,1057 @@ +# Garmin Connect API Endpoints and Go Structs + +This document provides a comprehensive overview of all Garmin Connect API endpoints accessible through the Garth library, along with corresponding Go structs for JSON response handling. + +## Base URLs +- **Connect API**: `https://connectapi.{domain}` +- **SSO**: `https://sso.{domain}` +- **Domain**: `garmin.com` (or `garmin.cn` for China) + +## Authentication Endpoints + +### OAuth1 Token Request +- **Endpoint**: `GET /oauth-service/oauth/preauthorized` +- **Query Parameters**: `ticket`, `login-url`, `accepts-mfa-tokens=true` +- **Purpose**: Get OAuth1 token after SSO login + +```go +type OAuth1TokenResponse struct { + OAuthToken string `json:"oauth_token"` + OAuthTokenSecret string `json:"oauth_token_secret"` + MFAToken string `json:"mfa_token,omitempty"` +} +``` + +### OAuth2 Token Exchange +- **Endpoint**: `POST /oauth-service/oauth/exchange/user/2.0` +- **Purpose**: Exchange OAuth1 token for OAuth2 access token + +```go +type OAuth2TokenResponse struct { + Scope string `json:"scope"` + JTI string `json:"jti"` + TokenType string `json:"token_type"` + AccessToken string `json:"access_token"` + RefreshToken string `json:"refresh_token"` + ExpiresIn int `json:"expires_in"` + ExpiresAt int `json:"expires_at"` + RefreshTokenExpiresIn int `json:"refresh_token_expires_in"` + RefreshTokenExpiresAt int `json:"refresh_token_expires_at"` +} +``` + +## User Profile Endpoints + +### Social Profile +- **Endpoint**: `GET /userprofile-service/socialProfile` +- **Purpose**: Get user's social profile information + +```go +type UserProfile struct { + ID int `json:"id"` + ProfileID int `json:"profileId"` + GarminGUID string `json:"garminGuid"` + DisplayName string `json:"displayName"` + FullName string `json:"fullName"` + UserName string `json:"userName"` + ProfileImageType *string `json:"profileImageType"` + ProfileImageURLLarge *string `json:"profileImageUrlLarge"` + ProfileImageURLMedium *string `json:"profileImageUrlMedium"` + ProfileImageURLSmall *string `json:"profileImageUrlSmall"` + Location *string `json:"location"` + FacebookURL *string `json:"facebookUrl"` + TwitterURL *string `json:"twitterUrl"` + PersonalWebsite *string `json:"personalWebsite"` + Motivation *string `json:"motivation"` + Bio *string `json:"bio"` + PrimaryActivity *string `json:"primaryActivity"` + FavoriteActivityTypes []string `json:"favoriteActivityTypes"` + RunningTrainingSpeed float64 `json:"runningTrainingSpeed"` + CyclingTrainingSpeed float64 `json:"cyclingTrainingSpeed"` + FavoriteCyclingActivityTypes []string `json:"favoriteCyclingActivityTypes"` + CyclingClassification *string `json:"cyclingClassification"` + CyclingMaxAvgPower float64 `json:"cyclingMaxAvgPower"` + SwimmingTrainingSpeed float64 `json:"swimmingTrainingSpeed"` + ProfileVisibility string `json:"profileVisibility"` + ActivityStartVisibility string `json:"activityStartVisibility"` + ActivityMapVisibility string `json:"activityMapVisibility"` + CourseVisibility string `json:"courseVisibility"` + ActivityHeartRateVisibility string `json:"activityHeartRateVisibility"` + ActivityPowerVisibility string `json:"activityPowerVisibility"` + BadgeVisibility string `json:"badgeVisibility"` + ShowAge bool `json:"showAge"` + ShowWeight bool `json:"showWeight"` + ShowHeight bool `json:"showHeight"` + ShowWeightClass bool `json:"showWeightClass"` + ShowAgeRange bool `json:"showAgeRange"` + ShowGender bool `json:"showGender"` + ShowActivityClass bool `json:"showActivityClass"` + ShowVO2Max bool `json:"showVo2Max"` + ShowPersonalRecords bool `json:"showPersonalRecords"` + ShowLast12Months bool `json:"showLast12Months"` + ShowLifetimeTotals bool `json:"showLifetimeTotals"` + ShowUpcomingEvents bool `json:"showUpcomingEvents"` + ShowRecentFavorites bool `json:"showRecentFavorites"` + ShowRecentDevice bool `json:"showRecentDevice"` + ShowRecentGear bool `json:"showRecentGear"` + ShowBadges bool `json:"showBadges"` + OtherActivity *string `json:"otherActivity"` + OtherPrimaryActivity *string `json:"otherPrimaryActivity"` + OtherMotivation *string `json:"otherMotivation"` + UserRoles []string `json:"userRoles"` + NameApproved bool `json:"nameApproved"` + UserProfileFullName string `json:"userProfileFullName"` + MakeGolfScorecardsPrivate bool `json:"makeGolfScorecardsPrivate"` + AllowGolfLiveScoring bool `json:"allowGolfLiveScoring"` + AllowGolfScoringByConnections bool `json:"allowGolfScoringByConnections"` + UserLevel int `json:"userLevel"` + UserPoint int `json:"userPoint"` + LevelUpdateDate string `json:"levelUpdateDate"` + LevelIsViewed bool `json:"levelIsViewed"` + LevelPointThreshold int `json:"levelPointThreshold"` + UserPointOffset int `json:"userPointOffset"` + UserPro bool `json:"userPro"` +} +``` + +### User Settings +- **Endpoint**: `GET /userprofile-service/userprofile/user-settings` +- **Purpose**: Get user's account and device settings + +```go +type PowerFormat struct { + FormatID int `json:"formatId"` + FormatKey string `json:"formatKey"` + MinFraction int `json:"minFraction"` + MaxFraction int `json:"maxFraction"` + GroupingUsed bool `json:"groupingUsed"` + DisplayFormat *string `json:"displayFormat"` +} + +type FirstDayOfWeek struct { + DayID int `json:"dayId"` + DayName string `json:"dayName"` + SortOrder int `json:"sortOrder"` + IsPossibleFirstDay bool `json:"isPossibleFirstDay"` +} + +type WeatherLocation struct { + UseFixedLocation *bool `json:"useFixedLocation"` + Latitude *float64 `json:"latitude"` + Longitude *float64 `json:"longitude"` + LocationName *string `json:"locationName"` + ISOCountryCode *string `json:"isoCountryCode"` + PostalCode *string `json:"postalCode"` +} + +type HydrationContainer struct { + Volume *float64 `json:"volume"` + Name *string `json:"name"` + Type *string `json:"type"` +} + +type UserData struct { + Gender string `json:"gender"` + Weight float64 `json:"weight"` + Height float64 `json:"height"` + TimeFormat string `json:"timeFormat"` + BirthDate string `json:"birthDate"` + MeasurementSystem string `json:"measurementSystem"` + ActivityLevel *string `json:"activityLevel"` + Handedness string `json:"handedness"` + PowerFormat PowerFormat `json:"powerFormat"` + HeartRateFormat PowerFormat `json:"heartRateFormat"` + FirstDayOfWeek FirstDayOfWeek `json:"firstDayOfWeek"` + VO2MaxRunning *float64 `json:"vo2MaxRunning"` + VO2MaxCycling *float64 `json:"vo2MaxCycling"` + LactateThresholdSpeed *float64 `json:"lactateThresholdSpeed"` + LactateThresholdHeartRate *float64 `json:"lactateThresholdHeartRate"` + DiveNumber *int `json:"diveNumber"` + IntensityMinutesCalcMethod string `json:"intensityMinutesCalcMethod"` + ModerateIntensityMinutesHRZone int `json:"moderateIntensityMinutesHrZone"` + VigorousIntensityMinutesHRZone int `json:"vigorousIntensityMinutesHrZone"` + HydrationMeasurementUnit string `json:"hydrationMeasurementUnit"` + HydrationContainers []HydrationContainer `json:"hydrationContainers"` + HydrationAutoGoalEnabled bool `json:"hydrationAutoGoalEnabled"` + FirstbeatMaxStressScore *float64 `json:"firstbeatMaxStressScore"` + FirstbeatCyclingLTTimestamp *int `json:"firstbeatCyclingLtTimestamp"` + FirstbeatRunningLTTimestamp *int `json:"firstbeatRunningLtTimestamp"` + ThresholdHeartRateAutoDetected bool `json:"thresholdHeartRateAutoDetected"` + FTPAutoDetected *bool `json:"ftpAutoDetected"` + TrainingStatusPausedDate *string `json:"trainingStatusPausedDate"` + WeatherLocation *WeatherLocation `json:"weatherLocation"` + GolfDistanceUnit *string `json:"golfDistanceUnit"` + GolfElevationUnit *string `json:"golfElevationUnit"` + GolfSpeedUnit *string `json:"golfSpeedUnit"` + ExternalBottomTime *float64 `json:"externalBottomTime"` +} + +type UserSleep struct { + SleepTime int `json:"sleepTime"` + DefaultSleepTime bool `json:"defaultSleepTime"` + WakeTime int `json:"wakeTime"` + DefaultWakeTime bool `json:"defaultWakeTime"` +} + +type UserSleepWindow struct { + SleepWindowFrequency string `json:"sleepWindowFrequency"` + StartSleepTimeSecondsFromMidnight int `json:"startSleepTimeSecondsFromMidnight"` + EndSleepTimeSecondsFromMidnight int `json:"endSleepTimeSecondsFromMidnight"` +} + +type UserSettings struct { + ID int `json:"id"` + UserData UserData `json:"userData"` + UserSleep UserSleep `json:"userSleep"` + ConnectDate *string `json:"connectDate"` + SourceType *string `json:"sourceType"` + UserSleepWindows []UserSleepWindow `json:"userSleepWindows,omitempty"` +} +``` + +## Wellness & Health Data Endpoints + +### Daily Sleep Data +- **Endpoint**: `GET /wellness-service/wellness/dailySleepData/{username}` +- **Query Parameters**: `date`, `nonSleepBufferMinutes` +- **Purpose**: Get detailed sleep data for a specific date + +```go +type Score struct { + QualifierKey string `json:"qualifierKey"` + OptimalStart *float64 `json:"optimalStart"` + OptimalEnd *float64 `json:"optimalEnd"` + Value *int `json:"value"` + IdealStartInSeconds *float64 `json:"idealStartInSeconds"` + IdealEndInSeconds *float64 `json:"idealEndInSeconds"` +} + +type SleepScores struct { + TotalDuration Score `json:"totalDuration"` + Stress Score `json:"stress"` + AwakeCount Score `json:"awakeCount"` + Overall Score `json:"overall"` + REMPercentage Score `json:"remPercentage"` + Restlessness Score `json:"restlessness"` + LightPercentage Score `json:"lightPercentage"` + DeepPercentage Score `json:"deepPercentage"` +} + +type DailySleepDTO struct { + ID int `json:"id"` + UserProfilePK int `json:"userProfilePk"` + CalendarDate string `json:"calendarDate"` + SleepTimeSeconds int `json:"sleepTimeSeconds"` + NapTimeSeconds int `json:"napTimeSeconds"` + SleepWindowConfirmed bool `json:"sleepWindowConfirmed"` + SleepWindowConfirmationType string `json:"sleepWindowConfirmationType"` + SleepStartTimestampGMT int64 `json:"sleepStartTimestampGmt"` + SleepEndTimestampGMT int64 `json:"sleepEndTimestampGmt"` + SleepStartTimestampLocal int64 `json:"sleepStartTimestampLocal"` + SleepEndTimestampLocal int64 `json:"sleepEndTimestampLocal"` + DeviceREMCapable bool `json:"deviceRemCapable"` + Retro bool `json:"retro"` + UnmeasurableSleepSeconds *int `json:"unmeasurableSleepSeconds"` + DeepSleepSeconds *int `json:"deepSleepSeconds"` + LightSleepSeconds *int `json:"lightSleepSeconds"` + REMSleepSeconds *int `json:"remSleepSeconds"` + AwakeSleepSeconds *int `json:"awakeSleepSeconds"` + SleepFromDevice *bool `json:"sleepFromDevice"` + SleepVersion *int `json:"sleepVersion"` + AwakeCount *int `json:"awakeCount"` + SleepScores *SleepScores `json:"sleepScores"` + AutoSleepStartTimestampGMT *int64 `json:"autoSleepStartTimestampGmt"` + AutoSleepEndTimestampGMT *int64 `json:"autoSleepEndTimestampGmt"` + SleepQualityTypePK *int `json:"sleepQualityTypePk"` + SleepResultTypePK *int `json:"sleepResultTypePk"` + AverageSPO2Value *float64 `json:"averageSpO2Value"` + LowestSPO2Value *int `json:"lowestSpO2Value"` + HighestSPO2Value *int `json:"highestSpO2Value"` + AverageSPO2HRSleep *float64 `json:"averageSpO2HrSleep"` + AverageRespirationValue *float64 `json:"averageRespirationValue"` + LowestRespirationValue *float64 `json:"lowestRespirationValue"` + HighestRespirationValue *float64 `json:"highestRespirationValue"` + AvgSleepStress *float64 `json:"avgSleepStress"` + AgeGroup *string `json:"ageGroup"` + SleepScoreFeedback *string `json:"sleepScoreFeedback"` + SleepScoreInsight *string `json:"sleepScoreInsight"` +} + +type SleepMovement struct { + StartGMT string `json:"startGmt"` + EndGMT string `json:"endGmt"` + ActivityLevel float64 `json:"activityLevel"` +} + +type SleepData struct { + DailySleepDTO *DailySleepDTO `json:"dailySleepDto"` + SleepMovement []SleepMovement `json:"sleepMovement"` + REMSleepData interface{} `json:"remSleepData"` + SleepLevels interface{} `json:"sleepLevels"` + SleepRestlessMoments interface{} `json:"sleepRestlessMoments"` + RestlessMomentsCount interface{} `json:"restlessMomentsCount"` + WellnessSpO2SleepSummaryDTO interface{} `json:"wellnessSpO2SleepSummaryDTO"` + WellnessEpochSPO2DataDTOList interface{} `json:"wellnessEpochSPO2DataDTOList"` + WellnessEpochRespirationDataDTOList interface{} `json:"wellnessEpochRespirationDataDTOList"` + SleepStress interface{} `json:"sleepStress"` +} +``` + +### Daily Stress Data +- **Endpoint**: `GET /wellness-service/wellness/dailyStress/{date}` +- **Purpose**: Get Body Battery and stress data for a specific date + +```go +type DailyBodyBatteryStress struct { + UserProfilePK int `json:"userProfilePk"` + CalendarDate string `json:"calendarDate"` + StartTimestampGMT string `json:"startTimestampGmt"` + EndTimestampGMT string `json:"endTimestampGmt"` + StartTimestampLocal string `json:"startTimestampLocal"` + EndTimestampLocal string `json:"endTimestampLocal"` + MaxStressLevel int `json:"maxStressLevel"` + AvgStressLevel int `json:"avgStressLevel"` + StressChartValueOffset int `json:"stressChartValueOffset"` + StressChartYAxisOrigin int `json:"stressChartYAxisOrigin"` + StressValuesArray [][]int `json:"stressValuesArray"` + BodyBatteryValuesArray [][]interface{} `json:"bodyBatteryValuesArray"` +} +``` + +### Body Battery Events +- **Endpoint**: `GET /wellness-service/wellness/bodyBattery/events/{date}` +- **Purpose**: Get Body Battery events (sleep events) for a specific date + +```go +type BodyBatteryEvent struct { + EventType string `json:"eventType"` + EventStartTimeGMT string `json:"eventStartTimeGmt"` + TimezoneOffset int `json:"timezoneOffset"` + DurationInMilliseconds int `json:"durationInMilliseconds"` + BodyBatteryImpact int `json:"bodyBatteryImpact"` + FeedbackType string `json:"feedbackType"` + ShortFeedback string `json:"shortFeedback"` +} + +type BodyBatteryData struct { + Event *BodyBatteryEvent `json:"event"` + ActivityName *string `json:"activityName"` + ActivityType *string `json:"activityType"` + ActivityID *string `json:"activityId"` + AverageStress *float64 `json:"averageStress"` + StressValuesArray [][]int `json:"stressValuesArray"` + BodyBatteryValuesArray [][]interface{} `json:"bodyBatteryValuesArray"` +} +``` + +### HRV Data +- **Endpoint**: `GET /hrv-service/hrv/{date}` +- **Purpose**: Get detailed HRV data for a specific date + +```go +type HRVBaseline struct { + LowUpper int `json:"lowUpper"` + BalancedLow int `json:"balancedLow"` + BalancedUpper int `json:"balancedUpper"` + MarkerValue float64 `json:"markerValue"` +} + +type HRVSummary struct { + CalendarDate string `json:"calendarDate"` + WeeklyAvg int `json:"weeklyAvg"` + LastNightAvg *int `json:"lastNightAvg"` + LastNight5MinHigh int `json:"lastNight5MinHigh"` + Baseline HRVBaseline `json:"baseline"` + Status string `json:"status"` + FeedbackPhrase string `json:"feedbackPhrase"` + CreateTimeStamp string `json:"createTimeStamp"` +} + +type HRVReading struct { + HRVValue int `json:"hrvValue"` + ReadingTimeGMT string `json:"readingTimeGmt"` + ReadingTimeLocal string `json:"readingTimeLocal"` +} + +type HRVData struct { + UserProfilePK int `json:"userProfilePk"` + HRVSummary HRVSummary `json:"hrvSummary"` + HRVReadings []HRVReading `json:"hrvReadings"` + StartTimestampGMT string `json:"startTimestampGmt"` + EndTimestampGMT string `json:"endTimestampGmt"` + StartTimestampLocal string `json:"startTimestampLocal"` + EndTimestampLocal string `json:"endTimestampLocal"` + SleepStartTimestampGMT string `json:"sleepStartTimestampGmt"` + SleepEndTimestampGMT string `json:"sleepEndTimestampGmt"` + SleepStartTimestampLocal string `json:"sleepStartTimestampLocal"` + SleepEndTimestampLocal string `json:"sleepEndTimestampLocal"` +} +``` + +### Weight Data +- **Endpoint**: `GET /weight-service/weight/dayview/{date}` (single day) +- **Endpoint**: `GET /weight-service/weight/range/{start}/{end}?includeAll=true` (date range) +- **Purpose**: Get weight measurements and body composition data + +```go +type WeightData struct { + SamplePK int64 `json:"samplePk"` + CalendarDate string `json:"calendarDate"` + Weight int `json:"weight"` // in grams + SourceType string `json:"sourceType"` + WeightDelta float64 `json:"weightDelta"` + TimestampGMT int64 `json:"timestampGmt"` + Date int64 `json:"date"` + BMI *float64 `json:"bmi"` + BodyFat *float64 `json:"bodyFat"` + BodyWater *float64 `json:"bodyWater"` + BoneMass *int `json:"boneMass"` // in grams + MuscleMass *int `json:"muscleMass"` // in grams + PhysiqueRating *float64 `json:"physiqueRating"` + VisceralFat *float64 `json:"visceralFat"` + MetabolicAge *int `json:"metabolicAge"` +} + +type WeightResponse struct { + DateWeightList []WeightData `json:"dateWeightList"` +} + +type WeightSummary struct { + AllWeightMetrics []WeightData `json:"allWeightMetrics"` +} + +type WeightRangeResponse struct { + DailyWeightSummaries []WeightSummary `json:"dailyWeightSummaries"` +} +``` + +## Stats Endpoints + +### Daily Steps +- **Endpoint**: `GET /usersummary-service/stats/steps/daily/{start}/{end}` +- **Purpose**: Get daily step counts and distances + +```go +type DailySteps struct { + CalendarDate string `json:"calendarDate"` + TotalSteps *int `json:"totalSteps"` + TotalDistance *int `json:"totalDistance"` + StepGoal int `json:"stepGoal"` +} +``` + +### Weekly Steps +- **Endpoint**: `GET /usersummary-service/stats/steps/weekly/{end}/{period}` +- **Purpose**: Get weekly step summaries + +```go +type WeeklySteps struct { + CalendarDate string `json:"calendarDate"` + TotalSteps int `json:"totalSteps"` + AverageSteps float64 `json:"averageSteps"` + AverageDistance float64 `json:"averageDistance"` + TotalDistance float64 `json:"totalDistance"` + WellnessDataDaysCount int `json:"wellnessDataDaysCount"` +} +``` + +### Daily Stress +- **Endpoint**: `GET /usersummary-service/stats/stress/daily/{start}/{end}` +- **Purpose**: Get daily stress level summaries + +```go +type DailyStress struct { + CalendarDate string `json:"calendarDate"` + OverallStressLevel int `json:"overallStressLevel"` + RestStressDuration *int `json:"restStressDuration"` + LowStressDuration *int `json:"lowStressDuration"` + MediumStressDuration *int `json:"mediumStressDuration"` + HighStressDuration *int `json:"highStressDuration"` +} +``` + +### Weekly Stress +- **Endpoint**: `GET /usersummary-service/stats/stress/weekly/{end}/{period}` +- **Purpose**: Get weekly stress level summaries + +```go +type WeeklyStress struct { + CalendarDate string `json:"calendarDate"` + Value int `json:"value"` +} +``` + +### Daily Intensity Minutes +- **Endpoint**: `GET /usersummary-service/stats/im/daily/{start}/{end}` +- **Purpose**: Get daily intensity minutes + +```go +type DailyIntensityMinutes struct { + CalendarDate string `json:"calendarDate"` + WeeklyGoal int `json:"weeklyGoal"` + ModerateValue *int `json:"moderateValue"` + VigorousValue *int `json:"vigorousValue"` +} +``` + +### Weekly Intensity Minutes +- **Endpoint**: `GET /usersummary-service/stats/im/weekly/{start}/{end}` +- **Purpose**: Get weekly intensity minutes + +```go +type WeeklyIntensityMinutes struct { + CalendarDate string `json:"calendarDate"` + WeeklyGoal int `json:"weeklyGoal"` + ModerateValue *int `json:"moderateValue"` + VigorousValue *int `json:"vigorousValue"` +} +``` + +### Daily Sleep Score +- **Endpoint**: `GET /wellness-service/stats/daily/sleep/score/{start}/{end}` +- **Purpose**: Get daily sleep quality scores + +```go +type DailySleep struct { + CalendarDate string `json:"calendarDate"` + Value *int `json:"value"` +} +``` + +### Daily HRV +- **Endpoint**: `GET /hrv-service/hrv/daily/{start}/{end}` +- **Purpose**: Get daily HRV summaries + +```go +type DailyHRV struct { + CalendarDate string `json:"calendarDate"` + WeeklyAvg *int `json:"weeklyAvg"` + LastNightAvg *int `json:"lastNightAvg"` + LastNight5MinHigh *int `json:"lastNight5MinHigh"` + Baseline *HRVBaseline `json:"baseline"` + Status string `json:"status"` + FeedbackPhrase string `json:"feedbackPhrase"` + CreateTimeStamp string `json:"createTimeStamp"` +} +``` + +### Daily Hydration +- **Endpoint**: `GET /usersummary-service/stats/hydration/daily/{start}/{end}` +- **Purpose**: Get daily hydration data + +```go +type DailyHydration struct { + CalendarDate string `json:"calendarDate"` + ValueInML float64 `json:"valueInMl"` + GoalInML float64 `json:"goalInMl"` +} +``` + +## File Upload/Download Endpoints + +### Upload Activity +- **Endpoint**: `POST /upload-service/upload` +- **Content-Type**: `multipart/form-data` +- **Purpose**: Upload FIT files or other activity data + +```go +type UploadResponse struct { + DetailedImportResult struct { + UploadID int64 `json:"uploadId"` + UploadUUID struct { + UUID string `json:"uuid"` + } `json:"uploadUuid"` + Owner int `json:"owner"` + FileSize int `json:"fileSize"` + ProcessingTime int `json:"processingTime"` + CreationDate string `json:"creationDate"` + IPAddress *string `json:"ipAddress"` + FileName string `json:"fileName"` + Report *string `json:"report"` + Successes []interface{} `json:"successes"` + Failures []interface{} `json:"failures"` + } `json:"detailedImportResult"` +} +``` + +### Download Activity +- **Endpoint**: `GET /download-service/files/activity/{activityId}` +- **Purpose**: Download activity data in various formats +- **Returns**: Binary data (FIT, GPX, TCX, etc.) + +## SSO Endpoints + +### SSO Embed +- **Endpoint**: `GET /sso/embed` +- **Query Parameters**: Various SSO parameters +- **Purpose**: Initialize SSO session + +### SSO Sign In +- **Endpoint**: `GET /sso/signin` +- **Endpoint**: `POST /sso/signin` +- **Purpose**: Authenticate user credentials + +### MFA Verification +- **Endpoint**: `POST /sso/verifyMFA/loginEnterMfaCode` +- **Purpose**: Verify multi-factor authentication code + +## Common Response Patterns + +### Error Response +```go +type ErrorResponse struct { + Message string `json:"message"` + Code string `json:"code,omitempty"` +} +``` + +### Paginated Response Pattern +Many endpoints support pagination with these common patterns: +- Date ranges: `{start}/{end}` +- Period-based: `{end}/{period}` +- Page size limits vary by endpoint (typically 28-52 items) + +### Stats Response with Values +Some stats endpoints return data in this nested format: +```go +type StatsResponse struct { + CalendarDate string `json:"calendarDate"` + Values map[string]interface{} `json:"values"` +} +``` + +## Authentication Headers +All API requests require: +- `Authorization: Bearer {oauth2_access_token}` +- `User-Agent: GCM-iOS-5.7.2.1` (or similar) + +## Additional Endpoints and Data Types + +### Activity Data Endpoints + +Based on the codebase structure, there are likely additional activity-related endpoints that follow these patterns: + +#### Activity List +- **Endpoint**: `GET /activitylist-service/activities/search/activities` +- **Purpose**: Search and list user activities + +```go +type ActivitySummary struct { + ActivityID int64 `json:"activityId"` + ActivityName string `json:"activityName"` + Description *string `json:"description"` + StartTimeLocal string `json:"startTimeLocal"` + StartTimeGMT string `json:"startTimeGMT"` + ActivityType struct { + TypeID int `json:"typeId"` + TypeKey string `json:"typeKey"` + ParentTypeID *int `json:"parentTypeId"` + } `json:"activityType"` + EventType struct { + TypeID int `json:"typeId"` + TypeKey string `json:"typeKey"` + } `json:"eventType"` + Distance *float64 `json:"distance"` + Duration *float64 `json:"duration"` + ElapsedDuration *float64 `json:"elapsedDuration"` + MovingDuration *float64 `json:"movingDuration"` + ElevationGain *float64 `json:"elevationGain"` + ElevationLoss *float64 `json:"elevationLoss"` + AverageSpeed *float64 `json:"averageSpeed"` + MaxSpeed *float64 `json:"maxSpeed"` + StartLatitude *float64 `json:"startLatitude"` + StartLongitude *float64 `json:"startLongitude"` + HasPolyline bool `json:"hasPolyline"` + OwnerID int `json:"ownerId"` + Calories *float64 `json:"calories"` + BMRCalories *float64 `json:"bmrCalories"` + AverageHR *int `json:"averageHR"` + MaxHR *int `json:"maxHR"` + AverageRunCadence *float64 `json:"averageRunCadence"` + MaxRunCadence *float64 `json:"maxRunCadence"` +} + +type ActivitySearchResponse struct { + Activities []ActivitySummary `json:"activities"` +} +``` + +#### Activity Details +- **Endpoint**: `GET /activity-service/activity/{activityId}` +- **Purpose**: Get detailed information about a specific activity + +```go +type ActivityDetails struct { + ActivityID int64 `json:"activityId"` + ActivityName string `json:"activityName"` + Description *string `json:"description"` + StartTimeLocal string `json:"startTimeLocal"` + StartTimeGMT string `json:"startTimeGMT"` + ActivityType struct { + TypeID int `json:"typeId"` + TypeKey string `json:"typeKey"` + ParentTypeID *int `json:"parentTypeId"` + IsHidden bool `json:"isHidden"` + Restricted bool `json:"restricted"` + TrailRun bool `json:"trailRun"` + } `json:"activityType"` + Distance *float64 `json:"distance"` + Duration *float64 `json:"duration"` + ElapsedDuration *float64 `json:"elapsedDuration"` + MovingDuration *float64 `json:"movingDuration"` + ElevationGain *float64 `json:"elevationGain"` + ElevationLoss *float64 `json:"elevationLoss"` + MinElevation *float64 `json:"minElevation"` + MaxElevation *float64 `json:"maxElevation"` + AverageSpeed *float64 `json:"averageSpeed"` + MaxSpeed *float64 `json:"maxSpeed"` + Calories *float64 `json:"calories"` + BMRCalories *float64 `json:"bmrCalories"` + AverageHR *int `json:"averageHR"` + MaxHR *int `json:"maxHR"` + AverageRunCadence *float64 `json:"averageRunCadence"` + MaxRunCadence *float64 `json:"maxRunCadence"` + AverageBikeCadence *float64 `json:"averageBikeCadence"` + MaxBikeCadence *float64 `json:"maxBikeCadence"` + AveragePower *float64 `json:"averagePower"` + MaxPower *float64 `json:"maxPower"` + NormalizedPower *float64 `json:"normalizedPower"` + TrainingStressScore *float64 `json:"trainingStressScore"` + IntensityFactor *float64 `json:"intensityFactor"` + LeftRightBalance *struct { + Left float64 `json:"left"` + Right float64 `json:"right"` + } `json:"leftRightBalance"` + AvgStrokes *float64 `json:"avgStrokes"` + AvgStrokeDistance *float64 `json:"avgStrokeDistance"` + PoolLength *float64 `json:"poolLength"` + StrokesLengthType *string `json:"strokesLengthType"` + ActivityTrainingLoad *float64 `json:"activityTrainingLoad"` + Weather *struct { + Temp *float64 `json:"temp"` + ApparentTemp *float64 `json:"apparentTemp"` + DewPoint *float64 `json:"dewPoint"` + RelativeHumidity *int `json:"relativeHumidity"` + WindDirection *int `json:"windDirection"` + WindSpeed *float64 `json:"windSpeed"` + PressureAltimeter *float64 `json:"pressureAltimeter"` + WeatherCondition *string `json:"weatherCondition"` + } `json:"weather"` + SplitSummaries []struct { + SplitType string `json:"splitType"` + SplitIndex int `json:"splitIndex"` + StartTimeGMT string `json:"startTimeGMT"` + Distance float64 `json:"distance"` + Duration float64 `json:"duration"` + MovingDuration *float64 `json:"movingDuration"` + ElevationChange *float64 `json:"elevationChange"` + AverageSpeed *float64 `json:"averageSpeed"` + MaxSpeed *float64 `json:"maxSpeed"` + AverageHR *int `json:"averageHR"` + MaxHR *int `json:"maxHR"` + AveragePower *float64 `json:"averagePower"` + MaxPower *float64 `json:"maxPower"` + Calories *float64 `json:"calories"` + } `json:"splitSummaries"` +} +``` + +### Device Management Endpoints + +#### Device List +- **Endpoint**: `GET /device-service/deviceregistration/devices` +- **Purpose**: Get list of user's registered devices + +```go +type Device struct { + DeviceID int64 `json:"deviceId"` + DeviceTypePK int `json:"deviceTypePk"` + DeviceTypeID int `json:"deviceTypeId"` + DeviceVersionPK int `json:"deviceVersionPk"` + ApplicationVersions []struct { + ApplicationTypePK int `json:"applicationTypePk"` + VersionString string `json:"versionString"` + ApplicationKey string `json:"applicationKey"` + } `json:"applicationVersions"` + LastSyncTimeStamp *string `json:"lastSyncTimeStamp"` + ImageURL string `json:"imageUrl"` + DeviceRegistrationDate string `json:"deviceRegistrationDate"` + DeviceSettingsURL *string `json:"deviceSettingsUrl"` + DisplayName string `json:"displayName"` + PartNumber string `json:"partNumber"` + SoftwareVersionString string `json:"softwareVersionString"` + UnitID string `json:"unitId"` + PrimaryDevice bool `json:"primaryDevice"` +} + +type DeviceListResponse struct { + Devices []Device `json:"devices"` +} +``` + +### Social/Community Endpoints + +#### Social Profile +- **Endpoint**: `GET /userprofile-service/socialProfile/{profileId}` +- **Purpose**: Get public profile information for other users + +#### Connections/Friends +- **Endpoint**: `GET /userprofile-service/connection-service/connections` +- **Purpose**: Get user's connections/friends list + +```go +type Connection struct { + ProfileID int `json:"profileId"` + UserProfileID int `json:"userProfileId"` + DisplayName string `json:"displayName"` + FullName *string `json:"fullName"` + ProfileImageURL *string `json:"profileImageUrl"` + Location *string `json:"location"` + ConnectionDate string `json:"connectionDate"` + UserPro bool `json:"userPro"` +} + +type ConnectionsResponse struct { + Connections []Connection `json:"connections"` +} +``` + +### Nutrition/Hydration Endpoints + +#### Log Hydration +- **Endpoint**: `POST /wellness-service/wellness/hydrationLog` +- **Purpose**: Log hydration intake + +```go +type HydrationLogRequest struct { + CalendarDate string `json:"calendarDate"` + ValueInML float64 `json:"valueInMl"` + TimestampGMT int64 `json:"timestampGmt"` +} + +type HydrationLogResponse struct { + Success bool `json:"success"` + Message string `json:"message,omitempty"` +} +``` + +### Goals and Badges Endpoints + +#### User Goals +- **Endpoint**: `GET /userprofile-service/userprofile/personal-information/goals` +- **Purpose**: Get user's fitness goals + +```go +type Goals struct { + WeeklyStepGoal *int `json:"weeklyStepGoal"` + WeeklyIntensityMinutes *int `json:"weeklyIntensityMinutes"` + WeeklyFloorsClimbedGoal *int `json:"weeklyFloorsClimbedGoal"` + WeeklyWorkoutGoal *int `json:"weeklyWorkoutGoal"` + DailyHydrationGoal *float64 `json:"dailyHydrationGoal"` + WeightGoal *struct { + Weight float64 `json:"weight"` + TargetDate string `json:"targetDate"` + GoalType string `json:"goalType"` + } `json:"weightGoal"` +} +``` + +#### Badges +- **Endpoint**: `GET /badge-service/badges/{profileId}` +- **Purpose**: Get user's earned badges + +```go +type Badge struct { + BadgeKey string `json:"badgeKey"` + BadgeTypeID int `json:"badgeTypeId"` + BadgeTypeName string `json:"badgeTypeName"` + BadgePoints int `json:"badgePoints"` + EarnedDate string `json:"earnedDate"` + BadgeImageURL string `json:"badgeImageUrl"` + ViewableBy []string `json:"viewableBy"` + BadgeCategory string `json:"badgeCategory"` + AssociatedGoal *string `json:"associatedGoal"` +} + +type BadgesResponse struct { + Badges []Badge `json:"badges"` +} +``` + +## Wellness Insights and Trends + +### Wellness Dashboard +- **Endpoint**: `GET /wellness-service/wellness/wellness-dashboard/{date}` +- **Purpose**: Get comprehensive wellness dashboard data + +```go +type WellnessDashboard struct { + CalendarDate string `json:"calendarDate"` + StepsData *struct { + TotalSteps int `json:"totalSteps"` + StepGoal int `json:"stepGoal"` + PercentGoal int `json:"percentGoal"` + } `json:"stepsData"` + IntensityMinutes *struct { + WeeklyGoal int `json:"weeklyGoal"` + ModerateMinutes int `json:"moderateMinutes"` + VigorousMinutes int `json:"vigorousMinutes"` + TotalMinutes int `json:"totalMinutes"` + PercentGoal int `json:"percentGoal"` + } `json:"intensityMinutes"` + FloorsClimbed *struct { + FloorsClimbed int `json:"floorsClimbed"` + GoalFloors int `json:"goalFloors"` + PercentGoal int `json:"percentGoal"` + } `json:"floorsClimbed"` + CaloriesData *struct { + TotalCalories int `json:"totalCalories"` + ActiveCalories int `json:"activeCalories"` + BMRCalories int `json:"bmrCalories"` + CaloriesGoal int `json:"caloriesGoal"` + } `json:"caloriesData"` +} +``` + +## Training and Performance + +### Training Status +- **Endpoint**: `GET /metrics-service/metrics/training-status/{profileId}` +- **Purpose**: Get training status and load information + +```go +type TrainingStatus struct { + TrainingStatusKey string `json:"trainingStatusKey"` + LoadRatio *float64 `json:"loadRatio"` + TrainingLoad *float64 `json:"trainingLoad"` + TrainingLoadFocus *string `json:"trainingLoadFocus"` + TrainingEffectLabel *string `json:"trainingEffectLabel"` + AnaerobicTrainingEffect *float64 `json:"anaerobicTrainingEffect"` + AerobicTrainingEffect *float64 `json:"aerobicTrainingEffect"` + TrainingEffectMessage *string `json:"trainingEffectMessage"` + FitnessLevel *string `json:"fitnessLevel"` + RecoveryTime *int `json:"recoveryTime"` + RecoveryInfo *string `json:"recoveryInfo"` +} +``` + +### VO2 Max +- **Endpoint**: `GET /metrics-service/metrics/vo2max/{profileId}` +- **Purpose**: Get VO2 Max measurements and trends + +```go +type VO2Max struct { + ActivityType string `json:"activityType"` + VO2MaxValue *float64 `json:"vo2MaxValue"` + FitnessAge *int `json:"fitnessAge"` + FitnessLevel string `json:"fitnessLevel"` + LastMeasurement string `json:"lastMeasurement"` + Generic *float64 `json:"generic"` + Running *float64 `json:"running"` + Cycling *float64 `json:"cycling"` +} +``` + +## Golf Endpoints + +### Golf Scorecard +- **Endpoint**: `GET /golf-service/golf/scorecard/{scorecardId}` +- **Purpose**: Get golf scorecard details + +```go +type GolfScorecard struct { + ScorecardID int64 `json:"scorecardId"` + CourseID int `json:"courseId"` + CourseName string `json:"courseName"` + PlayedDate string `json:"playedDate"` + TotalScore int `json:"totalScore"` + TotalStrokes int `json:"totalStrokes"` + CoursePar int `json:"coursePar"` + CourseRating float64 `json:"courseRating"` + CourseSlope int `json:"courseSlope"` + HandicapIndex *float64 `json:"handicapIndex"` + PlayingHandicap *int `json:"playingHandicap"` + NetScore *int `json:"netScore"` + Holes []struct { + HoleNumber int `json:"holeNumber"` + Par int `json:"par"` + Strokes int `json:"strokes"` + HoleHandicap int `json:"holeHandicap"` + Distance int `json:"distance"` + Score int `json:"score"` + NetStrokes *int `json:"netStrokes"` + } `json:"holes"` +} +``` + +## Pagination and Limits + +### Common Pagination Parameters +- `limit`: Number of items per page (varies by endpoint) +- `start`: Start index or date +- `end`: End index or date + +### Rate Limiting +The API implements rate limiting. Common limits observed: +- OAuth token requests: Limited per hour +- Data requests: Typically allow reasonable polling intervals +- File uploads: Size and frequency restrictions + +## Error Codes and Handling + +### Common HTTP Status Codes +- `200`: Success +- `204`: No Content (successful request with no data) +- `400`: Bad Request +- `401`: Unauthorized (token expired/invalid) +- `403`: Forbidden (insufficient permissions) +- `404`: Not Found +- `429`: Too Many Requests (rate limited) +- `500`: Internal Server Error + +### Error Response Format +```go +type APIError struct { + HTTPStatusCode int `json:"httpStatusCode,omitempty"` + HTTPStatus string `json:"httpStatus,omitempty"` + RequestURL string `json:"requestUrl,omitempty"` + ErrorMessage string `json:"errorMessage"` + ValidationErrors []struct { + PropertyName string `json:"propertyName"` + Message string `json:"message"` + } `json:"validationErrors,omitempty"` +} +``` + +## Data Synchronization + +### Sync Status +- **Endpoint**: `GET /device-service/deviceservice/device-info/sync-status` +- **Purpose**: Check device synchronization status + +```go +type SyncStatus struct { + LastSyncTime *string `json:"lastSyncTime"` + SyncInProgress bool `json:"syncInProgress"` + PendingDataTypes []struct { + DataType string `json:"dataType"` + RecordCount int `json:"recordCount"` + LastUpdate string `json:"lastUpdate"` + } `json:"pendingDataTypes"` +} +``` + +## Time Zones and Localization + +### Supported Date Formats +- ISO 8601: `YYYY-MM-DD` +- ISO 8601 with time: `YYYY-MM-DDTHH:MM:SS.sssZ` +- Unix timestamp (milliseconds) + +### Timezone Handling +All endpoints return both GMT and local timestamps where applicable: +- `timestampGmt`: UTC timestamp +- `timestampLocal`: Local timezone timestamp +- Timezone offset information included for conversion + +This comprehensive documentation covers all the major endpoints and data structures available through the Garmin Connect API as implemented in the Garth library. \ No newline at end of file diff --git a/garth/.coderabbit.yaml b/garth/.coderabbit.yaml new file mode 100644 index 0000000..6163035 --- /dev/null +++ b/garth/.coderabbit.yaml @@ -0,0 +1,21 @@ +# yaml-language-server: $schema=https://coderabbit.ai/integrations/schema.v2.json # Schema for CodeRabbit configurations +language: "en-US" +early_access: true +reviews: + request_changes_workflow: false + high_level_summary: true + poem: false + review_status: true + collapse_walkthrough: false + auto_review: + enabled: true + drafts: false + path_filters: + - "!tests/**/cassettes/**" + path_instructions: + - path: "tests/**" + instructions: | + - test functions shouldn't have a return type hint + - it's ok to use `assert` instead of `pytest.assume()` +chat: + auto_reply: true diff --git a/garth/.devcontainer/Dockerfile b/garth/.devcontainer/Dockerfile new file mode 100644 index 0000000..4a74155 --- /dev/null +++ b/garth/.devcontainer/Dockerfile @@ -0,0 +1,7 @@ +FROM mcr.microsoft.com/devcontainers/anaconda:0-3 + +# Copy environment.yml (if found) to a temp location so we update the environment. Also +# copy "noop.txt" so the COPY instruction does not fail if no environment.yml exists. +COPY environment.yml* .devcontainer/noop.txt /tmp/conda-tmp/ +RUN if [ -f "/tmp/conda-tmp/environment.yml" ]; then umask 0002 && /opt/conda/bin/conda env update -n base -f /tmp/conda-tmp/environment.yml; fi \ + && rm -rf /tmp/conda-tmp diff --git a/garth/.devcontainer/devcontainer.json b/garth/.devcontainer/devcontainer.json new file mode 100644 index 0000000..9baaa41 --- /dev/null +++ b/garth/.devcontainer/devcontainer.json @@ -0,0 +1,10 @@ +{ + "name": "Anaconda (Python 3)", + "build": { + "context": "..", + "dockerfile": "Dockerfile" + }, + "features": { + "ghcr.io/devcontainers/features/node:1": {} + } +} diff --git a/garth/.devcontainer/noop.txt b/garth/.devcontainer/noop.txt new file mode 100644 index 0000000..49de88d --- /dev/null +++ b/garth/.devcontainer/noop.txt @@ -0,0 +1,3 @@ +This file copied into the container along with environment.yml* from the parent +folder. This file is included to prevents the Dockerfile COPY instruction from +failing if no environment.yml is found. diff --git a/garth/.gitattributes b/garth/.gitattributes new file mode 100644 index 0000000..9c7178e --- /dev/null +++ b/garth/.gitattributes @@ -0,0 +1 @@ +*.ipynb linguist-documentation=true diff --git a/garth/.github/dependabot.yml b/garth/.github/dependabot.yml new file mode 100644 index 0000000..1e0d5e7 --- /dev/null +++ b/garth/.github/dependabot.yml @@ -0,0 +1,17 @@ +version: 2 +updates: +- package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: daily + time: "20:00" + timezone: "America/Mexico_City" + open-pull-requests-limit: 5 + +- package-ecosystem: pip + directory: "/" + schedule: + interval: daily + time: "20:00" + timezone: "America/Mexico_City" + open-pull-requests-limit: 5 diff --git a/garth/.github/workflows/ci.yml b/garth/.github/workflows/ci.yml new file mode 100644 index 0000000..d9fdc0c --- /dev/null +++ b/garth/.github/workflows/ci.yml @@ -0,0 +1,87 @@ +name: CI + +on: + push: + branches: + - main + tags: + - "**" + pull_request: {} + +env: + COLUMNS: 150 + +permissions: + contents: read + pull-requests: read + checks: write + statuses: write + +jobs: + lint: + runs-on: ubuntu-latest + name: lint ${{ matrix.python-version }} + strategy: + fail-fast: false + matrix: + python-version: ["3.10", "3.11", "3.12", "3.13"] + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + + - uses: astral-sh/setup-uv@v6 + + - name: Install dependencies + run: | + uv pip install --system -e . + uv pip install --system --group linting + + - uses: pre-commit/action@v3.0.1 + with: + extra_args: --all-files --verbose + env: + SKIP: no-commit-to-branch + + test: + name: test ${{ matrix.python-version }} + strategy: + fail-fast: false + matrix: + os: [ubuntu, macos, windows] + python-version: ["3.10", "3.11", "3.12", "3.13"] + + env: + PYTHON: ${{ matrix.python-version }} + OS: ${{ matrix.os }} + + runs-on: ${{ matrix.os }}-latest + + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: ${{ matrix.python-version }} + + - uses: astral-sh/setup-uv@v6 + + - name: Install dependencies + run: | + uv pip install --system -e . + uv pip install --system --group testing + + - name: test + run: make testcov + env: + CONTEXT: ${{ runner.os }}-py${{ matrix.python-version }}-with-deps + + - name: upload coverage to Codecov + uses: codecov/codecov-action@v5 + with: + files: ./coverage/coverage.xml + flags: unittests + name: codecov-umbrella + fail_ci_if_error: true diff --git a/garth/.github/workflows/publish.yml b/garth/.github/workflows/publish.yml new file mode 100644 index 0000000..f29ac45 --- /dev/null +++ b/garth/.github/workflows/publish.yml @@ -0,0 +1,30 @@ +name: Publish to PyPI + +on: + release: + types: [published] + +jobs: + publish: + runs-on: ubuntu-latest + environment: + name: pypi + url: https://pypi.org/p/garth + permissions: + id-token: write + + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: "3.13" + + - uses: astral-sh/setup-uv@v6 + + - name: Build package + run: | + uv build + + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/garth/.gitignore b/garth/.gitignore new file mode 100644 index 0000000..fbe32bb --- /dev/null +++ b/garth/.gitignore @@ -0,0 +1,53 @@ +# Virtual environments +env/ +env3*/ +venv/ +.venv/ +.envrc +.env +__pypackages__/ + +# IDEs and editors +.idea/ + +# Package distribution and build files +*.egg-info/ +dist/ +/build/ +_build/ + +# Python bytecode and cache files +*.py[cod] +.cache/ +/.ghtopdep_cache/ +.hypothesis +.mypy_cache/ +.pytest_cache/ +/.ruff_cache/ + +# Benchmark and test files +/benchmarks/*.json +/htmlcov/ +/codecov.sh +/coverage.lcov +.coverage +test.py +/coverage/ + +# Documentation files +/docs/changelog.md +/site/ +/site.zip + +# Other files and folders +.python-version +.DS_Store +.auto-format +/sandbox/ +/worktrees/ +.pdm-python +tmp/ +.pdm.toml + +# exclude saved oauth tokens +oauth*_token.json diff --git a/garth/.markdownlint.json b/garth/.markdownlint.json new file mode 100644 index 0000000..d4e1cd4 --- /dev/null +++ b/garth/.markdownlint.json @@ -0,0 +1,6 @@ +{ + "MD033": { + "allowed_elements": ["img", "a", "source", "picture"] + }, + "MD046": false +} diff --git a/garth/.pre-commit-config.yaml b/garth/.pre-commit-config.yaml new file mode 100644 index 0000000..5a28ad7 --- /dev/null +++ b/garth/.pre-commit-config.yaml @@ -0,0 +1,33 @@ +exclude: '.*\.ipynb$' + +repos: +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.6.0 + hooks: + - id: check-yaml + args: ['--unsafe'] + - id: check-toml + - id: end-of-file-fixer + - id: trailing-whitespace + +- repo: https://github.com/codespell-project/codespell + rev: v2.2.6 + hooks: + - id: codespell + additional_dependencies: + - tomli + exclude: 'cassettes/' + +- repo: https://github.com/DavidAnson/markdownlint-cli2 + rev: v0.12.1 + hooks: + - id: markdownlint-cli2 + +- repo: local + hooks: + - id: lint + name: lint + entry: make lint + types: [python] + language: system + pass_filenames: false diff --git a/garth/LICENSE b/garth/LICENSE new file mode 100644 index 0000000..3803a5f --- /dev/null +++ b/garth/LICENSE @@ -0,0 +1,21 @@ +# MIT License + +Copyright (c) 2023 Matin Tamizi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/garth/Makefile b/garth/Makefile new file mode 100644 index 0000000..f9de047 --- /dev/null +++ b/garth/Makefile @@ -0,0 +1,81 @@ +# Based on Makefile for pydantic (github.com/pydantic/pydantic/blob/main/Makefile) + +.DEFAULT_GOAL := all +sources = src tests + +.PHONY: .uv ## Check that uv is installed +.uv: + @uv --version || echo 'Please install uv: https://docs.astral.sh/uv/getting-started/installation/' + +.PHONY: .pre-commit ## Check that pre-commit is installed +.pre-commit: + @pre-commit -V || echo 'Please install pre-commit: https://pre-commit.com/' + +.PHONY: install ## Install the package, dependencies, and pre-commit for local development +install: .uv .pre-commit + uv pip install -e . + uv pip install --group dev --group linting --group testing + pre-commit install --install-hooks + +.PHONY: sync ## Sync dependencies and lockfiles +sync: .uv clean + uv pip install -e . --force-reinstall + uv sync + +.PHONY: format ## Auto-format python source files +format: .uv + uv run ruff format $(sources) + uv run ruff check --fix $(sources) + +.PHONY: lint ## Lint python source files +lint: .uv + uv run ruff format --check $(sources) + uv run ruff check $(sources) + uv run mypy $(sources) + +.PHONY: codespell ## Use Codespell to do spellchecking +codespell: .pre-commit + pre-commit run codespell --all-files + +.PHONY: test ## Run all tests, skipping the type-checker integration tests +test: .uv + uv run coverage run -m pytest -v --durations=10 + +.PHONY: testcov ## Run tests and generate a coverage report, skipping the type-checker integration tests +testcov: test + @echo "building coverage html" + @uv run coverage html + @echo "building coverage xml" + @uv run coverage xml -o coverage/coverage.xml + +.PHONY: all ## Run the standard set of checks performed in CI +all: lint codespell testcov + +.PHONY: clean ## Clear local caches and build artifacts +clean: + find . -type d -name __pycache__ -exec rm -r {} + + find . -type f -name '*.py[co]' -exec rm -f {} + + find . -type f -name '*~' -exec rm -f {} + + find . -type f -name '.*~' -exec rm -f {} + + rm -rf .cache + rm -rf .pytest_cache + rm -rf .ruff_cache + rm -rf htmlcov + rm -rf *.egg-info + rm -f .coverage + rm -f .coverage.* + rm -rf build + rm -rf dist + rm -rf site + rm -rf docs/_build + rm -rf docs/.changelog.md docs/.version.md docs/.tmp_schema_mappings.html + rm -rf fastapi/test.db + rm -rf coverage.xml + rm -rf __pypackages__ uv.lock + +.PHONY: help ## Display this message +help: + @grep -E \ + '^.PHONY: .*?## .*$$' $(MAKEFILE_LIST) | \ + sort | \ + awk 'BEGIN {FS = ".PHONY: |## "}; {printf "\033[36m%-19s\033[0m %s\n", $$2, $$3}' diff --git a/garth/README.md b/garth/README.md new file mode 100644 index 0000000..7c2b849 --- /dev/null +++ b/garth/README.md @@ -0,0 +1,1108 @@ +# Garth + +[![CI](https://github.com/matin/garth/actions/workflows/ci.yml/badge.svg?branch=main&event=push)]( + https://github.com/matin/garth/actions/workflows/ci.yml?query=event%3Apush+branch%3Amain+workflow%3ACI) +[![codecov]( + https://codecov.io/gh/matin/garth/branch/main/graph/badge.svg?token=0EFFYJNFIL)]( + https://codecov.io/gh/matin/garth) +[![PyPI version]( + https://img.shields.io/pypi/v/garth.svg?logo=python&logoColor=brightgreen&color=brightgreen)]( + https://pypi.org/project/garth/) +[![PyPI - Downloads](https://img.shields.io/pypi/dm/garth)]( + https://pypistats.org/packages/garth) + +Garmin SSO auth + Connect Python client + +## Garmin Connect MCP Server + +[`garth-mcp-server`](https://github.com/matin/garth-mcp-server) is in early development. +Contributions are greatly appreciated. + +To generate your `GARTH_TOKEN`, use `uvx garth login`. +For China, do `uvx garth --domain garmin.cn login`. + +## Google Colabs + +### [Stress: 28-day rolling average](https://colab.research.google.com/github/matin/garth/blob/main/colabs/stress.ipynb) + +Stress levels from one day to another can vary by extremes, but there's always +a general trend. Using a scatter plot with a rolling average shows both the +individual days and the trend. The Colab retrieves up to three years of daily +data. If there's less than three years of data, it retrieves whatever is +available. + +![Stress: Garph of 28-day rolling average]( + https://github.com/matin/garth/assets/98985/868ecf25-4644-4879-b28f-ed0706a9e7b9) + +### [Sleep analysis over 90 days](https://colab.research.google.com/github/matin/garth/blob/main/colabs/sleep.ipynb) + +The Garmin Connect app only shows a maximum of seven days for sleep +stages—making it hard to see trends. The Connect API supports retrieving +daily sleep quality in 28-day pages, but that doesn't show details. Using +`SleedData.list()` gives us the ability to retrieve an arbitrary number of +day with enough detail to product a stacked bar graph of the daily sleep +stages. + +![Sleep stages over 90 days]( + https://github.com/matin/garth/assets/98985/ba678baf-0c8a-4907-aa91-be43beec3090) + +One specific graph that's useful but not available in the Connect app is +sleep start and end times over an extended period. This provides context +to the sleep hours and stages. + +![Sleep times over 90 days]( + https://github.com/matin/garth/assets/98985/c5583b9e-ab8a-4b5c-bfe6-1cb0ca95d1de) + +### [ChatGPT analysis of Garmin stats](https://colab.research.google.com/github/matin/garth/blob/main/colabs/chatgpt_analysis_of_stats.ipynb) + +ChatGPT's Advanced Data Analysis took can provide incredible insight +into the data in a way that's much simpler than using Pandas and Matplotlib. + +Start by using the linked Colab to download a CSV of the last three years +of your stats, and upload the CSV to ChatGPT. + +Here's the outputs of the following prompts: + +How do I sleep on different days of the week? + +image + +On what days do I exercise the most? + +image + +Magic! + +## Background + +Garth is meant for personal use and follows the philosophy that your data is +your data. You should be able to download it and analyze it in the way that +you'd like. In my case, that means processing with Google Colab, Pandas, +Matplotlib, etc. + +There are already a few Garmin Connect libraries. Why write another? + +### Authentication and stability + +The most important reasoning is to build a library with authentication that +works on [Google Colab](https://colab.research.google.com/) and doesn't require +tools like Cloudscraper. Garth, in comparison: + +1. Uses OAuth1 and OAuth2 token authentication after initial login +1. OAuth1 token survives for a year +1. Supports MFA +1. Auto-refresh of OAuth2 token when expired +1. Works on Google Colab +1. Uses Pydantic dataclasses to validate and simplify use of data +1. Full test coverage + +### JSON vs HTML + +Using `garth.connectapi()` allows you to make requests to the Connect API +and receive JSON vs needing to parse HTML. You can use the same endpoints the +mobile app uses. + +This also goes back to authentication. Garth manages the necessary Bearer +Authentication (along with auto-refresh) necessary to make requests routed to +the Connect API. + +## Instructions + +### Install + +```bash +python -m pip install garth +``` + +### Clone, setup environment and run tests + +```bash +gh repo clone matin/garth +cd garth +make install +make +``` + +Use `make help` to see all the options. + +### Authenticate and save session + +```python +import garth +from getpass import getpass + +email = input("Enter email address: ") +password = getpass("Enter password: ") +# If there's MFA, you'll be prompted during the login +garth.login(email, password) + +garth.save("~/.garth") +``` + +### Custom MFA handler + +By default, MFA will prompt for the code in the terminal. You can provide your +own handler: + +```python +garth.login(email, password, prompt_mfa=lambda: input("Enter MFA code: ")) +``` + +For advanced use cases (like async handling), MFA can be handled separately: + +```python +result1, result2 = garth.login(email, password, return_on_mfa=True) +if result1 == "needs_mfa": # MFA is required + mfa_code = "123456" # Get this from your custom MFA flow + oauth1, oauth2 = garth.resume_login(result2, mfa_code) +``` + +### Configure + +#### Set domain for China + +```python +garth.configure(domain="garmin.cn") +``` + +#### Proxy through Charles + +```python +garth.configure(proxies={"https": "http://localhost:8888"}, ssl_verify=False) +``` + +### Attempt to resume session + +```python +import garth +from garth.exc import GarthException + +garth.resume("~/.garth") +try: + garth.client.username +except GarthException: + # Session is expired. You'll need to log in again +``` + +## Connect API + +### Daily details + +```python +sleep = garth.connectapi( + f"/wellness-service/wellness/dailySleepData/{garth.client.username}", + params={"date": "2023-07-05", "nonSleepBufferMinutes": 60}, +) +list(sleep.keys()) +``` + +```json +[ + "dailySleepDTO", + "sleepMovement", + "remSleepData", + "sleepLevels", + "sleepRestlessMoments", + "restlessMomentsCount", + "wellnessSpO2SleepSummaryDTO", + "wellnessEpochSPO2DataDTOList", + "wellnessEpochRespirationDataDTOList", + "sleepStress" +] +``` + +### Stats + +```python +stress = garth.connectapi("/usersummary-service/stats/stress/weekly/2023-07-05/52") +``` + +```json +{ + "calendarDate": "2023-07-13", + "values": { + "highStressDuration": 2880, + "lowStressDuration": 10140, + "overallStressLevel": 33, + "restStressDuration": 30960, + "mediumStressDuration": 8760 + } +} +``` + +## Upload + +```python +with open("12129115726_ACTIVITY.fit", "rb") as f: + uploaded = garth.client.upload(f) +``` + +Note: Garmin doesn't accept uploads of _structured_ FIT files as outlined in +[this conversation](https://github.com/matin/garth/issues/27). FIT files +generated from workouts are accepted without issues. + +```python +{ + 'detailedImportResult': { + 'uploadId': 212157427938, + 'uploadUuid': { + 'uuid': '6e56051d-1dd4-4f2c-b8ba-00a1a7d82eb3' + }, + 'owner': 2591602, + 'fileSize': 5289, + 'processingTime': 36, + 'creationDate': '2023-09-29 01:58:19.113 GMT', + 'ipAddress': None, + 'fileName': '12129115726_ACTIVITY.fit', + 'report': None, + 'successes': [], + 'failures': [] + } +} +``` + +## Stats resources + +### Stress + +Daily stress levels + +```python +DailyStress.list("2023-07-23", 2) +``` + +```python +[ + DailyStress( + calendar_date=datetime.date(2023, 7, 22), + overall_stress_level=31, + rest_stress_duration=31980, + low_stress_duration=23820, + medium_stress_duration=7440, + high_stress_duration=1500 + ), + DailyStress( + calendar_date=datetime.date(2023, 7, 23), + overall_stress_level=26, + rest_stress_duration=38220, + low_stress_duration=22500, + medium_stress_duration=2520, + high_stress_duration=300 + ) +] +``` + +Weekly stress levels + +```python +WeeklyStress.list("2023-07-23", 2) +``` + +```python +[ + WeeklyStress(calendar_date=datetime.date(2023, 7, 10), value=33), + WeeklyStress(calendar_date=datetime.date(2023, 7, 17), value=32) +] +``` + +### Body Battery + +Daily Body Battery and stress data + +```python +garth.DailyBodyBatteryStress.get("2023-07-20") +``` + +```python +DailyBodyBatteryStress( + user_profile_pk=2591602, + calendar_date=datetime.date(2023, 7, 20), + start_timestamp_gmt=datetime.datetime(2023, 7, 20, 6, 0), + end_timestamp_gmt=datetime.datetime(2023, 7, 21, 5, 59, 59, 999000), + start_timestamp_local=datetime.datetime(2023, 7, 19, 23, 0), + end_timestamp_local=datetime.datetime(2023, 7, 20, 22, 59, 59, 999000), + max_stress_level=85, + avg_stress_level=25, + stress_chart_value_offset=0, + stress_chart_y_axis_origin=0, + stress_values_array=[ + [1689811800000, 12], [1689812100000, 18], [1689812400000, 15], + [1689815700000, 45], [1689819300000, 85], [1689822900000, 35], + [1689826500000, 20], [1689830100000, 15], [1689833700000, 25], + [1689837300000, 30] + ], + body_battery_values_array=[ + [1689811800000, 'charging', 45, 1.0], [1689812100000, 'charging', 48, 1.0], + [1689812400000, 'charging', 52, 1.0], [1689815700000, 'charging', 65, 1.0], + [1689819300000, 'draining', 85, 1.0], [1689822900000, 'draining', 75, 1.0], + [1689826500000, 'draining', 65, 1.0], [1689830100000, 'draining', 55, 1.0], + [1689833700000, 'draining', 45, 1.0], [1689837300000, 'draining', 35, 1.0], + [1689840900000, 'draining', 25, 1.0] + ] +) + +# Access derived properties +daily_bb = garth.DailyBodyBatteryStress.get("2023-07-20") +daily_bb.current_body_battery # 25 (last reading) +daily_bb.max_body_battery # 85 +daily_bb.min_body_battery # 25 +daily_bb.body_battery_change # -20 (45 -> 25) + +# Access structured readings +for reading in daily_bb.body_battery_readings: + print(f"Level: {reading.level}, Status: {reading.status}") + # Level: 45, Status: charging + # Level: 48, Status: charging + # ... etc + +for reading in daily_bb.stress_readings: + print(f"Stress: {reading.stress_level}") + # Stress: 12 + # Stress: 18 + # ... etc +``` + +Body Battery events (sleep events) + +```python +garth.BodyBatteryData.get("2023-07-20") +``` + +```python +[ + BodyBatteryData( + event=BodyBatteryEvent( + event_type='sleep', + event_start_time_gmt=datetime.datetime(2023, 7, 19, 21, 30), + timezone_offset=-25200000, + duration_in_milliseconds=28800000, + body_battery_impact=35, + feedback_type='good_sleep', + short_feedback='Good sleep restored your Body Battery' + ), + activity_name=None, + activity_type=None, + activity_id=None, + average_stress=15.5, + stress_values_array=[ + [1689811800000, 12], [1689812100000, 18], [1689812400000, 15] + ], + body_battery_values_array=[ + [1689811800000, 'charging', 45, 1.0], + [1689812100000, 'charging', 48, 1.0], + [1689812400000, 'charging', 52, 1.0], + [1689840600000, 'draining', 85, 1.0] + ] + ) +] + +# Access convenience properties on each event +events = garth.BodyBatteryData.get("2023-07-20") +event = events[0] +event.current_level # 85 (last reading) +event.max_level # 85 +event.min_level # 45 +``` + +### Hydration + +Daily hydration data + +```python +garth.DailyHydration.list(period=2) +``` + +```python +[ + DailyHydration( + calendar_date=datetime.date(2024, 6, 29), + value_in_ml=1750.0, + goal_in_ml=2800.0 + ) +] +``` + +### Steps + +Daily steps + +```python +garth.DailySteps.list(period=2) +``` + +```python +[ + DailySteps( + calendar_date=datetime.date(2023, 7, 28), + total_steps=6510, + total_distance=5552, + step_goal=8090 + ), + DailySteps( + calendar_date=datetime.date(2023, 7, 29), + total_steps=7218, + total_distance=6002, + step_goal=7940 + ) +] +``` + +Weekly steps + +```python +garth.WeeklySteps.list(period=2) +``` + +```python +[ + WeeklySteps( + calendar_date=datetime.date(2023, 7, 16), + total_steps=42339, + average_steps=6048.428571428572, + average_distance=5039.285714285715, + total_distance=35275.0, + wellness_data_days_count=7 + ), + WeeklySteps( + calendar_date=datetime.date(2023, 7, 23), + total_steps=56420, + average_steps=8060.0, + average_distance=7198.142857142857, + total_distance=50387.0, + wellness_data_days_count=7 + ) +] +``` + +### Intensity Minutes + +Daily intensity minutes + +```python +garth.DailyIntensityMinutes.list(period=2) +``` + +```python +[ + DailyIntensityMinutes( + calendar_date=datetime.date(2023, 7, 28), + weekly_goal=150, + moderate_value=0, + vigorous_value=0 + ), + DailyIntensityMinutes( + calendar_date=datetime.date(2023, 7, 29), + weekly_goal=150, + moderate_value=0, + vigorous_value=0 + ) +] +``` + +Weekly intensity minutes + +```python +garth.WeeklyIntensityMinutes.list(period=2) +``` + +```python +[ + WeeklyIntensityMinutes( + calendar_date=datetime.date(2023, 7, 17), + weekly_goal=150, + moderate_value=103, + vigorous_value=9 + ), + WeeklyIntensityMinutes( + calendar_date=datetime.date(2023, 7, 24), + weekly_goal=150, + moderate_value=101, + vigorous_value=105 + ) +] +``` + +### HRV + +Daily HRV + +```python +garth.DailyHRV.list(period=2) +``` + +```python +[ + DailyHRV( + calendar_date=datetime.date(2023, 7, 28), + weekly_avg=39, + last_night_avg=36, + last_night_5_min_high=52, + baseline=HRVBaseline( + low_upper=36, + balanced_low=39, + balanced_upper=51, + marker_value=0.25 + ), + status='BALANCED', + feedback_phrase='HRV_BALANCED_2', + create_time_stamp=datetime.datetime(2023, 7, 28, 12, 40, 16, 785000) + ), + DailyHRV( + calendar_date=datetime.date(2023, 7, 29), + weekly_avg=40, + last_night_avg=41, + last_night_5_min_high=76, + baseline=HRVBaseline( + low_upper=36, + balanced_low=39, + balanced_upper=51, + marker_value=0.2916565 + ), + status='BALANCED', + feedback_phrase='HRV_BALANCED_8', + create_time_stamp=datetime.datetime(2023, 7, 29, 13, 45, 23, 479000) + ) +] +``` + +Detailed HRV data + +```python +garth.HRVData.get("2023-07-20") +``` + +```python +HRVData( + user_profile_pk=2591602, + hrv_summary=HRVSummary( + calendar_date=datetime.date(2023, 7, 20), + weekly_avg=39, + last_night_avg=42, + last_night_5_min_high=66, + baseline=Baseline( + low_upper=36, + balanced_low=39, + balanced_upper=52, + marker_value=0.25 + ), + status='BALANCED', + feedback_phrase='HRV_BALANCED_7', + create_time_stamp=datetime.datetime(2023, 7, 20, 12, 14, 11, 898000) + ), + hrv_readings=[ + HRVReading( + hrv_value=54, + reading_time_gmt=datetime.datetime(2023, 7, 20, 5, 29, 48), + reading_time_local=datetime.datetime(2023, 7, 19, 23, 29, 48) + ), + HRVReading( + hrv_value=56, + reading_time_gmt=datetime.datetime(2023, 7, 20, 5, 34, 48), + reading_time_local=datetime.datetime(2023, 7, 19, 23, 34, 48) + ), + # ... truncated for brevity + HRVReading( + hrv_value=38, + reading_time_gmt=datetime.datetime(2023, 7, 20, 12, 9, 48), + reading_time_local=datetime.datetime(2023, 7, 20, 6, 9, 48) + ) + ], + start_timestamp_gmt=datetime.datetime(2023, 7, 20, 5, 25), + end_timestamp_gmt=datetime.datetime(2023, 7, 20, 12, 9, 48), + start_timestamp_local=datetime.datetime(2023, 7, 19, 23, 25), + end_timestamp_local=datetime.datetime(2023, 7, 20, 6, 9, 48), + sleep_start_timestamp_gmt=datetime.datetime(2023, 7, 20, 5, 25), + sleep_end_timestamp_gmt=datetime.datetime(2023, 7, 20, 12, 11), + sleep_start_timestamp_local=datetime.datetime(2023, 7, 19, 23, 25), + sleep_end_timestamp_local=datetime.datetime(2023, 7, 20, 6, 11) +) +``` + +### Sleep + +Daily sleep quality + +```python +garth.DailySleep.list("2023-07-23", 2) +``` + +```python +[ + DailySleep(calendar_date=datetime.date(2023, 7, 22), value=69), + DailySleep(calendar_date=datetime.date(2023, 7, 23), value=73) +] +``` + +Detailed sleep data + +```python +garth.SleepData.get("2023-07-20") +``` + +```python +SleepData( + daily_sleep_dto=DailySleepDTO( + id=1689830700000, + user_profile_pk=2591602, + calendar_date=datetime.date(2023, 7, 20), + sleep_time_seconds=23700, + nap_time_seconds=0, + sleep_window_confirmed=True, + sleep_window_confirmation_type='enhanced_confirmed_final', + sleep_start_timestamp_gmt=datetime.datetime(2023, 7, 20, 5, 25, tzinfo=TzInfo(UTC)), + sleep_end_timestamp_gmt=datetime.datetime(2023, 7, 20, 12, 11, tzinfo=TzInfo(UTC)), + sleep_start_timestamp_local=datetime.datetime(2023, 7, 19, 23, 25, tzinfo=TzInfo(UTC)), + sleep_end_timestamp_local=datetime.datetime(2023, 7, 20, 6, 11, tzinfo=TzInfo(UTC)), + unmeasurable_sleep_seconds=0, + deep_sleep_seconds=9660, + light_sleep_seconds=12600, + rem_sleep_seconds=1440, + awake_sleep_seconds=660, + device_rem_capable=True, + retro=False, + sleep_from_device=True, + sleep_version=2, + awake_count=1, + sleep_scores=SleepScores( + total_duration=Score( + qualifier_key='FAIR', + optimal_start=28800.0, + optimal_end=28800.0, + value=None, + ideal_start_in_seconds=None, + deal_end_in_seconds=None + ), + stress=Score( + qualifier_key='FAIR', + optimal_start=0.0, + optimal_end=15.0, + value=None, + ideal_start_in_seconds=None, + ideal_end_in_seconds=None + ), + awake_count=Score( + qualifier_key='GOOD', + optimal_start=0.0, + optimal_end=1.0, + value=None, + ideal_start_in_seconds=None, + ideal_end_in_seconds=None + ), + overall=Score( + qualifier_key='FAIR', + optimal_start=None, + optimal_end=None, + value=68, + ideal_start_in_seconds=None, + ideal_end_in_seconds=None + ), + rem_percentage=Score( + qualifier_key='POOR', + optimal_start=21.0, + optimal_end=31.0, + value=6, + ideal_start_in_seconds=4977.0, + ideal_end_in_seconds=7347.0 + ), + restlessness=Score( + qualifier_key='EXCELLENT', + optimal_start=0.0, + optimal_end=5.0, + value=None, + ideal_start_in_seconds=None, + ideal_end_in_seconds=None + ), + light_percentage=Score( + qualifier_key='EXCELLENT', + optimal_start=30.0, + optimal_end=64.0, + value=53, + ideal_start_in_seconds=7110.0, + ideal_end_in_seconds=15168.0 + ), + deep_percentage=Score( + qualifier_key='EXCELLENT', + optimal_start=16.0, + optimal_end=33.0, + value=41, + ideal_start_in_seconds=3792.0, + ideal_end_in_seconds=7821.0 + ) + ), + auto_sleep_start_timestamp_gmt=None, + auto_sleep_end_timestamp_gmt=None, + sleep_quality_type_pk=None, + sleep_result_type_pk=None, + average_sp_o2_value=92.0, + lowest_sp_o2_value=87, + highest_sp_o2_value=100, + average_sp_o2_hr_sleep=53.0, + average_respiration_value=14.0, + lowest_respiration_value=12.0, + highest_respiration_value=16.0, + avg_sleep_stress=17.0, + age_group='ADULT', + sleep_score_feedback='NEGATIVE_NOT_ENOUGH_REM', + sleep_score_insight='NONE' + ), + sleep_movement=[ + SleepMovement( + start_gmt=datetime.datetime(2023, 7, 20, 4, 25), + end_gmt=datetime.datetime(2023, 7, 20, 4, 26), + activity_level=5.688743692980419 + ), + SleepMovement( + start_gmt=datetime.datetime(2023, 7, 20, 4, 26), + end_gmt=datetime.datetime(2023, 7, 20, 4, 27), + activity_level=5.318763075304898 + ), + # ... truncated for brevity + SleepMovement( + start_gmt=datetime.datetime(2023, 7, 20, 13, 10), + end_gmt=datetime.datetime(2023, 7, 20, 13, 11), + activity_level=7.088729101943337 + ) + ] +) +``` + +List sleep data over several nights. + +```python +garth.SleepData.list("2023-07-20", 30) +``` + +### Weight + +Retrieve the latest weight measurement and body composition data for a given +date. + +**Note**: Weight, weight delta, bone mass, and muscle mass values are measured +in grams + +```python +garth.WeightData.get("2025-06-01") +``` + +```python +WeightData( + sample_pk=1749996902851, + calendar_date=datetime.date(2025, 6, 15), + weight=59720, + source_type='INDEX_SCALE', + weight_delta=200.00000000000284, + timestamp_gmt=1749996876000, + datetime_utc=datetime.datetime(2025, 6, 15, 14, 14, 36, tzinfo=TzInfo(UTC)), + datetime_local=datetime.datetime( + 2025, 6, 15, 8, 14, 36, + tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=64800)) + ), + bmi=22.799999237060547, + body_fat=19.3, + body_water=58.9, + bone_mass=3539, + muscle_mass=26979, + physique_rating=None, + visceral_fat=None, + metabolic_age=None +) +``` + +Get weight entries for a date range. + +```python +garth.WeightData.list("2025-06-01", 30) +``` + +```python +[ + WeightData( + sample_pk=1749307692871, + calendar_date=datetime.date(2025, 6, 7), + weight=59189, + source_type='INDEX_SCALE', + weight_delta=500.0, + timestamp_gmt=1749307658000, + datetime_utc=datetime.datetime(2025, 6, 7, 14, 47, 38, tzinfo=TzInfo(UTC)), + datetime_local=datetime.datetime( + 2025, 6, 7, 8, 47, 38, + tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=64800)) + ), + bmi=22.600000381469727, + body_fat=20.0, + body_water=58.4, + bone_mass=3450, + muscle_mass=26850, + physique_rating=None, + visceral_fat=None, + metabolic_age=None + ), + WeightData( + sample_pk=1749909217098, + calendar_date=datetime.date(2025, 6, 14), + weight=59130, + source_type='INDEX_SCALE', + weight_delta=-100.00000000000142, + timestamp_gmt=1749909180000, + datetime_utc=datetime.datetime(2025, 6, 14, 13, 53, tzinfo=TzInfo(UTC)), + datetime_local=datetime.datetime( + 2025, 6, 14, 7, 53, + tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=64800)) + ), + bmi=22.5, + body_fat=20.3, + body_water=58.2, + bone_mass=3430, + muscle_mass=26840, + physique_rating=None, + visceral_fat=None, + metabolic_age=None + ), + WeightData( + sample_pk=1749948744411, + calendar_date=datetime.date(2025, 6, 14), + weight=59500, + source_type='MANUAL', + weight_delta=399.9999999999986, + timestamp_gmt=1749948725175, + datetime_utc=datetime.datetime( + 2025, 6, 15, 0, 52, 5, 175000, tzinfo=TzInfo(UTC) + ), + datetime_local=datetime.datetime( + 2025, 6, 14, 18, 52, 5, 175000, + tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=64800)) + ), + bmi=None, + body_fat=None, + body_water=None, + bone_mass=None, + muscle_mass=None, + physique_rating=None, + visceral_fat=None, + metabolic_age=None + ), + WeightData( + sample_pk=1749996902851, + calendar_date=datetime.date(2025, 6, 15), + weight=59720, + source_type='INDEX_SCALE', + weight_delta=200.00000000000284, + timestamp_gmt=1749996876000, + datetime_utc=datetime.datetime(2025, 6, 15, 14, 14, 36, tzinfo=TzInfo(UTC)), + datetime_local=datetime.datetime( + 2025, 6, 15, 8, 14, 36, + tzinfo=datetime.timezone(datetime.timedelta(days=-1, seconds=64800)) + ), + bmi=22.799999237060547, + body_fat=19.3, + body_water=58.9, + bone_mass=3539, + muscle_mass=26979, + physique_rating=None, + visceral_fat=None, + metabolic_age=None + ) +] +``` + +## User + +### UserProfile + +```python +garth.UserProfile.get() +``` + +```python +UserProfile( + id=3154645, + profile_id=2591602, + garmin_guid="0690cc1d-d23d-4412-b027-80fd4ed1c0f6", + display_name="mtamizi", + full_name="Matin Tamizi", + user_name="mtamizi", + profile_image_uuid="73240e81-6e4d-43fc-8af8-c8f6c51b3b8f", + profile_image_url_large=( + "https://s3.amazonaws.com/garmin-connect-prod/profile_images/" + "73240e81-6e4d-43fc-8af8-c8f6c51b3b8f-2591602.png" + ), + profile_image_url_medium=( + "https://s3.amazonaws.com/garmin-connect-prod/profile_images/" + "685a19e9-a7be-4a11-9bf9-faca0c5d1f1a-2591602.png" + ), + profile_image_url_small=( + "https://s3.amazonaws.com/garmin-connect-prod/profile_images/" + "6302f021-0ec7-4dc9-b0c3-d5a19bc5a08c-2591602.png" + ), + location="Ciudad de México, CDMX", + facebook_url=None, + twitter_url=None, + personal_website=None, + motivation=None, + bio=None, + primary_activity=None, + favorite_activity_types=[], + running_training_speed=0.0, + cycling_training_speed=0.0, + favorite_cycling_activity_types=[], + cycling_classification=None, + cycling_max_avg_power=0.0, + swimming_training_speed=0.0, + profile_visibility="private", + activity_start_visibility="private", + activity_map_visibility="public", + course_visibility="public", + activity_heart_rate_visibility="public", + activity_power_visibility="public", + badge_visibility="private", + show_age=False, + show_weight=False, + show_height=False, + show_weight_class=False, + show_age_range=False, + show_gender=False, + show_activity_class=False, + show_vo_2_max=False, + show_personal_records=False, + show_last_12_months=False, + show_lifetime_totals=False, + show_upcoming_events=False, + show_recent_favorites=False, + show_recent_device=False, + show_recent_gear=False, + show_badges=True, + other_activity=None, + other_primary_activity=None, + other_motivation=None, + user_roles=[ + "SCOPE_ATP_READ", + "SCOPE_ATP_WRITE", + "SCOPE_COMMUNITY_COURSE_READ", + "SCOPE_COMMUNITY_COURSE_WRITE", + "SCOPE_CONNECT_READ", + "SCOPE_CONNECT_WRITE", + "SCOPE_DT_CLIENT_ANALYTICS_WRITE", + "SCOPE_GARMINPAY_READ", + "SCOPE_GARMINPAY_WRITE", + "SCOPE_GCOFFER_READ", + "SCOPE_GCOFFER_WRITE", + "SCOPE_GHS_SAMD", + "SCOPE_GHS_UPLOAD", + "SCOPE_GOLF_API_READ", + "SCOPE_GOLF_API_WRITE", + "SCOPE_INSIGHTS_READ", + "SCOPE_INSIGHTS_WRITE", + "SCOPE_PRODUCT_SEARCH_READ", + "ROLE_CONNECTUSER", + "ROLE_FITNESS_USER", + "ROLE_WELLNESS_USER", + "ROLE_OUTDOOR_USER", + "ROLE_CONNECT_2_USER", + "ROLE_TACX_APP_USER", + ], + name_approved=True, + user_profile_full_name="Matin Tamizi", + make_golf_scorecards_private=True, + allow_golf_live_scoring=False, + allow_golf_scoring_by_connections=True, + user_level=3, + user_point=118, + level_update_date="2020-12-12T15:20:38.0", + level_is_viewed=False, + level_point_threshold=140, + user_point_offset=0, + user_pro=False, +) +``` + +### UserSettings + +```python +garth.UserSettings.get() +``` + +```python +UserSettings( + id=2591602, + user_data=UserData( + gender="MALE", + weight=83000.0, + height=182.0, + time_format="time_twenty_four_hr", + birth_date=datetime.date(1984, 10, 17), + measurement_system="metric", + activity_level=None, + handedness="RIGHT", + power_format=PowerFormat( + format_id=30, + format_key="watt", + min_fraction=0, + max_fraction=0, + grouping_used=True, + display_format=None, + ), + heart_rate_format=PowerFormat( + format_id=21, + format_key="bpm", + min_fraction=0, + max_fraction=0, + grouping_used=False, + display_format=None, + ), + first_day_of_week=FirstDayOfWeek( + day_id=2, + day_name="sunday", + sort_order=2, + is_possible_first_day=True, + ), + vo_2_max_running=45.0, + vo_2_max_cycling=None, + lactate_threshold_speed=0.34722125000000004, + lactate_threshold_heart_rate=None, + dive_number=None, + intensity_minutes_calc_method="AUTO", + moderate_intensity_minutes_hr_zone=3, + vigorous_intensity_minutes_hr_zone=4, + hydration_measurement_unit="milliliter", + hydration_containers=[], + hydration_auto_goal_enabled=True, + firstbeat_max_stress_score=None, + firstbeat_cycling_lt_timestamp=None, + firstbeat_running_lt_timestamp=1044719868, + threshold_heart_rate_auto_detected=True, + ftp_auto_detected=None, + training_status_paused_date=None, + weather_location=None, + golf_distance_unit="statute_us", + golf_elevation_unit=None, + golf_speed_unit=None, + external_bottom_time=None, + ), + user_sleep=UserSleep( + sleep_time=80400, + default_sleep_time=False, + wake_time=24000, + default_wake_time=False, + ), + connect_date=None, + source_type=None, +) +``` + +## Star History + + + + + + Star History Chart + + diff --git a/garth/colabs/chatgpt_analysis_of_stats.ipynb b/garth/colabs/chatgpt_analysis_of_stats.ipynb new file mode 100644 index 0000000..136d25b --- /dev/null +++ b/garth/colabs/chatgpt_analysis_of_stats.ipynb @@ -0,0 +1,1084 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyNzwzBxhj/ENtPvpC3sc3iq", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "b7d1a1e77d344a8e9b65fa0887859b6f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ButtonModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ButtonView", + "button_style": "", + "description": "Download CSV", + "disabled": false, + "icon": "", + "layout": "IPY_MODEL_f4c0da5a7d7641bdab1fdf2d2a5a434c", + "style": "IPY_MODEL_c57ce657dd1b49bea27a6d5f9f232205", + "tooltip": "" + } + }, + "f4c0da5a7d7641bdab1fdf2d2a5a434c": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c57ce657dd1b49bea27a6d5f9f232205": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ButtonStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ButtonStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "button_color": null, + "font_weight": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# chatGPT analysis of Garmin stats" + ], + "metadata": { + "id": "gsR7Ay0KuqGl" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Setup" + ], + "metadata": { + "id": "AuY_RBBruxkA" + } + }, + { + "cell_type": "markdown", + "source": [ + "Install [Garth](https://github.com/matin/garth) to download stats from Garmin Connect." + ], + "metadata": { + "id": "yg5Hzyrbu2SV" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "2YBVvyYJnRug" + }, + "outputs": [], + "source": [ + "%pip install garth >& /dev/null" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Set location of session tokens." + ], + "metadata": { + "id": "ZTzxkfQQu-fJ" + } + }, + { + "cell_type": "code", + "source": [ + "GARTH_HOME = \"drive/MyDrive/garth\"" + ], + "metadata": { + "id": "FPkG6WzOnfdP" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Mount Google Drive to access session tokens." + ], + "metadata": { + "id": "QeSi-VipvBa3" + } + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount(\"/content/drive\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5nWiUmA5nh8k", + "outputId": "f8acf58a-3275-4b6f-b2b5-05c85a4585af" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Attempt to resume session. Otherwise, log in. Save updated session in both cases." + ], + "metadata": { + "id": "youB5vWsvGwv" + } + }, + { + "cell_type": "code", + "source": [ + "import garth\n", + "from garth.exc import GarthException\n", + "from getpass import getpass\n", + "\n", + "try:\n", + " garth.resume(GARTH_HOME)\n", + " garth.client.username\n", + "except (FileNotFoundError, GarthException):\n", + " email = input(\"Email: \")\n", + " password = getpass(\"Password: \")\n", + " garth.client.login(email, password)\n", + "\n", + "garth.save(GARTH_HOME)" + ], + "metadata": { + "id": "jFYjpHMwnmRF" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Import Pandas and define period for analysis." + ], + "metadata": { + "id": "s09TVMCTvSEy" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "\n", + "DAYS = 365 * 3" + ], + "metadata": { + "id": "r18SHYm6n_i9" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Query stats" + ], + "metadata": { + "id": "fHsEkJQNo_o0" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Sleep" + ], + "metadata": { + "id": "JFdWsRJHnw1H" + } + }, + { + "cell_type": "code", + "source": [ + "from datetime import timedelta\n", + "\n", + "sleep = pd.DataFrame(garth.DailySleep.list(period=DAYS))\n", + "sleep[\"calendar_date\"] = sleep[\"calendar_date\"].apply(lambda x: x - timedelta(days=1))\n", + "sleep.set_index(\"calendar_date\", inplace=True)\n", + "sleep.rename(columns={\"value\": \"sleep_quality\"}, inplace=True)" + ], + "metadata": { + "id": "cKH4pkwtoHt9" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Steps" + ], + "metadata": { + "id": "KXe5NV8HoYxZ" + } + }, + { + "cell_type": "code", + "source": [ + "steps = pd.DataFrame(garth.DailySteps.list(period=DAYS))\n", + "steps.set_index(\"calendar_date\", inplace=True)" + ], + "metadata": { + "id": "uaG8YTPjobC8" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Stress" + ], + "metadata": { + "id": "YbV8jW-QofcS" + } + }, + { + "cell_type": "code", + "source": [ + "stress = pd.DataFrame(garth.DailyStress.list(period=DAYS))\n", + "stress.set_index(\"calendar_date\", inplace=True)\n", + "stress[\"high_stress_duration\"].fillna(0, inplace=True)\n", + "stress[\"medium_stress_duration\"].fillna(0, inplace=True)" + ], + "metadata": { + "id": "lThQ23Rjog-Z" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Intensity minutes" + ], + "metadata": { + "id": "-NjiZ8OKoj3-" + } + }, + { + "cell_type": "code", + "source": [ + "im = pd.DataFrame(garth.DailyIntensityMinutes.list(period=DAYS))\n", + "im.set_index(\"calendar_date\", inplace=True)\n", + "im[\"intensity_minutes\"] = im[\"moderate_value\"] + 2 * im[\"vigorous_value\"]\n", + "im.rename(\n", + " columns={\n", + " \"weekly_goal\": \"intensity_minutes_goal\",\n", + " \"moderate_value\": \"moderate_intensity_minutes\",\n", + " \"vigorous_value\": \"vigorous_intensity_minutes\",\n", + " },\n", + " inplace=True\n", + ")" + ], + "metadata": { + "id": "9BcHMdXzol6U" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Join stats" + ], + "metadata": { + "id": "NEaoXU7JpCve" + } + }, + { + "cell_type": "code", + "source": [ + "stats = (\n", + " sleep\n", + " .join(steps)\n", + " .join(stress)\n", + " .join(im)\n", + ")\n", + "stats" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 475 + }, + "id": "hcLk5XzdpFZP", + "outputId": "9c7b40e3-7c58-4978-bcbe-38d20513199f" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " sleep_quality total_steps total_distance step_goal \\\n", + "calendar_date \n", + "2021-09-08 64 2728 2259 8830 \n", + "2021-09-09 65 7601 6338 7610 \n", + "2021-09-10 81 25646 19797 7610 \n", + "2021-09-11 0 6869 5701 9420 \n", + "2021-09-13 76 17210 15660 8970 \n", + "... ... ... ... ... \n", + "2023-09-27 85 6367 5349 8740 \n", + "2023-09-28 80 2363 2072 8510 \n", + "2023-09-29 86 11261 8675 7280 \n", + "2023-09-30 79 8130 6742 7680 \n", + "2023-10-01 46 25434 21006 7770 \n", + "\n", + " overall_stress_level rest_stress_duration \\\n", + "calendar_date \n", + "2021-09-08 26 50100 \n", + "2021-09-09 32 29100 \n", + "2021-09-10 31 30780 \n", + "2021-09-11 28 37380 \n", + "2021-09-13 37 25440 \n", + "... ... ... \n", + "2023-09-27 30 34980 \n", + "2023-09-28 29 40740 \n", + "2023-09-29 38 32880 \n", + "2023-09-30 29 42120 \n", + "2023-10-01 30 36900 \n", + "\n", + " low_stress_duration medium_stress_duration \\\n", + "calendar_date \n", + "2021-09-08 14400 10020 \n", + "2021-09-09 24420 8520 \n", + "2021-09-10 16500 5880 \n", + "2021-09-11 18720 7380 \n", + "2021-09-13 16440 13680 \n", + "... ... ... \n", + "2023-09-27 20460 6600 \n", + "2023-09-28 23580 8520 \n", + "2023-09-29 11520 11400 \n", + "2023-09-30 15660 9840 \n", + "2023-10-01 8640 7680 \n", + "\n", + " high_stress_duration intensity_minutes_goal \\\n", + "calendar_date \n", + "2021-09-08 1500.0 150 \n", + "2021-09-09 1680.0 150 \n", + "2021-09-10 4020.0 150 \n", + "2021-09-11 1020.0 150 \n", + "2021-09-13 4200.0 150 \n", + "... ... ... \n", + "2023-09-27 1200.0 150 \n", + "2023-09-28 1200.0 150 \n", + "2023-09-29 8160.0 150 \n", + "2023-09-30 900.0 150 \n", + "2023-10-01 4140.0 150 \n", + "\n", + " moderate_intensity_minutes vigorous_intensity_minutes \\\n", + "calendar_date \n", + "2021-09-08 0.0 0.0 \n", + "2021-09-09 0.0 0.0 \n", + "2021-09-10 117.0 46.0 \n", + "2021-09-11 0.0 0.0 \n", + "2021-09-13 7.0 41.0 \n", + "... ... ... \n", + "2023-09-27 0.0 0.0 \n", + "2023-09-28 0.0 0.0 \n", + "2023-09-29 44.0 2.0 \n", + "2023-09-30 0.0 0.0 \n", + "2023-10-01 77.0 56.0 \n", + "\n", + " intensity_minutes \n", + "calendar_date \n", + "2021-09-08 0.0 \n", + "2021-09-09 0.0 \n", + "2021-09-10 209.0 \n", + "2021-09-11 0.0 \n", + "2021-09-13 89.0 \n", + "... ... \n", + "2023-09-27 0.0 \n", + "2023-09-28 0.0 \n", + "2023-09-29 48.0 \n", + "2023-09-30 0.0 \n", + "2023-10-01 189.0 \n", + "\n", + "[743 rows x 13 columns]" + ], + "text/html": [ + "\n", + "
\n", + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sleep_qualitytotal_stepstotal_distancestep_goaloverall_stress_levelrest_stress_durationlow_stress_durationmedium_stress_durationhigh_stress_durationintensity_minutes_goalmoderate_intensity_minutesvigorous_intensity_minutesintensity_minutes
calendar_date
2021-09-0864272822598830265010014400100201500.01500.00.00.0
2021-09-096576016338761032291002442085201680.01500.00.00.0
2021-09-10812564619797761031307801650058804020.0150117.046.0209.0
2021-09-11068695701942028373801872073801020.01500.00.00.0
2021-09-137617210156608970372544016440136804200.01507.041.089.0
..........................................
2023-09-278563675349874030349802046066001200.01500.00.00.0
2023-09-288023632072851029407402358085201200.01500.00.00.0
2023-09-29861126186757280383288011520114008160.015044.02.048.0
2023-09-30798130674276802942120156609840900.01500.00.00.0
2023-10-0146254342100677703036900864076804140.015077.056.0189.0
\n", + "

743 rows × 13 columns

\n", + "
\n", + "
\n", + "\n", + "
\n", + " \n", + "\n", + " \n", + "\n", + " \n", + "
\n", + "\n", + "\n", + "
\n", + " \n", + "\n", + "\n", + "\n", + " \n", + "
\n", + "
\n", + "
\n" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Download as a CSV that can be uploaded to chatGPT." + ], + "metadata": { + "id": "DYpdJ-vwve6g" + } + }, + { + "cell_type": "code", + "source": [ + "from google.colab import files\n", + "from ipywidgets import widgets\n", + "from IPython.display import display\n", + "\n", + "def create_download_button(df, filename):\n", + " def export_csv(df):\n", + " df.to_csv(filename)\n", + " files.download(filename)\n", + "\n", + " button = widgets.Button(description=\"Download CSV\")\n", + " button.on_click(lambda b: export_csv(df))\n", + " display(button)\n", + "\n", + "create_download_button(stats, \"consolidated_garmin_stats.csv\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 49, + "referenced_widgets": [ + "b7d1a1e77d344a8e9b65fa0887859b6f", + "f4c0da5a7d7641bdab1fdf2d2a5a434c", + "c57ce657dd1b49bea27a6d5f9f232205" + ] + }, + "id": "nEbaWK7Dpqzj", + "outputId": "0781f65e-0e21-4bd7-ac88-00c3f4891cc5" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Button(description='Download CSV', style=ButtonStyle())" + ], + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "b7d1a1e77d344a8e9b65fa0887859b6f" + } + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## chatGPT data analysis" + ], + "metadata": { + "id": "G4lI4sPqt9Gj" + } + }, + { + "cell_type": "markdown", + "source": [ + "Upload the CSV to chatGPT and ask the following questions:" + ], + "metadata": { + "id": "Aw_VA0VHwwHD" + } + }, + { + "cell_type": "markdown", + "source": [ + "---" + ], + "metadata": { + "id": "zydPs3afw21Q" + } + }, + { + "cell_type": "markdown", + "source": [ + "How do I sleep on different days of the week?" + ], + "metadata": { + "id": "zirj_VC8uAsB" + } + }, + { + "cell_type": "markdown", + "source": [ + "![image.png](data:image/png;base64,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)" + ], + "metadata": { + "id": "TqFfxR2ExizU" + } + }, + { + "cell_type": "markdown", + "source": [ + "How does my sleep relate to the other stats? Is it correlated with any of the other stats?" + ], + "metadata": { + "id": "vscLdhVruWiw" + } + }, + { + "cell_type": "markdown", + "source": [ + "![image.png](data:image/png;base64,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)" + ], + "metadata": { + "id": "cbWEhT4axXx4" + } + }, + { + "cell_type": "markdown", + "source": [ + "On what days do I exercise the most?" + ], + "metadata": { + "id": "LyUsbbn6udDb" + } + }, + { + "cell_type": "markdown", + "source": [ + "![image.png](data:image/png;base64,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)" + ], + "metadata": { + "id": "DjKiCw35xx17" + } + } + ] +} \ No newline at end of file diff --git a/garth/colabs/sleep.ipynb b/garth/colabs/sleep.ipynb new file mode 100644 index 0000000..7671b58 --- /dev/null +++ b/garth/colabs/sleep.ipynb @@ -0,0 +1,478 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyMYSNpkyOfBAD4DCo+Yq+Qi", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Garmin sleep statistics" + ], + "metadata": { + "id": "BAdFqDSZ6kDc" + } + }, + { + "cell_type": "markdown", + "source": [ + "Start by installing and importing `garth`" + ], + "metadata": { + "id": "rYcdIQ0p7J0y" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "ImHEwwsi6U_C" + }, + "outputs": [], + "source": [ + "%pip install garth >& /dev/null" + ] + }, + { + "cell_type": "code", + "source": [ + "import garth" + ], + "metadata": { + "id": "2hqN2SWx7Msx" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Define Garth session location to save and resume sessions" + ], + "metadata": { + "id": "ZIgwOzTp7QPs" + } + }, + { + "cell_type": "code", + "source": [ + "GARTH_HOME = \"drive/MyDrive/garth\"" + ], + "metadata": { + "id": "rRY592o97W7m" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Mount Drive for saving and resuming sessions" + ], + "metadata": { + "id": "-7XcADH-7Z2B" + } + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount(\"/content/drive\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "E5ng79XD7cZG", + "outputId": "5d06cad9-4497-4d82-c772-17db34224b98" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Resume session or login, and make sure to save the garth session for next time" + ], + "metadata": { + "id": "RZwodyQw7iqq" + } + }, + { + "cell_type": "code", + "source": [ + "from garth.exc import GarthException\n", + "from getpass import getpass\n", + "\n", + "try:\n", + " garth.resume(GARTH_HOME)\n", + " garth.client.username\n", + "except (GarthException, FileNotFoundError):\n", + " email = input(\"Email: \")\n", + " password = getpass(\"Password: \")\n", + " garth.client.login(email, password)\n", + "\n", + "garth.save(GARTH_HOME)" + ], + "metadata": { + "id": "DEEIjPWn7lu5" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Daily sleep quality" + ], + "metadata": { + "id": "thTMuZ0w7-P_" + } + }, + { + "cell_type": "markdown", + "source": [ + "List sleep quality for the past 7 days" + ], + "metadata": { + "id": "hkkhxPqY8GMU" + } + }, + { + "cell_type": "code", + "source": [ + "garth.DailySleep.list(period=7)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "27r1VCJ98Bxz", + "outputId": "e6f36922-e992-4290-d37c-9316b33960a1" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[DailySleep(calendar_date=datetime.date(2023, 8, 10), value=79),\n", + " DailySleep(calendar_date=datetime.date(2023, 8, 11), value=68),\n", + " DailySleep(calendar_date=datetime.date(2023, 8, 12), value=73),\n", + " DailySleep(calendar_date=datetime.date(2023, 8, 13), value=70),\n", + " DailySleep(calendar_date=datetime.date(2023, 8, 14), value=75),\n", + " DailySleep(calendar_date=datetime.date(2023, 8, 15), value=28),\n", + " DailySleep(calendar_date=datetime.date(2023, 8, 16), value=42)]" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Let's take a look at the sleep quality for the past 90 days" + ], + "metadata": { + "id": "00pLOftd8OBZ" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.dates as mdates\n", + "\n", + "daily_sleep = pd.DataFrame(garth.DailySleep.list(period=90))\n", + "\n", + "daily_sleep[\"calendar_date\"] = pd.to_datetime(daily_sleep[\"calendar_date\"])\n", + "daily_sleep.set_index(\"calendar_date\", inplace=True)\n", + "\n", + "sns.set_theme()\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "sns.lineplot(data=daily_sleep, legend=False)\n", + "\n", + "plt.ylabel(None)\n", + "plt.xlabel(None)\n", + "plt.title(\"Daily Sleep Quality\")\n", + "\n", + "ax = plt.gca()\n", + "ax.xaxis.set_major_locator(mdates.MonthLocator())\n", + "ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%b %Y\"))\n", + "\n", + "plt.xticks(rotation=45, ha=\"right\")\n", + "\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 596 + }, + "id": "rIGthr8r8S70", + "outputId": "bcedb60b-4e51-48c2-c11d-0ca18a2794b1" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Daily sleep data (including stages)" + ], + "metadata": { + "id": "cGY4-x_68obc" + } + }, + { + "cell_type": "markdown", + "source": [ + "Determine the latest date with sleep data" + ], + "metadata": { + "id": "jrKkclxLvU61" + } + }, + { + "cell_type": "code", + "source": [ + "latest = garth.DailySleep.list(period=2)[-1].calendar_date" + ], + "metadata": { + "id": "Z08Kv62CvaFJ" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "The sleep data includes a tremendous amount of information and can only be fetched by day. Let\"s fetch every day for the 30 days leading up to yesterday" + ], + "metadata": { + "id": "EneDTjdO8zBG" + } + }, + { + "cell_type": "code", + "source": [ + "sleep_data = [sd.daily_sleep_dto for sd in garth.SleepData.list(latest, 90)]" + ], + "metadata": { + "id": "YWwxbPk19DUG" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Let's graph the sleep stages as a stacked bar graph" + ], + "metadata": { + "id": "Ppg1gskf-Lhz" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "df = pd.DataFrame(sleep_data)\n", + "\n", + "df[\"deep_sleep_hours\"] = (\n", + " df[\"deep_sleep_seconds\"] / 3600\n", + ")\n", + "df[\"light_sleep_hours\"] = (\n", + " df[\"light_sleep_seconds\"] / 3600\n", + ")\n", + "df[\"rem_sleep_hours\"] = (\n", + " df[\"rem_sleep_seconds\"] / 3600\n", + ")\n", + "df[\"awake_sleep_hours\"] = (\n", + " df[\"awake_sleep_seconds\"] / 3600\n", + ")\n", + "df[\"calendar_date\"] = (\n", + " pd.to_datetime(df[\"calendar_date\"]).dt.date\n", + ")\n", + "\n", + "df.sort_values(\"calendar_date\", inplace=True)\n", + "df.set_index(\"calendar_date\", inplace=True)\n", + "df.rename(columns={\n", + " \"deep_sleep_hours\": \"Deep\",\n", + " \"light_sleep_hours\": \"Light\",\n", + " \"rem_sleep_hours\": \"REM\",\n", + " \"awake_sleep_hours\": \"Awake\"\n", + "}, inplace=True)\n", + "\n", + "sns.set_theme()\n", + "\n", + "ax = df[[\"Deep\", \"Light\", \"REM\", \"Awake\"]].plot(\n", + " kind=\"bar\", stacked=True, figsize=(10, 6), grid=True, colormap=\"viridis\",\n", + " width=1\n", + ")\n", + "\n", + "plt.ylabel(\"Hours\")\n", + "plt.xlabel(None)\n", + "plt.title(\"Daily Sleep Stages\")\n", + "plt.grid(axis=\"x\")\n", + "plt.legend(loc=\"upper left\")\n", + "labels = ax.get_xticklabels()\n", + "ticks = ax.get_xticks()\n", + "ax.set_xticks([tick for i, tick in enumerate(ticks) if i % 4 == 0])\n", + "ax.set_xticklabels([label for i, label in enumerate(labels) if i % 4 == 0])\n", + "plt.xticks(rotation=45, ha=\"right\")\n", + "\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 607 + }, + "id": "nwmrTPLd-cUK", + "outputId": "9221b664-d535-4bce-83b9-c2b5f4a6ca98" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Look at the time of day for when we went to sleep and woke up" + ], + "metadata": { + "id": "WW6Ec4xDoNLo" + } + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "df = pd.DataFrame(sleep_data)\n", + "df.sort_values(\"calendar_date\", inplace=True)\n", + "df.set_index(\"calendar_date\", inplace=True)\n", + "\n", + "# Convert index to datetime\n", + "df.index = pd.to_datetime(df.index)\n", + "\n", + "# Get the provided timestamp columns (in milliseconds)\n", + "start_col = \"sleep_start_timestamp_local\"\n", + "end_col = \"sleep_end_timestamp_local\"\n", + "\n", + "# Convert the timestamps (in milliseconds) to hours and minutes\n", + "df[\"sleep_start_time\"] = pd.to_datetime(df[start_col], unit=\"ms\").dt.time\n", + "df[\"sleep_end_time\"] = pd.to_datetime(df[end_col], unit=\"ms\").dt.time\n", + "\n", + "# Convert time to hours, with 18:00 as the starting point\n", + "def convert_time(time_obj):\n", + " hours_from_18 = time_obj.hour + time_obj.minute / 60 - 18\n", + " return hours_from_18 if hours_from_18 >= 0 else hours_from_18 + 24\n", + "\n", + "df[\"sleep_start_hours\"] = df[\"sleep_start_time\"].apply(convert_time)\n", + "df[\"sleep_end_hours\"] = df[\"sleep_end_time\"].apply(convert_time)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10, 6))\n", + "sns.lineplot(data=df, x=df.index, y=\"sleep_start_hours\", label=\"Sleep Start\", marker=\"o\")\n", + "sns.lineplot(data=df, x=df.index, y=\"sleep_end_hours\", label=\"Sleep End\", marker=\"o\")\n", + "\n", + "# Formatting\n", + "plt.title(\"Sleep Start and End Time\")\n", + "plt.ylabel(\"Time of Day\")\n", + "plt.xlabel(\"Date\")\n", + "plt.grid(axis=\"x\")\n", + "plt.xticks(df.index[::4], rotation=45, ha=\"right\")\n", + "plt.yticks(range(0, 16, 2), [f\"{(h + 18) % 24:02d}:00\" for h in range(0, 16, 2)])\n", + "plt.ylim(0, 16)\n", + "plt.tight_layout()\n", + "plt.legend()\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 601 + }, + "id": "sojEiYKfXHab", + "outputId": "84bbeeb8-9688-408c-d08c-399f1978dbff" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/garth/colabs/stress.ipynb b/garth/colabs/stress.ipynb new file mode 100644 index 0000000..02fc952 --- /dev/null +++ b/garth/colabs/stress.ipynb @@ -0,0 +1,502 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "authorship_tag": "ABX9TyP9msPojyEmVietv9euZQ9H", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Garmin stress trends using [Garth](https://github.com/matin/garth) and Matplotlib" + ], + "metadata": { + "id": "xqeAMylmO463" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Setup" + ], + "metadata": { + "id": "NiV2vHQKPZYX" + } + }, + { + "cell_type": "markdown", + "source": [ + "Start by installing and importing Garth" + ], + "metadata": { + "id": "0f6OAsJZPSCv" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "0MyOQpfzOxY0" + }, + "outputs": [], + "source": [ + "%pip install garth >& /dev/null" + ] + }, + { + "cell_type": "code", + "source": [ + "import garth" + ], + "metadata": { + "id": "kzGuWE_FPGAc" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Define Garth access token location to save and resume sessions" + ], + "metadata": { + "id": "TuPanq3FPk9D" + } + }, + { + "cell_type": "code", + "source": [ + "GARTH_HOME = \"drive/MyDrive/garth\"" + ], + "metadata": { + "id": "bhS2hpwvPpV_" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Mount Drive for saving and resuming sessions" + ], + "metadata": { + "id": "0pvIcybePvMw" + } + }, + { + "cell_type": "code", + "source": [ + "from google.colab import drive\n", + "drive.mount(\"/content/drive\")" + ], + "metadata": { + "id": "Lgbzn6WfPzzh", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2a300c43-1651-470f-bc25-323e1a497416" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Attemt to resume session. If resuming the session fails or the path set for `GARTH_HOME` doesn't exist, log in. In both cases, save the new / updated session for future use." + ], + "metadata": { + "id": "RXe2Y4WEQFQP" + } + }, + { + "cell_type": "code", + "source": [ + "from garth.exc import GarthException\n", + "from getpass import getpass\n", + "\n", + "try:\n", + " garth.resume(GARTH_HOME)\n", + " garth.client.username\n", + "except (FileNotFoundError, GarthException):\n", + " email = input(\"Email: \")\n", + " password = getpass(\"Password: \")\n", + " garth.client.login(email, password)\n", + "\n", + "garth.save(GARTH_HOME)" + ], + "metadata": { + "id": "SAKFmoHFQK8c" + }, + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Weekly stress" + ], + "metadata": { + "id": "VW-ALoJwQpBk" + } + }, + { + "cell_type": "markdown", + "source": [ + "Get the most recent week." + ], + "metadata": { + "id": "fEB2r8nmQv0B" + } + }, + { + "cell_type": "code", + "source": [ + "garth.WeeklyStress.list()[0]" + ], + "metadata": { + "id": "xswaFgIwQsIG", + "outputId": "b40eec5a-aeac-42b6-e0ee-c9498cd2f70d", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "WeeklyStress(calendar_date=datetime.date(2023, 9, 26), value=28)" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Get the last two years." + ], + "metadata": { + "id": "2GhptSX5rpWt" + } + }, + { + "cell_type": "code", + "source": [ + "weekly_stress = garth.WeeklyStress.list(period=104)" + ], + "metadata": { + "id": "EHonpeUHrhEr" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Use Pandas and Matplotlib with Seaborn styling to graph" + ], + "metadata": { + "id": "G8KcE4Y3RFgs" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.dates as mdates\n", + "from matplotlib import pyplot as plt\n", + "\n", + "df = pd.DataFrame(weekly_stress).sort_values(\"calendar_date\")\n", + "\n", + "sns.set_theme()\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "sns.lineplot(x=df[\"calendar_date\"], y=df[\"value\"])\n", + "\n", + "plt.gca().xaxis.set_major_locator(mdates.MonthLocator())\n", + "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter(\"%b %Y\"))\n", + "\n", + "plt.xticks(rotation=45)\n", + "\n", + "plt.xlabel(None)\n", + "plt.ylabel(None)\n", + "plt.title(\"Average Weekly Stress\")\n", + "\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 598 + }, + "id": "rkKTbUXJRHi9", + "outputId": "9a32ca27-f5c1-429e-afb5-2ad9c0bc1016" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Daily stress trends" + ], + "metadata": { + "id": "NvWgqmslRaG7" + } + }, + { + "cell_type": "markdown", + "source": [ + "Retrieve daily averages by week. This takes a while to run.\n" + ], + "metadata": { + "id": "KMGWyCznRdDA" + } + }, + { + "cell_type": "markdown", + "source": [ + "Get yesterday's stress levels." + ], + "metadata": { + "id": "b-GJQP4MRrLZ" + } + }, + { + "cell_type": "code", + "source": [ + "from datetime import date, timedelta\n", + "\n", + "garth.DailyStress.list(date.today() - timedelta(days=1))[0]" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BUDpv1jlRpVK", + "outputId": "200408b8-1230-4ecf-eb47-80cd063d9be3" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "DailyStress(calendar_date=datetime.date(2023, 10, 1), overall_stress_level=30, rest_stress_duration=36900, low_stress_duration=8640, medium_stress_duration=7680, high_stress_duration=4140)" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Get up to the last three years." + ], + "metadata": { + "id": "NgnMszkFr_KK" + } + }, + { + "cell_type": "code", + "source": [ + "daily_stress = garth.DailyStress.list(period=365 * 3)" + ], + "metadata": { + "id": "Vp9TC3XesAeZ" + }, + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Daily stats are going to have a *lot* of noise, so let's also graph the 28-day rolling average." + ], + "metadata": { + "id": "q3BFkrzKSMvW" + } + }, + { + "cell_type": "code", + "source": [ + "import seaborn as sns\n", + "import matplotlib.dates as mdates\n", + "from matplotlib import pyplot as plt\n", + "\n", + "sns.set_theme()\n", + "\n", + "df = pd.DataFrame(daily_stress)\n", + "df.set_index(\"calendar_date\", inplace=True)\n", + "\n", + "df[\"rolling_avg\"] = df[\"overall_stress_level\"].rolling(window=28).mean()\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "sns.scatterplot(\n", + " x=df.index,\n", + " y=df[\"overall_stress_level\"],\n", + " color=\"skyblue\",\n", + " label=\"Daily Stress Level\"\n", + ")\n", + "\n", + "sns.lineplot(\n", + " x=df.index,\n", + " y=df[\"rolling_avg\"],\n", + " color=\"r\",\n", + " label=\"28-day Rolling Average\"\n", + ")\n", + "\n", + "plt.gca().xaxis.set_major_locator(mdates.MonthLocator())\n", + "plt.gca().xaxis.set_major_formatter(mdates.DateFormatter(\"%b %Y\"))\n", + "\n", + "plt.xticks(rotation=45)\n", + "plt.xlim(df.index.min(), df.index.max())\n", + "plt.xlabel(None)\n", + "plt.ylabel(None)\n", + "plt.title(\"Overall Stress Level Over Time\")\n", + "plt.legend()\n", + "\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 598 + }, + "id": "Z7ZLYO7jSLxk", + "outputId": "903d13cb-fa41-440b-a16f-343eb0dc3a3f" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We can also use `seasonal_decompose` to look at the 28-day trend." + ], + "metadata": { + "id": "_hWWqx2PkSSc" + } + }, + { + "cell_type": "code", + "source": [ + "from statsmodels.tsa.seasonal import seasonal_decompose\n", + "\n", + "result = seasonal_decompose(\n", + " df[\"overall_stress_level\"], model=\"additive\", period=28\n", + ")\n", + "trend = result.trend.dropna()\n", + "\n", + "min_date = df.index.min()\n", + "max_date = df.index.max()\n", + "\n", + "def plot_subplot(ax, x, y, title, color, plot_type=\"line\"):\n", + " if plot_type == \"line\":\n", + " sns.lineplot(ax=ax, x=x, y=y, color=color)\n", + " elif plot_type == 'scatter':\n", + " sns.scatterplot(ax=ax, x=x, y=y, color=color)\n", + "\n", + " ax.set_title(title)\n", + " ax.set_xlim(min_date, max_date)\n", + " ax.set_xlabel(None)\n", + " ax.set_ylabel(None)\n", + " ax.xaxis.set_major_locator(mdates.MonthLocator())\n", + " ax.xaxis.set_major_formatter(mdates.DateFormatter(\"%b %Y\"))\n", + " ax.tick_params(axis=\"x\", rotation=45)\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(15, 6))\n", + "\n", + "plot_subplot(\n", + " axes[0], df.index, df[\"overall_stress_level\"],\n", + " \"Daily Stress Level\", \"skyblue\", plot_type='scatter'\n", + ")\n", + "plot_subplot(axes[1], trend.index, trend, \"28-Day Trend\", \"r\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ], + "metadata": { + "id": "mNLf5zD3ZtUH", + "outputId": "6513f16b-11f1-45f5-d12f-a5e1595fe997", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 579 + } + }, + "execution_count": 12, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/garth/pyproject.toml b/garth/pyproject.toml new file mode 100644 index 0000000..17dcd1b --- /dev/null +++ b/garth/pyproject.toml @@ -0,0 +1,89 @@ +[project] +name = "garth" +dynamic = ["version"] +description = "Garmin SSO auth + Connect client" +authors = [ + {name = "Matin Tamizi", email = "mtamizi@duck.com"}, +] +dependencies = [ + "requests>=2.0.0,<3.0.0", + "pydantic>=1.10.12,<3.0.0", + "requests-oauthlib>=1.3.1,<3.0.0", +] +requires-python = ">=3.10" +readme = "README.md" +license = {text = "MIT"} +classifiers = [ + "Development Status :: 5 - Production/Stable", + "License :: OSI Approved :: MIT License", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Operating System :: MacOS :: MacOS X", + "Operating System :: Microsoft :: Windows", + "Operating System :: POSIX :: Linux", + "Operating System :: OS Independent", +] +keywords = ["garmin", "garmin api", "garmin connect", "garmin sso"] + +[project.urls] +"Homepage" = "https://github.com/matin/garth" +"Repository" = "https://github.com/matin/garth" +"Issues" = "https://github.com/matin/garth/issues" +"Changelog" = "https://github.com/matin/garth/releases" + +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[tool.hatch.version] +path = "src/garth/version.py" + +[tool.pytest.ini_options] +addopts = "--ignore=__pypackages__ --ignore-glob=*.yaml" + +[tool.mypy] +ignore_missing_imports = true + +[tool.ruff] +line-length = 79 +indent-width = 4 +target-version = "py310" + +[tool.ruff.lint] +select = ["E", "F", "I"] +ignore = [] + +[tool.ruff.format] +quote-style = "double" +indent-style = "space" +skip-magic-trailing-comma = false +line-ending = "auto" + +[dependency-groups] +dev = [ + "ipython", + "ipdb", + "ipykernel", + "pandas", + "matplotlib", +] +linting = [ + "ruff", + "mypy", + "types-requests", +] +testing = [ + "coverage", + "pytest", + "pytest-vcr", +] + +[tool.ruff.lint.isort] +known-first-party = ["garth"] +combine-as-imports = true +lines-after-imports = 2 + +[project.scripts] +garth = "garth.cli:main" diff --git a/garth/src/garth/__init__.py b/garth/src/garth/__init__.py new file mode 100644 index 0000000..760eab3 --- /dev/null +++ b/garth/src/garth/__init__.py @@ -0,0 +1,59 @@ +from .data import ( + BodyBatteryData, + DailyBodyBatteryStress, + HRVData, + SleepData, + WeightData, +) +from .http import Client, client +from .stats import ( + DailyHRV, + DailyHydration, + DailyIntensityMinutes, + DailySleep, + DailySteps, + DailyStress, + WeeklyIntensityMinutes, + WeeklySteps, + WeeklyStress, +) +from .users import UserProfile, UserSettings +from .version import __version__ + + +__all__ = [ + "BodyBatteryData", + "Client", + "DailyBodyBatteryStress", + "DailyHRV", + "DailyHydration", + "DailyIntensityMinutes", + "DailySleep", + "DailySteps", + "DailyStress", + "HRVData", + "SleepData", + "WeightData", + "UserProfile", + "UserSettings", + "WeeklyIntensityMinutes", + "WeeklySteps", + "WeeklyStress", + "__version__", + "client", + "configure", + "connectapi", + "download", + "login", + "resume", + "save", + "upload", +] + +configure = client.configure +connectapi = client.connectapi +download = client.download +login = client.login +resume = client.load +save = client.dump +upload = client.upload diff --git a/garth/src/garth/auth_tokens.py b/garth/src/garth/auth_tokens.py new file mode 100644 index 0000000..09f535c --- /dev/null +++ b/garth/src/garth/auth_tokens.py @@ -0,0 +1,37 @@ +import time +from datetime import datetime + +from pydantic.dataclasses import dataclass + + +@dataclass +class OAuth1Token: + oauth_token: str + oauth_token_secret: str + mfa_token: str | None = None + mfa_expiration_timestamp: datetime | None = None + domain: str | None = None + + +@dataclass +class OAuth2Token: + scope: str + jti: str + token_type: str + access_token: str + refresh_token: str + expires_in: int + expires_at: int + refresh_token_expires_in: int + refresh_token_expires_at: int + + @property + def expired(self): + return self.expires_at < time.time() + + @property + def refresh_expired(self): + return self.refresh_token_expires_at < time.time() + + def __str__(self): + return f"{self.token_type.title()} {self.access_token}" diff --git a/garth/src/garth/cli.py b/garth/src/garth/cli.py new file mode 100644 index 0000000..a558c29 --- /dev/null +++ b/garth/src/garth/cli.py @@ -0,0 +1,34 @@ +import argparse +import getpass + +import garth + + +def main(): + parser = argparse.ArgumentParser(prog="garth") + parser.add_argument( + "--domain", + "-d", + default="garmin.com", + help=( + "Domain for Garmin Connect (default: garmin.com). " + "Use garmin.cn for China." + ), + ) + subparsers = parser.add_subparsers(dest="command") + subparsers.add_parser( + "login", help="Authenticate with Garmin Connect and print token" + ) + + args = parser.parse_args() + garth.configure(domain=args.domain) + + match args.command: + case "login": + email = input("Email: ") + password = getpass.getpass("Password: ") + garth.login(email, password) + token = garth.client.dumps() + print(token) + case _: + parser.print_help() diff --git a/garth/src/garth/data/__init__.py b/garth/src/garth/data/__init__.py new file mode 100644 index 0000000..44addfa --- /dev/null +++ b/garth/src/garth/data/__init__.py @@ -0,0 +1,21 @@ +__all__ = [ + "BodyBatteryData", + "BodyBatteryEvent", + "BodyBatteryReading", + "DailyBodyBatteryStress", + "HRVData", + "SleepData", + "StressReading", + "WeightData", +] + +from .body_battery import ( + BodyBatteryData, + BodyBatteryEvent, + BodyBatteryReading, + DailyBodyBatteryStress, + StressReading, +) +from .hrv import HRVData +from .sleep import SleepData +from .weight import WeightData diff --git a/garth/src/garth/data/_base.py b/garth/src/garth/data/_base.py new file mode 100644 index 0000000..cbfd757 --- /dev/null +++ b/garth/src/garth/data/_base.py @@ -0,0 +1,47 @@ +from abc import ABC, abstractmethod +from concurrent.futures import ThreadPoolExecutor +from datetime import date +from itertools import chain + +from typing_extensions import Self + +from .. import http +from ..utils import date_range, format_end_date + + +MAX_WORKERS = 10 + + +class Data(ABC): + @classmethod + @abstractmethod + def get( + cls, day: date | str, *, client: http.Client | None = None + ) -> Self | list[Self] | None: ... + + @classmethod + def list( + cls, + end: date | str | None = None, + days: int = 1, + *, + client: http.Client | None = None, + max_workers: int = MAX_WORKERS, + ) -> list[Self]: + client = client or http.client + end = format_end_date(end) + + def fetch_date(date_): + if day := cls.get(date_, client=client): + return day + + dates = date_range(end, days) + with ThreadPoolExecutor(max_workers=max_workers) as executor: + data = list(executor.map(fetch_date, dates)) + data = [day for day in data if day is not None] + + return list( + chain.from_iterable( + day if isinstance(day, list) else [day] for day in data + ) + ) diff --git a/garth/src/garth/data/body_battery/__init__.py b/garth/src/garth/data/body_battery/__init__.py new file mode 100644 index 0000000..bfe3dbe --- /dev/null +++ b/garth/src/garth/data/body_battery/__init__.py @@ -0,0 +1,11 @@ +__all__ = [ + "BodyBatteryData", + "BodyBatteryEvent", + "BodyBatteryReading", + "DailyBodyBatteryStress", + "StressReading", +] + +from .daily_stress import DailyBodyBatteryStress +from .events import BodyBatteryData, BodyBatteryEvent +from .readings import BodyBatteryReading, StressReading diff --git a/garth/src/garth/data/body_battery/daily_stress.py b/garth/src/garth/data/body_battery/daily_stress.py new file mode 100644 index 0000000..afefeb7 --- /dev/null +++ b/garth/src/garth/data/body_battery/daily_stress.py @@ -0,0 +1,90 @@ +from datetime import date, datetime +from functools import cached_property +from typing import Any + +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from ... import http +from ...utils import camel_to_snake_dict, format_end_date +from .._base import Data +from .readings import ( + BodyBatteryReading, + StressReading, + parse_body_battery_readings, + parse_stress_readings, +) + + +@dataclass +class DailyBodyBatteryStress(Data): + """Complete daily Body Battery and stress data.""" + + user_profile_pk: int + calendar_date: date + start_timestamp_gmt: datetime + end_timestamp_gmt: datetime + start_timestamp_local: datetime + end_timestamp_local: datetime + max_stress_level: int + avg_stress_level: int + stress_chart_value_offset: int + stress_chart_y_axis_origin: int + stress_values_array: list[list[int]] + body_battery_values_array: list[list[Any]] + + @cached_property + def body_battery_readings(self) -> list[BodyBatteryReading]: + """Convert body battery values array to structured readings.""" + return parse_body_battery_readings(self.body_battery_values_array) + + @property + def stress_readings(self) -> list[StressReading]: + """Convert stress values array to structured readings.""" + return parse_stress_readings(self.stress_values_array) + + @property + def current_body_battery(self) -> int | None: + """Get the latest Body Battery level.""" + readings = self.body_battery_readings + return readings[-1].level if readings else None + + @property + def max_body_battery(self) -> int | None: + """Get the maximum Body Battery level for the day.""" + readings = self.body_battery_readings + return max(reading.level for reading in readings) if readings else None + + @property + def min_body_battery(self) -> int | None: + """Get the minimum Body Battery level for the day.""" + readings = self.body_battery_readings + return min(reading.level for reading in readings) if readings else None + + @property + def body_battery_change(self) -> int | None: + """Calculate the Body Battery change for the day.""" + readings = self.body_battery_readings + if not readings or len(readings) < 2: + return None + return readings[-1].level - readings[0].level + + @classmethod + def get( + cls, + day: date | str | None = None, + *, + client: http.Client | None = None, + ) -> Self | None: + """Get complete Body Battery and stress data for a specific date.""" + client = client or http.client + date_str = format_end_date(day) + + path = f"/wellness-service/wellness/dailyStress/{date_str}" + response = client.connectapi(path) + + if not isinstance(response, dict): + return None + + snake_response = camel_to_snake_dict(response) + return cls(**snake_response) diff --git a/garth/src/garth/data/body_battery/events.py b/garth/src/garth/data/body_battery/events.py new file mode 100644 index 0000000..006e99d --- /dev/null +++ b/garth/src/garth/data/body_battery/events.py @@ -0,0 +1,227 @@ +import logging +from datetime import date, datetime +from typing import Any + +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from ... import http +from ...utils import format_end_date +from .._base import Data +from .readings import BodyBatteryReading, parse_body_battery_readings + + +MAX_WORKERS = 10 + + +@dataclass +class BodyBatteryEvent: + """Body Battery event data.""" + + event_type: str + event_start_time_gmt: datetime + timezone_offset: int + duration_in_milliseconds: int + body_battery_impact: int + feedback_type: str + short_feedback: str + + +@dataclass +class BodyBatteryData(Data): + """Legacy Body Battery events data (sleep events only).""" + + event: BodyBatteryEvent | None = None + activity_name: str | None = None + activity_type: str | None = None + activity_id: str | None = None + average_stress: float | None = None + stress_values_array: list[list[int]] | None = None + body_battery_values_array: list[list[Any]] | None = None + + @property + def body_battery_readings(self) -> list[BodyBatteryReading]: + """Convert body battery values array to structured readings.""" + return parse_body_battery_readings(self.body_battery_values_array) + + @property + def current_level(self) -> int | None: + """Get the latest Body Battery level.""" + readings = self.body_battery_readings + return readings[-1].level if readings else None + + @property + def max_level(self) -> int | None: + """Get the maximum Body Battery level for the day.""" + readings = self.body_battery_readings + return max(reading.level for reading in readings) if readings else None + + @property + def min_level(self) -> int | None: + """Get the minimum Body Battery level for the day.""" + readings = self.body_battery_readings + return min(reading.level for reading in readings) if readings else None + + @classmethod + def get( + cls, + date_str: str | date | None = None, + *, + client: http.Client | None = None, + ) -> list[Self]: + """Get Body Battery events for a specific date.""" + client = client or http.client + date_str = format_end_date(date_str) + + path = f"/wellness-service/wellness/bodyBattery/events/{date_str}" + try: + response = client.connectapi(path) + except Exception as e: + logging.warning(f"Failed to fetch Body Battery events: {e}") + return [] + + if not isinstance(response, list): + return [] + + events = [] + for item in response: + try: + # Parse event data with validation + event_data = item.get("event") + + # Validate event_data exists before accessing properties + if event_data is None: + logging.warning(f"Missing event data in item: {item}") + event = None + else: + # Validate and parse datetime with explicit error handling + event_start_time_str = event_data.get("eventStartTimeGmt") + if not event_start_time_str: + logging.error( + f"Missing eventStartTimeGmt in event data: " + f"{event_data}" + ) + raise ValueError( + "eventStartTimeGmt is required but missing" + ) + + try: + event_start_time_gmt = datetime.fromisoformat( + event_start_time_str.replace("Z", "+00:00") + ) + except (ValueError, AttributeError) as e: + logging.error( + f"Invalid datetime format " + f"'{event_start_time_str}': {e}" + ) + raise ValueError( + f"Invalid eventStartTimeGmt format: " + f"{event_start_time_str}" + ) from e + + # Validate numeric fields + timezone_offset = event_data.get("timezoneOffset", 0) + if not isinstance(timezone_offset, (int, float)): + logging.warning( + f"Invalid timezone_offset type: " + f"{type(timezone_offset)}, using 0" + ) + timezone_offset = 0 + + duration_ms = event_data.get("durationInMilliseconds", 0) + if not isinstance(duration_ms, (int, float)): + logging.warning( + f"Invalid durationInMilliseconds type: " + f"{type(duration_ms)}, using 0" + ) + duration_ms = 0 + + battery_impact = event_data.get("bodyBatteryImpact", 0) + if not isinstance(battery_impact, (int, float)): + logging.warning( + f"Invalid bodyBatteryImpact type: " + f"{type(battery_impact)}, using 0" + ) + battery_impact = 0 + + event = BodyBatteryEvent( + event_type=event_data.get("eventType", ""), + event_start_time_gmt=event_start_time_gmt, + timezone_offset=int(timezone_offset), + duration_in_milliseconds=int(duration_ms), + body_battery_impact=int(battery_impact), + feedback_type=event_data.get("feedbackType", ""), + short_feedback=event_data.get("shortFeedback", ""), + ) + + # Validate data arrays + stress_values = item.get("stressValuesArray") + if stress_values is not None and not isinstance( + stress_values, list + ): + logging.warning( + f"Invalid stressValuesArray type: " + f"{type(stress_values)}, using None" + ) + stress_values = None + + battery_values = item.get("bodyBatteryValuesArray") + if battery_values is not None and not isinstance( + battery_values, list + ): + logging.warning( + f"Invalid bodyBatteryValuesArray type: " + f"{type(battery_values)}, using None" + ) + battery_values = None + + # Validate average_stress + avg_stress = item.get("averageStress") + if avg_stress is not None and not isinstance( + avg_stress, (int, float) + ): + logging.warning( + f"Invalid averageStress type: " + f"{type(avg_stress)}, using None" + ) + avg_stress = None + + events.append( + cls( + event=event, + activity_name=item.get("activityName"), + activity_type=item.get("activityType"), + activity_id=item.get("activityId"), + average_stress=avg_stress, + stress_values_array=stress_values, + body_battery_values_array=battery_values, + ) + ) + + except ValueError as e: + # Re-raise validation errors with context + logging.error( + f"Data validation error for Body Battery event item " + f"{item}: {e}" + ) + continue + except Exception as e: + # Log unexpected errors with full context + logging.error( + f"Unexpected error parsing Body Battery event item " + f"{item}: {e}", + exc_info=True, + ) + continue + + # Log summary of data quality issues + total_items = len(response) + parsed_events = len(events) + if parsed_events < total_items: + skipped = total_items - parsed_events + logging.info( + f"Body Battery events parsing: {parsed_events}/{total_items} " + f"successful, {skipped} skipped due to data issues" + ) + + return events diff --git a/garth/src/garth/data/body_battery/readings.py b/garth/src/garth/data/body_battery/readings.py new file mode 100644 index 0000000..e85cc26 --- /dev/null +++ b/garth/src/garth/data/body_battery/readings.py @@ -0,0 +1,56 @@ +from typing import Any + +from pydantic.dataclasses import dataclass + + +@dataclass +class BodyBatteryReading: + """Individual Body Battery reading.""" + + timestamp: int + status: str + level: int + version: float + + +@dataclass +class StressReading: + """Individual stress reading.""" + + timestamp: int + stress_level: int + + +def parse_body_battery_readings( + body_battery_values_array: list[list[Any]] | None, +) -> list[BodyBatteryReading]: + """Convert body battery values array to structured readings.""" + readings = [] + for values in body_battery_values_array or []: + # Each reading requires 4 values: timestamp, status, level, version + if len(values) >= 4: + readings.append( + BodyBatteryReading( + timestamp=values[0], + status=values[1], + level=values[2], + version=values[3], + ) + ) + # Sort readings by timestamp to ensure chronological order + return sorted(readings, key=lambda reading: reading.timestamp) + + +def parse_stress_readings( + stress_values_array: list[list[int]] | None, +) -> list[StressReading]: + """Convert stress values array to structured readings.""" + readings = [] + for values in stress_values_array or []: + # Each reading requires 2 values: timestamp, stress_level + if len(values) >= 2: + readings.append( + StressReading(timestamp=values[0], stress_level=values[1]) + ) + # Sort readings by timestamp to ensure chronological order + return sorted(readings, key=lambda reading: reading.timestamp) diff --git a/garth/src/garth/data/hrv.py b/garth/src/garth/data/hrv.py new file mode 100644 index 0000000..728cc28 --- /dev/null +++ b/garth/src/garth/data/hrv.py @@ -0,0 +1,68 @@ +from datetime import date, datetime + +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from .. import http +from ..utils import camel_to_snake_dict +from ._base import Data + + +@dataclass +class Baseline: + low_upper: int + balanced_low: int + balanced_upper: int + marker_value: float + + +@dataclass +class HRVSummary: + calendar_date: date + weekly_avg: int + last_night_avg: int | None + last_night_5_min_high: int + baseline: Baseline + status: str + feedback_phrase: str + create_time_stamp: datetime + + +@dataclass +class HRVReading: + hrv_value: int + reading_time_gmt: datetime + reading_time_local: datetime + + +@dataclass +class HRVData(Data): + user_profile_pk: int + hrv_summary: HRVSummary + hrv_readings: list[HRVReading] + start_timestamp_gmt: datetime + end_timestamp_gmt: datetime + start_timestamp_local: datetime + end_timestamp_local: datetime + sleep_start_timestamp_gmt: datetime + sleep_end_timestamp_gmt: datetime + sleep_start_timestamp_local: datetime + sleep_end_timestamp_local: datetime + + @classmethod + def get( + cls, day: date | str, *, client: http.Client | None = None + ) -> Self | None: + client = client or http.client + path = f"/hrv-service/hrv/{day}" + hrv_data = client.connectapi(path) + if not hrv_data: + return None + hrv_data = camel_to_snake_dict(hrv_data) + assert isinstance(hrv_data, dict) + return cls(**hrv_data) + + @classmethod + def list(cls, *args, **kwargs) -> list[Self]: + data = super().list(*args, **kwargs) + return sorted(data, key=lambda d: d.hrv_summary.calendar_date) diff --git a/garth/src/garth/data/sleep.py b/garth/src/garth/data/sleep.py new file mode 100644 index 0000000..0c15c51 --- /dev/null +++ b/garth/src/garth/data/sleep.py @@ -0,0 +1,123 @@ +from datetime import date, datetime +from typing import Optional, Union + +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from .. import http +from ..utils import camel_to_snake_dict, get_localized_datetime +from ._base import Data + + +@dataclass +class Score: + qualifier_key: str + optimal_start: Optional[float] = None + optimal_end: Optional[float] = None + value: Optional[int] = None + ideal_start_in_seconds: Optional[float] = None + ideal_end_in_seconds: Optional[float] = None + + +@dataclass +class SleepScores: + total_duration: Score + stress: Score + awake_count: Score + overall: Score + rem_percentage: Score + restlessness: Score + light_percentage: Score + deep_percentage: Score + + +@dataclass +class DailySleepDTO: + id: int + user_profile_pk: int + calendar_date: date + sleep_time_seconds: int + nap_time_seconds: int + sleep_window_confirmed: bool + sleep_window_confirmation_type: str + sleep_start_timestamp_gmt: int + sleep_end_timestamp_gmt: int + sleep_start_timestamp_local: int + sleep_end_timestamp_local: int + device_rem_capable: bool + retro: bool + unmeasurable_sleep_seconds: Optional[int] = None + deep_sleep_seconds: Optional[int] = None + light_sleep_seconds: Optional[int] = None + rem_sleep_seconds: Optional[int] = None + awake_sleep_seconds: Optional[int] = None + sleep_from_device: Optional[bool] = None + sleep_version: Optional[int] = None + awake_count: Optional[int] = None + sleep_scores: Optional[SleepScores] = None + auto_sleep_start_timestamp_gmt: Optional[int] = None + auto_sleep_end_timestamp_gmt: Optional[int] = None + sleep_quality_type_pk: Optional[int] = None + sleep_result_type_pk: Optional[int] = None + average_sp_o2_value: Optional[float] = None + lowest_sp_o2_value: Optional[int] = None + highest_sp_o2_value: Optional[int] = None + average_sp_o2_hr_sleep: Optional[float] = None + average_respiration_value: Optional[float] = None + lowest_respiration_value: Optional[float] = None + highest_respiration_value: Optional[float] = None + avg_sleep_stress: Optional[float] = None + age_group: Optional[str] = None + sleep_score_feedback: Optional[str] = None + sleep_score_insight: Optional[str] = None + + @property + def sleep_start(self) -> datetime: + return get_localized_datetime( + self.sleep_start_timestamp_gmt, self.sleep_start_timestamp_local + ) + + @property + def sleep_end(self) -> datetime: + return get_localized_datetime( + self.sleep_end_timestamp_gmt, self.sleep_end_timestamp_local + ) + + +@dataclass +class SleepMovement: + start_gmt: datetime + end_gmt: datetime + activity_level: float + + +@dataclass +class SleepData(Data): + daily_sleep_dto: DailySleepDTO + sleep_movement: Optional[list[SleepMovement]] = None + + @classmethod + def get( + cls, + day: Union[date, str], + *, + buffer_minutes: int = 60, + client: Optional[http.Client] = None, + ) -> Optional[Self]: + client = client or http.client + path = ( + f"/wellness-service/wellness/dailySleepData/{client.username}?" + f"nonSleepBufferMinutes={buffer_minutes}&date={day}" + ) + sleep_data = client.connectapi(path) + assert sleep_data + sleep_data = camel_to_snake_dict(sleep_data) + assert isinstance(sleep_data, dict) + return ( + cls(**sleep_data) if sleep_data["daily_sleep_dto"]["id"] else None + ) + + @classmethod + def list(cls, *args, **kwargs) -> list[Self]: + data = super().list(*args, **kwargs) + return sorted(data, key=lambda x: x.daily_sleep_dto.calendar_date) diff --git a/garth/src/garth/data/weight.py b/garth/src/garth/data/weight.py new file mode 100644 index 0000000..42b8c7f --- /dev/null +++ b/garth/src/garth/data/weight.py @@ -0,0 +1,81 @@ +from datetime import date, datetime, timedelta +from itertools import chain + +from pydantic import Field, ValidationInfo, field_validator +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from .. import http +from ..utils import ( + camel_to_snake_dict, + format_end_date, + get_localized_datetime, +) +from ._base import MAX_WORKERS, Data + + +@dataclass +class WeightData(Data): + sample_pk: int + calendar_date: date + weight: int + source_type: str + weight_delta: float + timestamp_gmt: int + datetime_utc: datetime = Field(..., alias="timestamp_gmt") + datetime_local: datetime = Field(..., alias="date") + bmi: float | None = None + body_fat: float | None = None + body_water: float | None = None + bone_mass: int | None = None + muscle_mass: int | None = None + physique_rating: float | None = None + visceral_fat: float | None = None + metabolic_age: int | None = None + + @field_validator("datetime_local", mode="before") + @classmethod + def to_localized_datetime(cls, v: int, info: ValidationInfo) -> datetime: + return get_localized_datetime(info.data["timestamp_gmt"], v) + + @classmethod + def get( + cls, day: date | str, *, client: http.Client | None = None + ) -> Self | None: + client = client or http.client + path = f"/weight-service/weight/dayview/{day}" + data = client.connectapi(path) + day_weight_list = data["dateWeightList"] if data else [] + + if not day_weight_list: + return None + + # Get first (most recent) weight entry for the day + weight_data = camel_to_snake_dict(day_weight_list[0]) + return cls(**weight_data) + + @classmethod + def list( + cls, + end: date | str | None = None, + days: int = 1, + *, + client: http.Client | None = None, + max_workers: int = MAX_WORKERS, + ) -> list[Self]: + client = client or http.client + end = format_end_date(end) + start = end - timedelta(days=days - 1) + + data = client.connectapi( + f"/weight-service/weight/range/{start}/{end}?includeAll=true" + ) + weight_summaries = data["dailyWeightSummaries"] if data else [] + weight_metrics = chain.from_iterable( + summary["allWeightMetrics"] for summary in weight_summaries + ) + weight_data_list = ( + cls(**camel_to_snake_dict(weight_data)) + for weight_data in weight_metrics + ) + return sorted(weight_data_list, key=lambda d: d.datetime_utc) diff --git a/garth/src/garth/exc.py b/garth/src/garth/exc.py new file mode 100644 index 0000000..3e26258 --- /dev/null +++ b/garth/src/garth/exc.py @@ -0,0 +1,18 @@ +from dataclasses import dataclass + +from requests import HTTPError + + +@dataclass +class GarthException(Exception): + """Base exception for all garth exceptions.""" + + msg: str + + +@dataclass +class GarthHTTPError(GarthException): + error: HTTPError + + def __str__(self) -> str: + return f"{self.msg}: {self.error}" diff --git a/garth/src/garth/http.py b/garth/src/garth/http.py new file mode 100644 index 0000000..8a8c1ff --- /dev/null +++ b/garth/src/garth/http.py @@ -0,0 +1,247 @@ +import base64 +import json +import os +from typing import IO, Any, Dict, Literal, Tuple +from urllib.parse import urljoin + +from requests import HTTPError, Response, Session +from requests.adapters import HTTPAdapter, Retry + +from . import sso +from .auth_tokens import OAuth1Token, OAuth2Token +from .exc import GarthHTTPError +from .utils import asdict + + +USER_AGENT = {"User-Agent": "GCM-iOS-5.7.2.1"} + + +class Client: + sess: Session + last_resp: Response + domain: str = "garmin.com" + oauth1_token: OAuth1Token | Literal["needs_mfa"] | None = None + oauth2_token: OAuth2Token | dict[str, Any] | None = None + timeout: int = 10 + retries: int = 3 + status_forcelist: Tuple[int, ...] = (408, 429, 500, 502, 503, 504) + backoff_factor: float = 0.5 + pool_connections: int = 10 + pool_maxsize: int = 10 + _user_profile: Dict[str, Any] | None = None + + def __init__(self, session: Session | None = None, **kwargs): + self.sess = session if session else Session() + self.sess.headers.update(USER_AGENT) + self.configure( + timeout=self.timeout, + retries=self.retries, + status_forcelist=self.status_forcelist, + backoff_factor=self.backoff_factor, + **kwargs, + ) + + def configure( + self, + /, + oauth1_token: OAuth1Token | None = None, + oauth2_token: OAuth2Token | None = None, + domain: str | None = None, + proxies: Dict[str, str] | None = None, + ssl_verify: bool | None = None, + timeout: int | None = None, + retries: int | None = None, + status_forcelist: Tuple[int, ...] | None = None, + backoff_factor: float | None = None, + pool_connections: int | None = None, + pool_maxsize: int | None = None, + ): + if oauth1_token is not None: + self.oauth1_token = oauth1_token + if oauth2_token is not None: + self.oauth2_token = oauth2_token + if domain: + self.domain = domain + if proxies is not None: + self.sess.proxies.update(proxies) + if ssl_verify is not None: + self.sess.verify = ssl_verify + if timeout is not None: + self.timeout = timeout + if retries is not None: + self.retries = retries + if status_forcelist is not None: + self.status_forcelist = status_forcelist + if backoff_factor is not None: + self.backoff_factor = backoff_factor + if pool_connections is not None: + self.pool_connections = pool_connections + if pool_maxsize is not None: + self.pool_maxsize = pool_maxsize + + retry = Retry( + total=self.retries, + status_forcelist=self.status_forcelist, + backoff_factor=self.backoff_factor, + ) + adapter = HTTPAdapter( + max_retries=retry, + pool_connections=self.pool_connections, + pool_maxsize=self.pool_maxsize, + ) + self.sess.mount("https://", adapter) + + @property + def user_profile(self): + if not self._user_profile: + self._user_profile = self.connectapi( + "/userprofile-service/socialProfile" + ) + assert isinstance(self._user_profile, dict), ( + "No profile from connectapi" + ) + return self._user_profile + + @property + def profile(self): + return self.user_profile + + @property + def username(self): + return self.user_profile["userName"] + + def request( + self, + method: str, + subdomain: str, + path: str, + /, + api: bool = False, + referrer: str | bool = False, + headers: dict = {}, + **kwargs, + ) -> Response: + url = f"https://{subdomain}.{self.domain}" + url = urljoin(url, path) + if referrer is True and self.last_resp: + headers["referer"] = self.last_resp.url + if api: + assert self.oauth1_token, ( + "OAuth1 token is required for API requests" + ) + if ( + not isinstance(self.oauth2_token, OAuth2Token) + or self.oauth2_token.expired + ): + self.refresh_oauth2() + headers["Authorization"] = str(self.oauth2_token) + self.last_resp = self.sess.request( + method, + url, + headers=headers, + timeout=self.timeout, + **kwargs, + ) + try: + self.last_resp.raise_for_status() + except HTTPError as e: + raise GarthHTTPError( + msg="Error in request", + error=e, + ) + return self.last_resp + + def get(self, *args, **kwargs) -> Response: + return self.request("GET", *args, **kwargs) + + def post(self, *args, **kwargs) -> Response: + return self.request("POST", *args, **kwargs) + + def delete(self, *args, **kwargs) -> Response: + return self.request("DELETE", *args, **kwargs) + + def put(self, *args, **kwargs) -> Response: + return self.request("PUT", *args, **kwargs) + + def login(self, *args, **kwargs): + self.oauth1_token, self.oauth2_token = sso.login( + *args, **kwargs, client=self + ) + return self.oauth1_token, self.oauth2_token + + def resume_login(self, *args, **kwargs): + self.oauth1_token, self.oauth2_token = sso.resume_login( + *args, **kwargs + ) + return self.oauth1_token, self.oauth2_token + + def refresh_oauth2(self): + assert self.oauth1_token and isinstance( + self.oauth1_token, OAuth1Token + ), "OAuth1 token is required for OAuth2 refresh" + # There is a way to perform a refresh of an OAuth2 token, but it + # appears even Garmin uses this approach when the OAuth2 is expired + self.oauth2_token = sso.exchange(self.oauth1_token, self) + + def connectapi( + self, path: str, method="GET", **kwargs + ) -> Dict[str, Any] | None: + resp = self.request(method, "connectapi", path, api=True, **kwargs) + if resp.status_code == 204: + return None + return resp.json() + + def download(self, path: str, **kwargs) -> bytes: + resp = self.get("connectapi", path, api=True, **kwargs) + return resp.content + + def upload( + self, fp: IO[bytes], /, path: str = "/upload-service/upload" + ) -> Dict[str, Any]: + fname = os.path.basename(fp.name) + files = {"file": (fname, fp)} + result = self.connectapi( + path, + method="POST", + files=files, + ) + assert result is not None, "No result from upload" + return result + + def dump(self, dir_path: str): + dir_path = os.path.expanduser(dir_path) + os.makedirs(dir_path, exist_ok=True) + with open(os.path.join(dir_path, "oauth1_token.json"), "w") as f: + if self.oauth1_token: + json.dump(asdict(self.oauth1_token), f, indent=4) + with open(os.path.join(dir_path, "oauth2_token.json"), "w") as f: + if self.oauth2_token: + json.dump(asdict(self.oauth2_token), f, indent=4) + + def dumps(self) -> str: + r = [] + r.append(asdict(self.oauth1_token)) + r.append(asdict(self.oauth2_token)) + s = json.dumps(r) + return base64.b64encode(s.encode()).decode() + + def load(self, dir_path: str): + dir_path = os.path.expanduser(dir_path) + with open(os.path.join(dir_path, "oauth1_token.json")) as f: + oauth1 = OAuth1Token(**json.load(f)) + with open(os.path.join(dir_path, "oauth2_token.json")) as f: + oauth2 = OAuth2Token(**json.load(f)) + self.configure( + oauth1_token=oauth1, oauth2_token=oauth2, domain=oauth1.domain + ) + + def loads(self, s: str): + oauth1, oauth2 = json.loads(base64.b64decode(s)) + self.configure( + oauth1_token=OAuth1Token(**oauth1), + oauth2_token=OAuth2Token(**oauth2), + domain=oauth1.get("domain"), + ) + + +client = Client() diff --git a/garth/src/garth/py.typed b/garth/src/garth/py.typed new file mode 100644 index 0000000..e69de29 diff --git a/garth/src/garth/sso.py b/garth/src/garth/sso.py new file mode 100644 index 0000000..3bef14d --- /dev/null +++ b/garth/src/garth/sso.py @@ -0,0 +1,259 @@ +import asyncio +import re +import time +from typing import Any, Callable, Dict, Literal, Tuple +from urllib.parse import parse_qs + +import requests +from requests import Session +from requests_oauthlib import OAuth1Session + +from . import http +from .auth_tokens import OAuth1Token, OAuth2Token +from .exc import GarthException + + +CSRF_RE = re.compile(r'name="_csrf"\s+value="(.+?)"') +TITLE_RE = re.compile(r"(.+?)") +OAUTH_CONSUMER_URL = "https://thegarth.s3.amazonaws.com/oauth_consumer.json" +OAUTH_CONSUMER: Dict[str, str] = {} +USER_AGENT = {"User-Agent": "com.garmin.android.apps.connectmobile"} + + +class GarminOAuth1Session(OAuth1Session): + def __init__( + self, + /, + parent: Session | None = None, + **kwargs, + ): + global OAUTH_CONSUMER + if not OAUTH_CONSUMER: + OAUTH_CONSUMER = requests.get(OAUTH_CONSUMER_URL).json() + super().__init__( + OAUTH_CONSUMER["consumer_key"], + OAUTH_CONSUMER["consumer_secret"], + **kwargs, + ) + if parent is not None: + self.mount("https://", parent.adapters["https://"]) + self.proxies = parent.proxies + self.verify = parent.verify + + +def login( + email: str, + password: str, + /, + client: "http.Client | None" = None, + prompt_mfa: Callable | None = lambda: input("MFA code: "), + return_on_mfa: bool = False, +) -> ( + Tuple[OAuth1Token, OAuth2Token] + | Tuple[Literal["needs_mfa"], dict[str, Any]] +): + """Login to Garmin Connect. + + Args: + email: Garmin account email + password: Garmin account password + client: Optional HTTP client to use + prompt_mfa: Callable that prompts for MFA code. Returns on MFA if None. + return_on_mfa: If True, returns dict with MFA info instead of prompting + + Returns: + If return_on_mfa=False (default): + Tuple[OAuth1Token, OAuth2Token]: OAuth tokens after login + If return_on_mfa=True and MFA required: + dict: Contains needs_mfa and client_state for resume_login() + """ + client = client or http.client + + # Define params based on domain + SSO = f"https://sso.{client.domain}/sso" + SSO_EMBED = f"{SSO}/embed" + SSO_EMBED_PARAMS = dict( + id="gauth-widget", + embedWidget="true", + gauthHost=SSO, + ) + SIGNIN_PARAMS = { + **SSO_EMBED_PARAMS, + **dict( + gauthHost=SSO_EMBED, + service=SSO_EMBED, + source=SSO_EMBED, + redirectAfterAccountLoginUrl=SSO_EMBED, + redirectAfterAccountCreationUrl=SSO_EMBED, + ), + } + + # Set cookies + client.get("sso", "/sso/embed", params=SSO_EMBED_PARAMS) + + # Get CSRF token + client.get( + "sso", + "/sso/signin", + params=SIGNIN_PARAMS, + referrer=True, + ) + csrf_token = get_csrf_token(client.last_resp.text) + + # Submit login form with email and password + client.post( + "sso", + "/sso/signin", + params=SIGNIN_PARAMS, + referrer=True, + data=dict( + username=email, + password=password, + embed="true", + _csrf=csrf_token, + ), + ) + title = get_title(client.last_resp.text) + + # Handle MFA + if "MFA" in title: + if return_on_mfa or prompt_mfa is None: + return "needs_mfa", { + "signin_params": SIGNIN_PARAMS, + "client": client, + } + + handle_mfa(client, SIGNIN_PARAMS, prompt_mfa) + title = get_title(client.last_resp.text) + + if title != "Success": + raise GarthException(f"Unexpected title: {title}") + return _complete_login(client) + + +def get_oauth1_token(ticket: str, client: "http.Client") -> OAuth1Token: + sess = GarminOAuth1Session(parent=client.sess) + base_url = f"https://connectapi.{client.domain}/oauth-service/oauth/" + login_url = f"https://sso.{client.domain}/sso/embed" + url = ( + f"{base_url}preauthorized?ticket={ticket}&login-url={login_url}" + "&accepts-mfa-tokens=true" + ) + resp = sess.get( + url, + headers=USER_AGENT, + timeout=client.timeout, + ) + resp.raise_for_status() + parsed = parse_qs(resp.text) + token = {k: v[0] for k, v in parsed.items()} + return OAuth1Token(domain=client.domain, **token) # type: ignore + + +def exchange(oauth1: OAuth1Token, client: "http.Client") -> OAuth2Token: + sess = GarminOAuth1Session( + resource_owner_key=oauth1.oauth_token, + resource_owner_secret=oauth1.oauth_token_secret, + parent=client.sess, + ) + data = dict(mfa_token=oauth1.mfa_token) if oauth1.mfa_token else {} + base_url = f"https://connectapi.{client.domain}/oauth-service/oauth/" + url = f"{base_url}exchange/user/2.0" + headers = { + **USER_AGENT, + **{"Content-Type": "application/x-www-form-urlencoded"}, + } + resp = sess.post( + url, + headers=headers, + data=data, + timeout=client.timeout, + ) + resp.raise_for_status() + token = resp.json() + return OAuth2Token(**set_expirations(token)) + + +def handle_mfa( + client: "http.Client", signin_params: dict, prompt_mfa: Callable +) -> None: + csrf_token = get_csrf_token(client.last_resp.text) + if asyncio.iscoroutinefunction(prompt_mfa): + mfa_code = asyncio.run(prompt_mfa()) + else: + mfa_code = prompt_mfa() + client.post( + "sso", + "/sso/verifyMFA/loginEnterMfaCode", + params=signin_params, + referrer=True, + data={ + "mfa-code": mfa_code, + "embed": "true", + "_csrf": csrf_token, + "fromPage": "setupEnterMfaCode", + }, + ) + + +def set_expirations(token: dict) -> dict: + token["expires_at"] = int(time.time() + token["expires_in"]) + token["refresh_token_expires_at"] = int( + time.time() + token["refresh_token_expires_in"] + ) + return token + + +def get_csrf_token(html: str) -> str: + m = CSRF_RE.search(html) + if not m: + raise GarthException("Couldn't find CSRF token") + return m.group(1) + + +def get_title(html: str) -> str: + m = TITLE_RE.search(html) + if not m: + raise GarthException("Couldn't find title") + return m.group(1) + + +def resume_login( + client_state: dict, mfa_code: str +) -> Tuple[OAuth1Token, OAuth2Token]: + """Complete login after MFA code is provided. + + Args: + client_state: The client state from login() when MFA was needed + mfa_code: The MFA code provided by the user + + Returns: + Tuple[OAuth1Token, OAuth2Token]: The OAuth tokens after login + """ + client = client_state["client"] + signin_params = client_state["signin_params"] + handle_mfa(client, signin_params, lambda: mfa_code) + return _complete_login(client) + + +def _complete_login(client: "http.Client") -> Tuple[OAuth1Token, OAuth2Token]: + """Complete the login process after successful authentication. + + Args: + client: The HTTP client + + Returns: + Tuple[OAuth1Token, OAuth2Token]: The OAuth tokens + """ + # Parse ticket + m = re.search(r'embed\?ticket=([^"]+)"', client.last_resp.text) + if not m: + raise GarthException( + "Couldn't find ticket in response" + ) # pragma: no cover + ticket = m.group(1) + + oauth1 = get_oauth1_token(ticket, client) + oauth2 = exchange(oauth1, client) + + return oauth1, oauth2 diff --git a/garth/src/garth/stats/__init__.py b/garth/src/garth/stats/__init__.py new file mode 100644 index 0000000..ff6f94d --- /dev/null +++ b/garth/src/garth/stats/__init__.py @@ -0,0 +1,18 @@ +__all__ = [ + "DailyHRV", + "DailyHydration", + "DailyIntensityMinutes", + "DailySleep", + "DailySteps", + "DailyStress", + "WeeklyIntensityMinutes", + "WeeklyStress", + "WeeklySteps", +] + +from .hrv import DailyHRV +from .hydration import DailyHydration +from .intensity_minutes import DailyIntensityMinutes, WeeklyIntensityMinutes +from .sleep import DailySleep +from .steps import DailySteps, WeeklySteps +from .stress import DailyStress, WeeklyStress diff --git a/garth/src/garth/stats/_base.py b/garth/src/garth/stats/_base.py new file mode 100644 index 0000000..958f4d1 --- /dev/null +++ b/garth/src/garth/stats/_base.py @@ -0,0 +1,53 @@ +from datetime import date, timedelta +from typing import ClassVar + +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from .. import http +from ..utils import camel_to_snake_dict, format_end_date + + +@dataclass +class Stats: + calendar_date: date + + _path: ClassVar[str] + _page_size: ClassVar[int] + + @classmethod + def list( + cls, + end: date | str | None = None, + period: int = 1, + *, + client: http.Client | None = None, + ) -> list[Self]: + client = client or http.client + end = format_end_date(end) + period_type = "days" if "daily" in cls._path else "weeks" + + if period > cls._page_size: + page = cls.list(end, cls._page_size, client=client) + if not page: + return [] + page = ( + cls.list( + end - timedelta(**{period_type: cls._page_size}), + period - cls._page_size, + client=client, + ) + + page + ) + return page + + start = end - timedelta(**{period_type: period - 1}) + path = cls._path.format(start=start, end=end, period=period) + page_dirs = client.connectapi(path) + if not isinstance(page_dirs, list) or not page_dirs: + return [] + page_dirs = [d for d in page_dirs if isinstance(d, dict)] + if page_dirs and "values" in page_dirs[0]: + page_dirs = [{**stat, **stat.pop("values")} for stat in page_dirs] + page_dirs = [camel_to_snake_dict(stat) for stat in page_dirs] + return [cls(**stat) for stat in page_dirs] diff --git a/garth/src/garth/stats/hrv.py b/garth/src/garth/stats/hrv.py new file mode 100644 index 0000000..deaad6e --- /dev/null +++ b/garth/src/garth/stats/hrv.py @@ -0,0 +1,66 @@ +from datetime import date, datetime, timedelta +from typing import Any, ClassVar, cast + +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from .. import http +from ..utils import camel_to_snake_dict, format_end_date + + +@dataclass +class HRVBaseline: + low_upper: int + balanced_low: int + balanced_upper: int + marker_value: float | None + + +@dataclass +class DailyHRV: + calendar_date: date + weekly_avg: int | None + last_night_avg: int | None + last_night_5_min_high: int | None + baseline: HRVBaseline | None + status: str + feedback_phrase: str + create_time_stamp: datetime + + _path: ClassVar[str] = "/hrv-service/hrv/daily/{start}/{end}" + _page_size: ClassVar[int] = 28 + + @classmethod + def list( + cls, + end: date | str | None = None, + period: int = 28, + *, + client: http.Client | None = None, + ) -> list[Self]: + client = client or http.client + end = format_end_date(end) + + # Paginate if period is greater than page size + if period > cls._page_size: + page = cls.list(end, cls._page_size, client=client) + if not page: + return [] + page = ( + cls.list( + end - timedelta(days=cls._page_size), + period - cls._page_size, + client=client, + ) + + page + ) + return page + + start = end - timedelta(days=period - 1) + path = cls._path.format(start=start, end=end) + response = client.connectapi(path) + if response is None: + return [] + daily_hrv = camel_to_snake_dict(response)["hrv_summaries"] + daily_hrv = cast(list[dict[str, Any]], daily_hrv) + return [cls(**hrv) for hrv in daily_hrv] diff --git a/garth/src/garth/stats/hydration.py b/garth/src/garth/stats/hydration.py new file mode 100644 index 0000000..e3c3de4 --- /dev/null +++ b/garth/src/garth/stats/hydration.py @@ -0,0 +1,17 @@ +from typing import ClassVar + +from pydantic.dataclasses import dataclass + +from ._base import Stats + + +BASE_PATH = "/usersummary-service/stats/hydration" + + +@dataclass +class DailyHydration(Stats): + value_in_ml: float + goal_in_ml: float + + _path: ClassVar[str] = f"{BASE_PATH}/daily/{{start}}/{{end}}" + _page_size: ClassVar[int] = 28 diff --git a/garth/src/garth/stats/intensity_minutes.py b/garth/src/garth/stats/intensity_minutes.py new file mode 100644 index 0000000..57264b7 --- /dev/null +++ b/garth/src/garth/stats/intensity_minutes.py @@ -0,0 +1,28 @@ +from typing import ClassVar + +from pydantic.dataclasses import dataclass + +from ._base import Stats + + +BASE_PATH = "/usersummary-service/stats/im" + + +@dataclass +class DailyIntensityMinutes(Stats): + weekly_goal: int + moderate_value: int | None = None + vigorous_value: int | None = None + + _path: ClassVar[str] = f"{BASE_PATH}/daily/{{start}}/{{end}}" + _page_size: ClassVar[int] = 28 + + +@dataclass +class WeeklyIntensityMinutes(Stats): + weekly_goal: int + moderate_value: int | None = None + vigorous_value: int | None = None + + _path: ClassVar[str] = f"{BASE_PATH}/weekly/{{start}}/{{end}}" + _page_size: ClassVar[int] = 52 diff --git a/garth/src/garth/stats/sleep.py b/garth/src/garth/stats/sleep.py new file mode 100644 index 0000000..d5b10a6 --- /dev/null +++ b/garth/src/garth/stats/sleep.py @@ -0,0 +1,15 @@ +from typing import ClassVar + +from pydantic.dataclasses import dataclass + +from ._base import Stats + + +@dataclass +class DailySleep(Stats): + value: int | None + + _path: ClassVar[str] = ( + "/wellness-service/stats/daily/sleep/score/{start}/{end}" + ) + _page_size: ClassVar[int] = 28 diff --git a/garth/src/garth/stats/steps.py b/garth/src/garth/stats/steps.py new file mode 100644 index 0000000..bd5a293 --- /dev/null +++ b/garth/src/garth/stats/steps.py @@ -0,0 +1,30 @@ +from typing import ClassVar + +from pydantic.dataclasses import dataclass + +from ._base import Stats + + +BASE_PATH = "/usersummary-service/stats/steps" + + +@dataclass +class DailySteps(Stats): + total_steps: int | None + total_distance: int | None + step_goal: int + + _path: ClassVar[str] = f"{BASE_PATH}/daily/{{start}}/{{end}}" + _page_size: ClassVar[int] = 28 + + +@dataclass +class WeeklySteps(Stats): + total_steps: int + average_steps: float + average_distance: float + total_distance: float + wellness_data_days_count: int + + _path: ClassVar[str] = f"{BASE_PATH}/weekly/{{end}}/{{period}}" + _page_size: ClassVar[int] = 52 diff --git a/garth/src/garth/stats/stress.py b/garth/src/garth/stats/stress.py new file mode 100644 index 0000000..f41b26e --- /dev/null +++ b/garth/src/garth/stats/stress.py @@ -0,0 +1,28 @@ +from typing import ClassVar + +from pydantic.dataclasses import dataclass + +from ._base import Stats + + +BASE_PATH = "/usersummary-service/stats/stress" + + +@dataclass +class DailyStress(Stats): + overall_stress_level: int + rest_stress_duration: int | None = None + low_stress_duration: int | None = None + medium_stress_duration: int | None = None + high_stress_duration: int | None = None + + _path: ClassVar[str] = f"{BASE_PATH}/daily/{{start}}/{{end}}" + _page_size: ClassVar[int] = 28 + + +@dataclass +class WeeklyStress(Stats): + value: int + + _path: ClassVar[str] = f"{BASE_PATH}/weekly/{{end}}/{{period}}" + _page_size: ClassVar[int] = 52 diff --git a/garth/src/garth/users/__init__.py b/garth/src/garth/users/__init__.py new file mode 100644 index 0000000..1e16433 --- /dev/null +++ b/garth/src/garth/users/__init__.py @@ -0,0 +1,5 @@ +from .profile import UserProfile +from .settings import UserSettings + + +__all__ = ["UserProfile", "UserSettings"] diff --git a/garth/src/garth/users/profile.py b/garth/src/garth/users/profile.py new file mode 100644 index 0000000..97491d1 --- /dev/null +++ b/garth/src/garth/users/profile.py @@ -0,0 +1,79 @@ +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from .. import http +from ..utils import camel_to_snake_dict + + +@dataclass +class UserProfile: + id: int + profile_id: int + garmin_guid: str + display_name: str + full_name: str + user_name: str + profile_image_type: str | None + profile_image_url_large: str | None + profile_image_url_medium: str | None + profile_image_url_small: str | None + location: str | None + facebook_url: str | None + twitter_url: str | None + personal_website: str | None + motivation: str | None + bio: str | None + primary_activity: str | None + favorite_activity_types: list[str] + running_training_speed: float + cycling_training_speed: float + favorite_cycling_activity_types: list[str] + cycling_classification: str | None + cycling_max_avg_power: float + swimming_training_speed: float + profile_visibility: str + activity_start_visibility: str + activity_map_visibility: str + course_visibility: str + activity_heart_rate_visibility: str + activity_power_visibility: str + badge_visibility: str + show_age: bool + show_weight: bool + show_height: bool + show_weight_class: bool + show_age_range: bool + show_gender: bool + show_activity_class: bool + show_vo_2_max: bool + show_personal_records: bool + show_last_12_months: bool + show_lifetime_totals: bool + show_upcoming_events: bool + show_recent_favorites: bool + show_recent_device: bool + show_recent_gear: bool + show_badges: bool + other_activity: str | None + other_primary_activity: str | None + other_motivation: str | None + user_roles: list[str] + name_approved: bool + user_profile_full_name: str + make_golf_scorecards_private: bool + allow_golf_live_scoring: bool + allow_golf_scoring_by_connections: bool + user_level: int + user_point: int + level_update_date: str + level_is_viewed: bool + level_point_threshold: int + user_point_offset: int + user_pro: bool + + @classmethod + def get(cls, /, client: http.Client | None = None) -> Self: + client = client or http.client + profile = client.connectapi("/userprofile-service/socialProfile") + assert isinstance(profile, dict) + return cls(**camel_to_snake_dict(profile)) diff --git a/garth/src/garth/users/settings.py b/garth/src/garth/users/settings.py new file mode 100644 index 0000000..649623b --- /dev/null +++ b/garth/src/garth/users/settings.py @@ -0,0 +1,108 @@ +from datetime import date +from typing import Dict + +from pydantic.dataclasses import dataclass +from typing_extensions import Self + +from .. import http +from ..utils import camel_to_snake_dict + + +@dataclass +class PowerFormat: + format_id: int + format_key: str + min_fraction: int + max_fraction: int + grouping_used: bool + display_format: str | None + + +@dataclass +class FirstDayOfWeek: + day_id: int + day_name: str + sort_order: int + is_possible_first_day: bool + + +@dataclass +class WeatherLocation: + use_fixed_location: bool | None + latitude: float | None + longitude: float | None + location_name: str | None + iso_country_code: str | None + postal_code: str | None + + +@dataclass +class UserData: + gender: str + weight: float + height: float + time_format: str + birth_date: date + measurement_system: str + activity_level: str | None + handedness: str + power_format: PowerFormat + heart_rate_format: PowerFormat + first_day_of_week: FirstDayOfWeek + vo_2_max_running: float | None + vo_2_max_cycling: float | None + lactate_threshold_speed: float | None + lactate_threshold_heart_rate: float | None + dive_number: int | None + intensity_minutes_calc_method: str + moderate_intensity_minutes_hr_zone: int + vigorous_intensity_minutes_hr_zone: int + hydration_measurement_unit: str + hydration_containers: list[Dict[str, float | str | None]] + hydration_auto_goal_enabled: bool + firstbeat_max_stress_score: float | None + firstbeat_cycling_lt_timestamp: int | None + firstbeat_running_lt_timestamp: int | None + threshold_heart_rate_auto_detected: bool + ftp_auto_detected: bool | None + training_status_paused_date: str | None + weather_location: WeatherLocation | None + golf_distance_unit: str | None + golf_elevation_unit: str | None + golf_speed_unit: str | None + external_bottom_time: float | None + + +@dataclass +class UserSleep: + sleep_time: int + default_sleep_time: bool + wake_time: int + default_wake_time: bool + + +@dataclass +class UserSleepWindow: + sleep_window_frequency: str + start_sleep_time_seconds_from_midnight: int + end_sleep_time_seconds_from_midnight: int + + +@dataclass +class UserSettings: + id: int + user_data: UserData + user_sleep: UserSleep + connect_date: str | None + source_type: str | None + user_sleep_windows: list[UserSleepWindow] | None = None + + @classmethod + def get(cls, /, client: http.Client | None = None) -> Self: + client = client or http.client + settings = client.connectapi( + "/userprofile-service/userprofile/user-settings" + ) + assert isinstance(settings, dict) + data = camel_to_snake_dict(settings) + return cls(**data) diff --git a/garth/src/garth/utils.py b/garth/src/garth/utils.py new file mode 100644 index 0000000..75eb3e8 --- /dev/null +++ b/garth/src/garth/utils.py @@ -0,0 +1,73 @@ +import dataclasses +import re +from datetime import date, datetime, timedelta, timezone +from typing import Any, Dict, List, Union + + +CAMEL_TO_SNAKE = re.compile( + r"((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z])|(?<=[a-zA-Z])[0-9])" +) + + +def camel_to_snake(camel_str: str) -> str: + snake_str = CAMEL_TO_SNAKE.sub(r"_\1", camel_str) + return snake_str.lower() + + +def camel_to_snake_dict(camel_dict: Dict[str, Any]) -> Dict[str, Any]: + """ + Converts a dictionary's keys from camel case to snake case. This version + handles nested dictionaries and lists. + """ + snake_dict: Dict[str, Any] = {} + for k, v in camel_dict.items(): + new_key = camel_to_snake(k) + if isinstance(v, dict): + snake_dict[new_key] = camel_to_snake_dict(v) + elif isinstance(v, list): + snake_dict[new_key] = [ + camel_to_snake_dict(i) if isinstance(i, dict) else i for i in v + ] + else: + snake_dict[new_key] = v + return snake_dict + + +def format_end_date(end: Union[date, str, None]) -> date: + if end is None: + end = date.today() + elif isinstance(end, str): + end = date.fromisoformat(end) + return end + + +def date_range(date_: Union[date, str], days: int): + date_ = date_ if isinstance(date_, date) else date.fromisoformat(date_) + for day in range(days): + yield date_ - timedelta(days=day) + + +def asdict(obj): + if dataclasses.is_dataclass(obj): + result = {} + for field in dataclasses.fields(obj): + value = getattr(obj, field.name) + result[field.name] = asdict(value) + return result + + if isinstance(obj, List): + return [asdict(v) for v in obj] + + if isinstance(obj, (datetime, date)): + return obj.isoformat() + + return obj + + +def get_localized_datetime( + gmt_timestamp: int, local_timestamp: int +) -> datetime: + local_diff = local_timestamp - gmt_timestamp + local_offset = timezone(timedelta(milliseconds=local_diff)) + gmt_time = datetime.fromtimestamp(gmt_timestamp / 1000, timezone.utc) + return gmt_time.astimezone(local_offset) diff --git a/garth/src/garth/version.py b/garth/src/garth/version.py new file mode 100644 index 0000000..496906a --- /dev/null +++ b/garth/src/garth/version.py @@ -0,0 +1 @@ +__version__ = "0.5.17" diff --git a/garth/tests/12129115726_ACTIVITY.fit b/garth/tests/12129115726_ACTIVITY.fit new file mode 100644 index 0000000..9fba182 Binary files /dev/null and b/garth/tests/12129115726_ACTIVITY.fit differ diff --git a/garth/tests/cassettes/test_client_request.yaml b/garth/tests/cassettes/test_client_request.yaml new file mode 100644 index 0000000..df6d4ea --- /dev/null +++ b/garth/tests/cassettes/test_client_request.yaml @@ -0,0 +1,461 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connect.garmin.com/ + response: + body: + string: "Garmin Connect |

\n\n

\n" + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f0ee80fca96154a-QRO + Connection: + - keep-alive + Content-Type: + - text/html; charset=UTF-8 + Date: + - Thu, 03 Aug 2023 13:28:55 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=pBhM%2FFYBcODg%2FPIna39iyE9lAG%2BDKwwlec%2FLBrLJv6uI1Oh03efBEQDeNQPAgyjUSUPf96sdG75o2goOlnGkTY8%2FQpPnO5quPWlTXL9DuQP%2F2W8Yn3uECo5%2FAsbsupzUx0pbXA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + cache-control: + - no-cache + last-modified: + - Wed, 24 May 2023 14:26:45 GMT + x-frame-options: + - deny + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/ + response: + body: + string: "Not Found\n\n
\n + \

Page Not Found

\n\n

We're sorry. + The page you're looking for does not exist.

\n
\n\n\n" + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f0ee8119bcb155f-QRO + Connection: + - keep-alive + Content-Type: + - text/html + Date: + - Thu, 03 Aug 2023 13:28:55 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=QIDnUWv2zs9Snb92gU%2BaTTvPJVmZifjxFWfJbPr3Ua7lsSIF3HLhgED53f7VE7jV9ucgR6Z9e41tBz6gqv%2Fmc4IMZ7fEvhPpMJ%2B1kz1AKfl4Ey0Gis1E5D2umJ0UbLSGo7gQ%2BjPxaw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache + status: + code: 404 + message: Not Found +version: 1 diff --git a/garth/tests/cassettes/test_connectapi.yaml b/garth/tests/cassettes/test_connectapi.yaml new file mode 100644 index 0000000..f95e45a --- /dev/null +++ b/garth/tests/cassettes/test_connectapi.yaml @@ -0,0 +1,65 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/daily/2023-07-21/2023-07-21 + response: + body: + string: '[{"calendarDate": "2023-07-21", "values": {"highStressDuration": 3240, + "lowStressDuration": 20280, "overallStressLevel": 35, "restStressDuration": + 31020, "mediumStressDuration": 11640}}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d932aa00b6ee-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:57:49 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=FuGLLTTuU8CV4eTRQnQ7XY0oTrHoXEaIYrPbxrkK1vRVT4yAr2Zv0YIj4D%2BZ0eQTeYgycpuCP1gSE4yk0bZE2Aj2p29AIZ2Ce%2BuOUJqB9Mp54VyHR9uEC5AAcVLUYqtzpE4YIK0Fgw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_delete.yaml b/garth/tests/cassettes/test_delete.yaml new file mode 100644 index 0000000..49f7c58 --- /dev/null +++ b/garth/tests/cassettes/test_delete.yaml @@ -0,0 +1,223 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/activity-service/activity/12135235656 + response: + body: + string: !!binary | + H4sIAAAAAAAAA6VW23LbNhD9lQ6eRZsXURL5ZstOookle2SpmbbT8ayAJYUGBDgAqETJ+N874EWk + ZbV96Btx9oLF7p5d/iRALT9we1wwkgZhEMVhFE/iyegk2G4XdyT9SaqKM5KS2SxJqD9NvCQJY288 + zSIPwmnosSBE5tNxsIMpee3NV1AgSclvKgcyIpVB/aRVxgW6C8M4CSZ+OCLcLCth+XOptH0CjdKS + NANhsHe0OZZ4t3l0odhjWZsHk2hUHz7jkaTk2NxR1vabVidMnPdPnDGUJ58ajdWcWmQnyGpeFLAT + 2CKvI4KH1s/Ztcnw0kpSsJgrzX8gIyNilLaPmqEmaeDXeaBozFxJq5VYV+LcWTh0Vmp+AIsuf5YX + +LuSuJXctiaV5LZ+dhyO6kNjdFOg5hSu53tOIVdkRDKgVmmS+ld+7+iC5uuIFGiBgYX2Cm4eNc+5 + BEFSqyscEYYHTvGmLAWnYLmSC2ksCNF8u2yEQTh2/ZKjtP+iJyshWq1nq7nMO8g1wwelC7Augqz+ + cgbTUXtonplxW/eVMYpysMjmqtIGe9cCjN2WDCzeuRymJPTDyPMTL0w2YZCOkzSOr3zXhKVQwJD9 + h9qBM1RbLTr/ezBPShwFl3jqmj2Y+R60vQMLXcb2YD7pDS9wIV3ezQB/Ut/wraj143ixkJm6s6qu + dE+Tp68DmjBuSgFH2XCqsFDwH9wVvBKiBZdgufxl00nKlmwF5LjV4gF0jt2DzmRLZLwqSEr21pYm + vb420RUU8ENJ+GauqCquc9AFlx5VUiK1XqkVu26dvHDnxVxPZjEECSYeTHfojSEIvGSXJV4GFHwa + syALwGvfc1XK/H2IzwUI8X+jiPww88PA85FOvTGjibfzaeQxF9yOxuDP6FkUbcp79tM9F2zBDEn/ + +LM93QxGUYsblEbp9nCapXUUDVaArBwfK+1GAvl4s14uVsSV8oCrqtg5tOvfcq4qN/mCYZt/Ufqr + qmzf59zc2LILpQMbmi7Rwl3P5gZ0liSKwiSZziazgHTK7hWuu6LJdOZ34K+oDVfS4Q2xX+vGXUiL + 0rinSYv6AMIMKfBcCm57BG/5V1zC9xtjuLFLxVwumjBr0S1Yi/q4NdD34lCwxgK4HEyIWth7q4my + eXzgxg64ua5kTa8vXLKGjo2IgkDJQN+7ae5MO0GuVVWuOcNmw7Xalb40WwqwdI9sfllaojZKglgj + VbpfKVBZNQdB5yCU5gO2Z3BQmtt+jLgmAdHXtFtTZ0+6l25Bna7N6V9++HaBDRYaCjzUw3eutMbB + rnsdEVMVBehj2ybGgrZuKj0o6gZ/PxFnmyBJAz+Np/VEPCl+XG7eDk7fH6gxlyWuJEmTq8l0MiKF + OnCZ353DKKA0yN7h9JSvwC2wXaH7DNYrDQ6oIcdPa5LOpg4o4Ht9SAbSDRYlanDEI2k0btUuoVxe + QK1uevA+y5Da7mIJqNWO081F6SXZEk3T52T1+HJzv368Xcxfbu9X9x8Wm5dgRv7R6VvD1bmpS3Q9 + b/AZHfeiEfkGFvW9sbyAutrB+3c8wA5dhberz6vHLysy+L1q9R4UsPo9syAI4mkYTuJJGNdZ6vrz + Acp3Natb49lqNIakk8jdjJKdgDo/jGcZapQUO9yrFY3F0pXWlS4/mYRtxYZOX1//BraydeSxCgAA + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 80e771592928359a-DFW + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 29 Sep 2023 21:50:37 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=m77%2F5qqWH%2FzNYg9h9aJB23Sa8erERimKhptV3iEpuPvFpQKcBvr8kHp%2B0tcMmTnLbEN%2FZr0zE7r9yfH0C5bHKK80P8CeBzFhzo9RkFicBPRHZMMaxBDwn7fNmDGgZpOGV9NydCV2LQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Content-Length: + - '0' + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: DELETE + uri: https://connectapi.garmin.com/activity-service/activity/12135235656 + response: + body: + string: '' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 80e7715a5b05359a-DFW + Connection: + - keep-alive + Date: + - Fri, 29 Sep 2023 21:50:37 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=RR3a8akw5KIfJ40HMjm%2FVxtacqIHiN3EkPNr5ZFwq02kvcv2Wt8fzZL9kbXMXFTHMd3iL7ZcPj4074wQQsCMR29xUXurv6SH5Nd2hdW2qeQT%2Bl7fsosUtcPp3mglfZcBnFOy9JteAg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 204 + message: No Content +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/activity-service/activity/12135235656 + response: + body: + string: !!binary | + H4sIAAAAAAAAA6tWyk0tLk5MT1WyUvIICQlQMDEwUfDLL1Fwyy/NS1HSUUotKsovUrJS8ssvAQu5 + ViSnFpRk5ucp1QIAv2CADDwAAAA= + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 80e7715cbe4b359a-DFW + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 29 Sep 2023 21:50:37 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=sBhGq8nTIKEsQsz%2FTdQHQGlCFN93mqZLF20y8BX8Vf4lPeqs0bM27QSt8IU1udH7S7x8wGmhmS3PzVMmthvCEbT8L1GrNICizdJ6H28Z%2Bd3F%2B4Em9Upz9aThxIiFzIPB8Zw6iEN%2Fqg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 404 + message: Not Found +version: 1 diff --git a/garth/tests/cassettes/test_download.yaml b/garth/tests/cassettes/test_download.yaml new file mode 100644 index 0000000..cc01a07 --- /dev/null +++ b/garth/tests/cassettes/test_download.yaml @@ -0,0 +1,618 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://connectapi.garmin.com/download-service/files/activity/11998957007 + response: + body: + string: !!binary | + UEsDBBQACAgIAJCTK1cAAAAAAAAAAAAAAAAYAAAAMTE5OTg5NTcwMDdfQUNUSVZJVFkuZml0tN0L + nFbT3zf+vdd1zVzTNE3TNNVMM9VIMhKm01Q611RTKiPFSAghhJzPVKaEJCaEkIQQBvErx5BMfqHj + zCDnSIRQJGme7/ezvmvP+nb//vfz/F/Pc3vdv5v9nn3ta332XnvttU/rSs+4enR5WRgcOWTYmBln + 9Q/on0QsPjsen5mIzwxNuTHlSaY8CIOg58XXrn79g9P71dE/YfBpWl1dfEAQdAqSTFYiMOVhaGJh + EA951v/6T0EqfWpgEOSH8X/iMw0vkf8xdoE33jgoCIaGKfSnWHwmfXdSfGYQGvq7CU1yGMR4tjRa + zML8IIjTvxuE5j9jcRAMCWO0nIBKT4vieTrR32L0v8FB0CxI2O+gUoZcWtM0NFmhSeL5pKh1dUOC + oEWQhxln01pIic9sHJ+ZEZ/ZJD+RHZ/dBuWPY72kmvJGpryZuc2WNjk0VIiGockMg6wwtXkYtAhN + Thi0SjatQ5NPM/D38IqsO+Cf/7TODvzHrXisyzqBOvr/SW4pyS7G/4vFh/H/54v3P2FS/kcWPzGw + n4il/g+snC/THrGlDuJpBy5+aBA0Dxr+41XcWGiogiWFAVWLlNCkh6ZxaBJuF4rF+P+XBMHtQdI/ + qKzG1cwUlPTV0/pN3T0J84bDaH0F59t5xsVnPtE/kWLKO5nyo015L96XZNdLCsMGYZAaBg3DIC0M + GrkvRUUMqCK2DIO8MGgdBm3CoG0YHBwG7cKgfRgcFgYdwuDwMOgYBkdQYxAGR4VBYRh0C4OiMOge + Bj3CoF+joH8YDAiDgWEwKAyKw2BwGBwTBiPCYGQYlIbBcWEwOgyOD4MxYTA2DE4Mg1NDMyEMTg9T + zwiDs8JgUmvKEEwOgwvC4MIwuCgMpoTBZWFweRhcF5rrQ3NDGNwYBlPDYFoYTA+Dm8KgPAxmhMEt + YXBrGNwWBreHZk5o7gjN3DC4MwzmhcHdYXBvGCwMg0fC4NEwWByaJWHwVGPzfGheCM2LYbAsDF4K + g0+oZodBA96UC5/G9rrx/2Sz/++qxLrETtoyYVAXxGLx1p2pTdlfF9L24n+COm4LMWU/gEmaoOoR + 4w3FHob0Udq2B8Uz0tOSW8ZMqwNrZ50sjj7XOU4VK+D/ow/Ggol2CdS4BimJBo0apiUlp6eG8cDE + klqH/FXDud1rlxef2So+87D4zA7UHpryNqY835QfZMoPMeXtudkOYlJJgwRVvdCg4gTpYdAkDKgd + axYG2SE1X1RTDCqIOSJMpdrRlWuHKQpNzzA4Ogx6J4K+VPVWnhIEGTS5r2BwXy56j5iNcD2trvBl + uxaCziYYQ//VhCpqLC7HC9phjgmCimBAEJ9tMhKN4jMz46lZaan94zMHxGcOic/cj9a2Ibe25Tmm + vKWL0daUH2zKC8xt3U15D1Pe05QPM7eN9Y5HUbYGnE32iIzQNAlTm4ap2bwvGNoLDkkE7RPBoYng + sIRx+0Kqvy90TjZdXGxK2Cs0vcOgT0ixTb+Qjl5c+U9AtW+4dehVj5SMHnlE6SUXHV3UvUv3oq5B + 8J9aGt0K1f/3VtoGU2L1FqN/c036D7P+f/zzJlWsujFbM2949LPAftJ+piF/7cCzTr/s0vwh516W + TwUM/vdFC//D97k54vzv/19Fwxy7Ns3asv0X09zzEUFwbHDoP/ZIG5+RGZ/RND6jWXxG8/iMnPjM + lqjFreMzD47PbBefQR2OmCmnRrAB6kQajsNZpryFucnWiUPMTbYVdjXAJMIw1W1+qtG5ockLTRsc + ltO4wV0Xtv9xXu/0IK0qPcg7LD0Y+CRtzwF5gavSW844Kii78orgPNP6x4weLYLfenSN3RuMji0J + qoLraY3N3x8EL9K/278cDnkj7BB0rEujqCODIC1oFMtPpMaN7XTY+oh+AjXShva1xmHQNMY7WqOT + Ljrn9P+2zRkb1KUezns9rUbepUYFQaPgGPSYZiTHZ1Df5CDe12cUxWcWx2cMy5gxPGPGOOw8Bqur + OXab/rLf817R0NvjqSAZ2ONb8E4f5OJo0QoHjOhocQgfMMyhoSngY4b5r8eMLjhs0DGDGobevHsE + /dxhg3aSEnfMGBUGx3rHjLG885iTwuAUPmwEk0I5VNDh4Soq28KZqIQ38v8ev8ygDuUOiGrbjf8H + /6O6OTTjAjped25JGyU5SEVrZKssGiFana1dZabGW3pYbr8LpHYfSx3koFEG1qmtgo3R2Bi0omhm + 6o/Aje33VqGcbyxBqxz0D4Is9EMvoyVwBQipo31zaGZRy84VcXZq/7y6Rf0p3XZq7OONuGylwRv1 + f0l6w/VWee9LfuN/tk/5xv9sn/L/dvH+J/5Dn/L/xeL/mz7l//3K+e/6lGEuHc6T3vTPTYI3bT1o + RfUgTM+PNQxWepBMTVXwlgdUybODt33ob/KDdzyIJycVBKsAA1rVVQ4I5wzd1SV414O7qvb1ClZ7 + UDAxv3/wHmAgwcAwLUgrCaoAgwgG2Rq7xgMOErwPKCYo5oamMvi3B60XNm4YrPUgk7IkPlC95YG8 + 5/BZ4mRT/l93HsMzvxSfnTqYPj8Y0c2Hmii8+UhoSKu6iiFhvGVYYNYpGlgwr8isV3Q/rQKzQRGv + BLORaFlE+2P7h5lNQkPpG4diRZjN9XNVDsGqMNWKeDuaGk2U3tQK2bWMQB+ruRDoE6IVESHQp4pW + betSZLaAdgrdw4E+I3qNyBYVgT4XsusLgb4gWhkRAn0pZDcUAn0FmtDAbm4E+pqoKqIUDvSNEAVa + JIG2ClFtrLDV03xLtDai+P6gwHwHmp/Sr1XdtH7h3MSuLmabonlVe3uZ74m2RoRA2xUh0A9E/0SE + QD+C1iUs0XEvMDsUIdBPihDoZ6LmSY4Q6BeiI4n6tqqb3NcG2glKSfTNY4rvpUC/Kpqz7dFC85ui + uVV7epnfFSHQLkUItFsRAv1BdDhRn7y6kj420J+KEGiPouYc6C9FCLRXEwf6m6hLRPE/KNA+RePf + 61Jo/lE0s2pnL7NfEQLVKQoCChR8aIkC5UugUKgfkWwhI0THxHzbFpqY0ACiAdQsUaA4aJ0QAiUJ + DSQaaAMlq7nihvahhJBd/IKh7QpNipAtxPSqHb1MA1DXFFtUBEolOoqIAuVToJ1BpWko1DuvLqc3 + bbSgxKQpQsZGipAxHbSPl5UjG62xkP3GDM6YIUSlz5GMTYgOI6KMOZIxU2gQfXBQGG9OGZsKDaa5 + Bof3n5NVaLIUTa/6uZdppggZmwsV59VlFoc/cKAW9d+YOdAGygZ1TaFVmNnfBsr5kCtT1xRahZmy + W7UUsnMhUK4QBcqUQHlCdvEI1AqEQJkUKJMCtRay5VowK15o2hBlEQ0hGkK1cFcvky80NK8uTRq+ + g4RKiEp43y4xbUETGlhCoIOJWhINJxoe5vahQO2EjiE6xgY6RBHaifZEh0SEQIeCVjniQAWK4h0o + 0GFC9I35w8PUJylQB0Vzq/b3MocrQqCOigIOdARRnk+l5khFuZ2oJT9KEQIVKsJu1YnoYKJheXXT + htlAnTVxoC6K4u0pUFeiwojenkQteTdFczhQEdHgpLw0SwjUXREC9TiQSk1PIdq0i4ZSINpCRxMd + Q0TbcVGJDdRLUSoH6n0gZZs+RJcTUezK4TZQXyFaPB0y422TCkw/IfpgZYkN1B+0vKElBBqgCIEG + KkKgQQdSqSlWhECDhagQk4faQEMUIdBQokk+ZZsSTRxoGNEVEcVb0xYarohOASvNMYpqJy0uNCOI + pkWEjCMVIeMoIdr5SobYhu9YRchYKkQNTNlgm/E4Rcg4mui6euKMxytCxjFEM5LGOOKMYxWhnThB + iHowZcXh+HN2FZoTieZFNJs7SGWKEOgkoseSdnK3dvIgu9HGHUil5mQh6ueUDbSBxitCoFOEqJ9T + Yvvu5lTQ8obUnyiR/sRpRAuJ7FwINEERjlanK1q1raLInEH0fESzuD9xpiIEmkj0rv1G2xsqMWcd + SKXmbCH64OT+tp04h+jDiBBoEmiMUMCBzlWEQOcR1dQTBzpfEQJNVlRSsKqTuYBoV0QzOdCFihDo + IqIOyWMa0rlKxQCcmpgpQrTuK+TQdLEiBLoEtIr7qxWDcD5iLlWELXSZkO37ItDlmjjQFUStiKRP + zsfaK0ETGth+9Cruwl6lCD2+qxUh0DV8OCGyy0KgaxUh0HWKcvtQoOuF7LIQ6AZuyYlsUdGS36gI + gaZq4kDTFGEfmq6oeNvvXcxNiuZzoHKiJhEh0AxF+2L7hpmZQl6gm9Vc2EKzFKHK3SJkTzLQ8N2q + yKRR+3UbaFX9XNlmtpCcW3HG29Vc8XRq3OcomndO1yJzh/rgvKo/epm5oJ1ynoaMdxJ9T/s21cJF + A2w3/S5FyFihCBnnEf0WETLeDVrVwBI22j1E+yNCoHuF6s/zzXwhuyPjvOM+ITo7mdY3TDuHauH9 + RHXUN+lD1IdqIQV6QIjmqpBe7QJF6KY/KOS1Ew8pQsP3sJDXTiwUotKXSaBHhGgVlsiZ4SIh2tol + UgsfVYTdarEQVfKSweFdkyYWmseIdkc0h3t8jytCoCcUYQstEaLF9yy2gZ5UlNstCBJPfehfkwh4 + EkvpOTi8lSDxtPy9Dn8fxNcs4v7VvtjT+ERdqzDr4DvfiS11U7sqclbEnnFT9O0NY8+6KT7axZ5z + U7x6YpVu6qmg/5eJ51WhzPNSbHtq3zEI9pgXFNHil5sXib6julbSivsWXBqzTBFW+ktC9oPxtmsK + zMtCw4iGhSvb7Oxu/kX0bfTBe6qCHmY5qHdjd30h6G9WKMJKf0URVvqrinB94TWiT4m8tux10KQM + O1cW16I3iH4gktJzLXpT6Bgi6WavFBpBNCKMFzUoMG8JjSQaGa7aTvv524oWcKB3hEYRjbK1aBXR + 10THEh1L35haYt5VhECrFSHQe6A9TUqJSouDYBJuA8dxawM3j8M4z8JX/c5Lz8izkav8D9lTpTWK + EPl9oeOIjgtNMTWA/yaqjghrYS1oUsZootFhfDi1dh8oMrft7m4+JNoS0SJeCx8JHU90vF0L6xTF + g3iJWa8Ia2ED0edEY4jG2LWwUcjOhYybFPFVQLNZETJWgzLShThQjdBYorE2UC3RRiJb+pInuhWZ + jxUt5n7rJ4oQ6FPQZUI4RG1RhECfEb1IZNcqzm8/V4TW7gtFOB38EtS7sWwODvQV0YZ64kBfE22P + KD6EAn2jaPpwCrRV0UIO9C1oUoYlBPpOEQJtU4RA3ytCoO2KEOgH0MpML9CPihBoBypARBzoJ6Iv + iGxdjdORxfwsRHvGomPD0gIK9AsouxnteBW841GgnUK0x1aMsIF+FaL9uuIYCkQtyW9Cw4nk/PZ3 + IWqoKobZQLtAS5pbQqDdQtRsTC6xZxZ/KEKgP7GFljSn9qZMzp72CFG3pUwuvf4FWpBt6aFJWYVm + r6L5fGbxtyIE2qcITeM/ihBov5A93mAfqiN6KyIECj6yREetnGLbToSKEMho4kAx0MQcSzjAxomW + EdHi8weH80raFZokRTjAJitCoATR6ojQY0gBoaj5ci25gaLckyhQKtEH9XNlUfvVUBEypglRUSuK + +fZChmkEmtLCEjKmE20isj14ZGysKJ5KGTOI/o6oauajnU0TRXOqfutlMkFfNhuYF3XzmipK4eY/ + S6g4D/c5OGMzop8jwkZrrggNXwvQ0kZ0mkqHOJxsZBOlJjtCoBwhOn12NwBaErWJKN6S2olcIfvB + DY9R3zwPNDvVznUPB2pFdHBECNRaUTxILjFtFCFQPlGfiBDoIEXYQm2JLqknDnSwIgRqJyQZOdAh + ai4Eak80JaKM76jfeqiQ/eA8DlSgCIEOU4SGrwPRuREh0OGK0E50dIQeBwIdoeZCoCMVIdBRRGcn + q3tOhaDlDS3Fm1OgTorQheosZDs0d3GgLmouBOqqaD8H6kY0jkhurXGgIkUI1F2IPjhNAvUQogZm + mmyhnmouBDqaqFk9caBeitBO9FY053s6Ye+jiQIl+n6kOs886f6OznO/j/zOc6wf/k6d3BueqHgr + 1t9N/VbRakVsgJvi1RIb6Ka45YwNclO8MmLFNDU1jaa4psYGuyl0sYe4KcNd7KFuCl3skmiKMseG + 0dRWnuK4seFuipZSGTvGTa3dvqtLbET9337rFRtpp/JsOUd9xLc4aQrlPNZNoZylbgrlPM77W8PY + aDsl5Tze/Q3lHBNNcTnHuimU8wQ3hZKdWL9MKlmZm0LJTlIlG6dKdrIq2XhVslPcFEp2qirZaapk + E1TJTlclO0OV7ExbDaRkE90USnaWm0LJznZTKNk53t8axia5KZTsXDeFkp0XTXHJzndTKNlkN4WS + XVC/TCrZhW6qQ0M67bpIVWfDky2S6+rsxVqcdk1RhNOui4l+TJrb8pg8PiXhmm0uERqWxydU2M8v + FbJXn3HZ5zJF2M8vJ9oRLQst8RVCI/L49AaHlisVoU99lSLs51d/xBfTIuL9/BqhkXl8EhQv+qDA + XKsIDdd1REGyo4f4JOF6RQh0g6KUIKXE3KgIgaYS7Una1XJUHp9jIdA0oWPz+OwJgaYTZSU7whWE + m4SOy4u6oOVqLgSaAVrS3FK8b06BmSlkvxGBbiZqRFSaxx3VxRxoliIEukURznpuBZVmCfXna0+K + kHG2kC0EMt5OlBERGuc5itDNvuMjvtC0o6kE4oxzNXHGO4kOiSjel442dymaOfyxzqZCEc7s5oHa + NfUy3k3UnsiuVRxt7hEanRedCN0rdHxe3aLjbaD56A+0azqGaIwNdB9oR9OxeXUVY22g+4nOiAiB + HhA6Ia9u2gk20AJF8XF0tHlQEU5VH1K0kAM9THRCRAi0UBH6A48o4kCJRfowxZM7OAqdt+Iw9ag+ + TPFkdjNqFMYsvXtlbLGbCuYOWBF7zE2hgXo8+hs3UE+4Kb5wGVtCU1NauAbqyWiKG6in3FSccsSe + dlPnhdQILdWN0FLEmdLCtiVohJ4BLci2hEboWaIBEXG5zXNCtqnCjlApZO933c/r9HlFfFUn8YJe + WzxJ3X70iLC2XtRr60X8nZvzIFgZW+amgrndVsReclNpQXxn7OVoTm74/0VTVTmu4V/uprBeV7ip + H/hq2Ct6jfDk4OSqHNtuYo28KuQ1y68RFUXrjctmXleESvwGUX8iu6z9IVXiN4XsslCJVwrZlYRK + /BbRiGiueOs1BeZtITsXVvg7QrafO59X+Co1Fyrxu0K21cexYTXRyGjx2CvfIyqL5sJeWSVkF4+m + dI0i7JXvC8lZDV9B/7fQoLzoCvpaTZzxAyG77ePNGxWYD4mGRKtwJj+K9JGQnQs76jqik5NXZnod + 9/VCtlzJfCayQciuCWTc+BH3v91cyLhJyM6FjJtBhU3sysFGq1aEQDVEk4hsURGoVlG8PTWlHyta + NalrkfkEVJtu6wSa0k8VIdAWIftBtDyfEU2O5kKgz4XsXAj0BSgj3auFX2rijfaVIgT6WhMH+gar + 0BECbVWEWvitkK052ELfEZ0WzYVA24TsKkSg74W8c8XtH9nzFZsRgX4Qsh9EoB8VoRbuUIRAPxGd + X08c6GdF8bYNCswvihBop5AtPS7m/kp0abK6I/8b0fvRXLgE87sQ5orzFF+RLUtvnGvT7VIfQbrd + ipDuD0W4S/Un0fM+ZZs9mjjdX4riHWhz7RWy63P4ksWdzd9qLrTS+9RcSPcP0YKIkG6/IgSqI3pW + b65gnU8IFCpC/8soQqAY0ZM6UFzIzoVASUQriGxlw+ZKFrI9UbSCCZB7GAOBUojeIbIfRKAGQl6g + VEWmgK8mKcLJcRpoappXJRsRLSeyc6FKpitCxsZEa+qJM2YoQsYmipAxk2gDkV05uGHSVMjLmKUI + GZsRbYoIGZuDljbyArVQhEDZRF9FhFqYcyBlJ1quUwdznlzaiDroi0bag3nuOnUwz8Xf6cB7w+Hz + 3o7lualg7hErYq3cFLowrd1U/GjqwrRxU1nn7e4Sy48+FwQ9Yge5KZz9ta3/G3UCDvbmLI21c1Po + BBxCUxnprnPV3k3h5tmhbgqdq4Joikt2mJtCyTrQVG26K9nhbgol6+imULIj3NQPMep0HKlWnOHJ + 1IRr29HpOArkDh3odBQS/UlHE3uw4nVoOgl5zwV1JtrvU6npIuQ1PF1BrpuDTd5NETZ5EVE8UZXj + NTzdiRrWE9fhHkKuWaUTv56g4uZeb+VoosyI7uI63EvIHcmD/qY3UeeU4ubRQaHE9BGK1kSp6Stk + l4VA/YhGRnMhUH8h6VhxoAFC3jXFgUL26ioCDQKVZknXpMNxBaaYqA+Rd+AbLGRjI9AQIXuehEBD + hexJEQKVgFZmRlRqhhF1iQiBhgvZU6c435k7Rs2FjCOE6GzK3u7KMCNBe5rYDyLjKKIj6okzHkvU + KiLcASsVsstCxuMUIeNo0KQMWwhkPF4RMo4R8s5kxypCxhOI1iYmZXhnsieC1mZIuThQmZB3tn4S + 0UdE9mIAAo0TktNpvgN2spD94Alr6Ex2PB95aLfyAp2iCIFO5QMIkT2LQ6DThOjss3KsDTRBEQKd + DsI5KhECnUG0LCJsoTMPpGwzURMHOovo+Yj4XM6cDVrS3FLVuRToHEXzqkwPM0kRDg3n8qE0IpwE + nCdEZ7KV9kzWnA+qyrGEQJOJFkeEDvIFQtGayDAXKkKgizRxoCmg/DwJNJq20MVCdkWjyl1CdE5E + 8znQpYoQ6DIhu9GwhS4HVbaKqNRcQTSMyH4Qga4UsnMh0FWKsIWuJurvU7a5BtS/jRAHulZRfBQF + uk5R8jbq8V9PdEhECzjQDUK2kiPQjdykJb7Ps4QtNFURAk1ThEDTFSHQTby7E0U7TIYpB1XlePvQ + DE0caKaQaxSoyt1MdGhEq+PvdjKzhOwHF3GgW0BTWrhGgQLdStQpIjxZcJuQ3d1xgWg2t4XRXMh4 + uyJ0UOaAVMN3h5AtF85q5ipCxjvxjRFxxruE3EajjBWgedIClNxKu9U8RQ9xxrsVIeM9QrZ+4cby + vURH2rkWSS2cL2Qvb3GgxH3q+B/wpPs7Ok73r1Mdp/vxd+44Pb3xrdgDbsrM7bMitsBNoSPzIE1N + ynAdmYfcFDoyD0dT3JFZ6KZ4FcQecVMfnksdmUU0tbAxlml6xB51U+jILHZTuM7yWP2c1MV63E2h + i/XEOr+LtWSd38V60k114O7QU7o79BRWWEa6Pf6iO/S0UHQ6v9wsJWqTuEyI14x5Rsjrrzyr5kIN + eE7I9VfWFJhK9UG0Q88rQp/7BfVBHCleJMqOCH3uZUJef+UlRdhtXwa5E2JU6X8J2aKiSi9XhEAr + UIgMP9ArQhKofasC86qQF+g1Idu/w5nf64pQpd9QhHboTaJERAi0UsgL9JYitENvqw/irOgdor+S + HSHQKk0c6F2ilIQ71cBZ0WpFyYfs6mLeU4SnWaqImkSEQGuE7Jkfrjy8Dyps4p3m/VsRMq4V8jJ+ + IGSXhY32ITJGxBk/Aq3NsISM6/DBiDjjeiG5XdKZMm4Qsqey5SW7upuNROkRPcQZN4EWNrb3IJBx + M9FBESFjtSIEqlGEQLVCttOEQB8THRwROmCfCHm3Ej4V8g4eWxShR/mZkG1+Mxo+3tl8Durd2B0N + qRZ+QdSUyDu8fylk58Ju9ZWQ16P8Wsg7Gn4Dct+IQFvX8VlGVFQO9C1RXjQXAn2niQNtU4RA34O2 + plmaOXx3F7OdKIvIFhW71Q+KEOhHRQi0QxEC/QQqaeQF+lkRdqtfhLwttFPI66/8ShSLPohAv4Ey + 0uXQxx2w34W8DtguRbhDt5voF9pFvR7lH0J2Ltyh+5NoX7JbPALtUYRAfwl5gfYq4huw5m/1QQTa + B6pN9wL9owhbaL8iBKpDUWvTXX+FAgXrLXkdsJBod7I7icE+ZIS8KhdThM5JnOjviFDlkoS8Kpe8 + nk+l5zXxOmAJIbs/IlCKkHcS00B9MP2p5oUmlSggotIvGs3D61SahkI0V8VxuAqbSFuv+hg86f6O + Pkaj9aqP0Wi99CN6HH73O7F0N4X7Uo3dFHoAGW7qPL5/0kR9jWkiBbGHJxy7MxXh2N2UaEfyPLlI + wd+YyNLFzcKX2L+juM10cXlyfKa7MdTcTQVze66ItYj+xl2U7Ohv3EXJcVPoorSkqZWZrouS66b4 + qn8sz02h89QqmsL1KTfFvYdYG5mK83/wNd9JfM2X614s383YwdC6Okivq4OwFlZmeo8AtFWEdXUw + 0afRPQrca2oHWpbl3fk5hOhrovpbbaa9kO1Goc05VMi7OFSgPohd9DCiz5N3NJVnl7hGdxCKLpxk + mMOFvL5JR01co48Q8i4OHbmeLzc6wi56lCI0ooVC3k2ETkSfRXPhAerOQt5xuwtoWZY9ZNqrXUTf + Etk9DW1ONyF3W4yvdimyV7uEvMccehBtTs5uZueKDz+9wPQU8tqco7EdHaHN6SXkHeZ6C9l2Ffet + +qznPkBp1olEJ8rVLqEyojK52iU0jmicDdRfzYWjwgChk4hOkqtdoFlN7Qft1S6ipIjiF1KbUyx0 + MtHJ4bqGRUVmMJGJCIGGKEKgoaDsZpbQiJYosle7FOGEaLje+3nS/R17/zF67z9mvdwMx94/Yn10 + E33witjI9fW3zStjo9b7N9GPdVM4CSldX39LPTt2HE0ty3J7+Gg3Fb+QTo+Od1PYqce4KVznHeum + 0DieQFOlPMXhYye6KbQ9ZW4Kbc9J3t8axsa5KZTsZJq6LirZ+GiKS3aKm0LJTnVTKNlpbgolm0BT + PbK5oY5T43O6bnx48o/kHtl2j0bjc4aQd835TLQOPeQ+PxqfiUJux6SW5iyin6P7/GhpzhbyWppz + 1Fyox5PwjY7Q0pyrCJ2B84j+iZaFeny+kNfSTBaS+1+tqaW5QMi7lXIhDs0Lsr2m8yJQkOMFmiLk + 3Uq5WM2FQJcoQmfgUqJfibzTusuIWiS80meYyw+kbHOFJg50paJ427DAXKVoyJPzOpmrsTMh9qJh + NtA1ihDoWkV4wPo6Icq4SJrO62XlUNu2SJ4CuEEyWkKgG9XKwWndVEUINE3I20LThSQQn9bdBJqY + 422h8vV8n2lijnfiPUPIndZRoJlEO6O5EOhmIe9YMAvk6mrurxToFiFvC926nnuDPaSamHZ8qUpI + isoZZwt5FxduJ9qWvKmFdzNkjiLcNL9D0cAOu7ubuUS/RzSPM96pCBnvArly4SJnBVHjhEelZp4i + bLS7FSHjPev5fpIjHO/uBbljJwLNF/LOU+9bz9cqdzS1h0BstPuFvI32gJAXaAG3ron6xxoo0IOK + EOghIW+3elgRAi3EYavWf6zhEZD3DEOGWUTUMboOgkCPCnm1cLEQtQCL5EWMxxQtKFnVyTwOcq+L + 38Un3k8oQqAlivDO+pNCxXnRi4FPETWPCO3E06AxQgi0VMiOuZHNgZ5RZK9nCXmDdTynKJ5OgSpB + O1PpgzmDwvElWYXm+fXcC3d0K79v+4Iiez1LyA6KgS207EAqNS8R7UmeLWSvZymy17Mc5TLhzZLl + ai57PQu7lZvLXs8C5aUNzuVBRPDE+KuK5i3ZVWheU4RAr2NPy0sbksvjBdjrWYrs9SxQSSP6xskS + aKUQzTVZHg16az3fvy9pNDS3bpo8GvS2EM21SDrB79TP5TrBq0C16SW5UUv+rhAVlW8o8sgJq4mO + JbIfxD70npD9IF7xrhIalht1gtcQnZncu7H9IA5N7ysyPArDvxXZ61lCVHr3+NMHiuz1LKIJRFJU + XM8SovXl3vpepwnXsxShFm4QGpTLT32t3vp7F7NR0RzOuIloTET2epYi1MLqA6nU1BCdSDQwl0eI + stezQEsbWbLXsxThea5PFNnrWUJ28fZ6liIE+gybo0Ro9aG7upjPFc3mQF8ostezhOgbZQw085Wa + C0+Sfr1edYJ5cnlD+3d0gr9ZrzrB3+Dvdbnhhvy5K2Nb3dQefuHhWzeFruZ3bgpn7NvU1xie7JE8 + pqGtY+gIfq8IHcHt3NxGxN9ofhCydcw+mqUIe8gOUO/GsjvwYyM/6Zw86Woqcv6sc/6Mv1Pp0dn/ + xU3hGdCdbgpd41/dFE7Lf3NTSP27Ts2TbahYw3OjRy52KULq3URJUeHR/f0D5M5xseP+KWSPO+iC + 7RFyr0sF/RN/6dQ86T6C1Ht16r34uzvF+dtNBXM7rYjti/7GFzj+if7GJxn73RRS1+nUPJkcnS4j + dbCByevXLjehIqQ2G/hJftd1w74W28DDA7gOHjZ/XBH67kkgdZUgmahB/Wk872sJIa/vniLkdTIa + bOD3IxyhZ5gKWtjYfrBHR74UJmT7MDiqpQm5i+HJO02jDfwkfz1RM5ouZC9zo4lpTNSNtr/3XEaG + kL0yidhNhOyZPd7GyyQaHRFiNxXy7ohngfLS7N31+DjqWzUjuiCi4qcf62yaK0LfqgXRrIiQMVso + ui1fYnKI2jfYmuY9s9BSyN0Rp65IriIEyiMaHhE6i62EvAuyrUEljbx7AG2IzmsQXZouojYzX2hk + Lt/nGD2JjtwHCdGOVjHc9q3aCtGONllurR0sRA1DyVDbt2pHdE5ECHSIEB3CespRrX39XD2lYh6q + CBWzgOjsBkuFEOgwIVpWR3lfsoMidBYPV1ReQoE6CtFBs4QHZ9nXyxyhCIGOrP9gmTzbdBTRWT6V + mkJFCNRJEboinYnKGmRw96FCGtouQrQK3ahUXevnWiS9325EJ0SErkiRouICCtQdhLU6bQhVOQrU + QxGOaj0V4ah2tCIE6kU0KqLcbkmB6Q2ibnMuv8yHQH0U4T5aX0UI1I9oaD1xoP6K0FkcQFTSIC/N + dkVKvl/c2QwUsj2d+/kwPUgRAhUrwvW4wYoQaIgi7ENDiQZGhCpXookDDVOEQMOJBtUvPpuf8gIt + bwiK8xRfUj6FLykj8AiSYvd3WyVHKtqypGuhGSVEG7XjUDv0zLFEQ4joEN5ROpOloK1ptCdimDdq + BY8TOoboGBt4tCIEPl4RAo9RhBfHxoJ6N7aEwCdo4kAnEh0dUbwzBSoTGkEnBSPCMdvjheYkRfN4 + C44DTcqwhEAnE3WJCL3j8YoQ6BQh+saecp3jVEUIdBpoTxNLaAUnEB0eEQKdrokDnSFE31gxwgY6 + U4hawUUjw5mHvdvJTASVZtm57uJAZxHlEdm5EOhsRdhC5xC1ITqWarwcpyYJlVLzKbelzgUVN7eE + QOcpwgnZ+UK0rBK5tTuZqC3RKAokt6UuIMokokL0HGmb9QtB2c0sLVgzr9BcJESBOo6wjcYURQh0 + cf0H80dSU0yBLlGEQJeCxmdSIXJG2UCXKUKgyxVhWJcrFCHQlZo40FWgebw50iTQ1USxiBasoSp3 + jSL0664VokBpEug6oj9THO3gKnc9aC1XpoTsQzcI0Z6WJldpblSEQFMVYR+aRvSjXZYbDnI6CDuM + Gw7yJkXxIylQOdE3EQ1fU1xoZihCB2qmIgS6mejTlEnyjThOzTqQSs0tRF+mYLeaLLdZblUUFPJ1 + NEVo6WeDdjS1hMuHtytCxjmaOOMdQrYngY02V9Mtu7qbO0Goq+4F07uIPowIGSsUYTCGeYqQ8W5F + yHgPKMixhED3ClFR+QoZB5pP9HZECHSfJg50P9Er9R/kduIB0K6WlrK2Ly40CxQh0INCVIgSCfSQ + oiDYN8w8LGR3ZARaqAi71SNC1AJ0lGdwFynK40CPKkKgxZo40GOg13ItYdCWx4mejmjL9qxC8wTR + qUR2f8QjIEsUIdCTitCSP6UIgZ4mGhwRAi1VhEDPbOAHuh215kDPKkKg50D5eV47UcmH+ohQ5Z4X + knaCD00vKMLdyxeJjokIgZaByoX2cqCXFCHQy4pQ5f61gZ8Xd4Qqt1xI2mgOtIJoQMqIVhFlm1c0 + caBXFfE7DOY1omMjKt4+sdC8LkQbreex9qmjN+rnKpEt9KaiOD8CspJoLBEVtUwCvSVE1bdM2om3 + kdERAr2jCL2lVYoQ6F1NHGi1IuxD7ynKbLC70FQRdaCtTeWaNjJcyIemNURZtgKUSaD3hezBMOjN + 19EU4ZHVtUJ0FC2Rp0I+AE3MsYRa+CHRr4mJOXYVohZ+pAgbbZ0QFaKjbLT1QlTUjvJo+waifxJT + WlhCxo1C9sA6/knarTYJ2W7U/TzI+WaieIojZKwWoiNMznB7h7aG6K/EsixLCFSrCBvtY0UI9Imi + lhzoU6KfI0KgLaDxmUIc6DNFGLz4c0WlvFt9QfRdRPdwB+lLRQj0FWhhY0toJ75WhEDfbOBXARY2 + pr5vvtxT2KoIgb5VhB7fdyBcgc2Xuz7bhOypHQJ9T3SUnatMBi/ersikdisyPxD1iwhd2B9BGUII + tEMRAv20gZ9Qd4RAPytClftFyJ5DY7faSTQ6sTXNErbQr0J0YlAm572/aeJAv/O+HRFOE3cpSuGB + fXcTXRDRPXyS8YciBPpTyJ4AJnM7sYfoPCJ70oZAfynCFtoLmsrncdPknsLfitCF3YfFT00blIth + mzjQP5o40H6hgbk8iCtGcqojOiuxvKGl4ieo8xBs9OkuHq0qJLokIgQyQvbSLBqFmBCVq0LuKcQV + YQslKUKgZKJTI8K1o4QiBErRxIEaEJ2b2JlK66tCzntTFdnBsBRVnzOms0kjupTv52BZc3nooEZC + dt0jYzrRDRGhFjZWhIwZipCxiSJkzNTEGZsK2dsyyJiliTM2c4Txn3Gq21zRrTev6mRaKJrNgbJB + Y2TgaATKUYRALbE5xvjDS+cSTUlg/GcXKE+oOC/aaK1AuCXmNlprRQjURmhQXt0iqYX5inBP4SCi + SREVv3dZV9MWhNt+i/hWHQU6GNvREQK1U4Qzw0MOIArUXsgbT+xQIe/xrgKicRHhnZ7DhOS9OA7U + Qci7mXo40fjogxitqqOmRNcic4SiWRzoSKKzI0Kgo4TsN2ILFRJdExECdQJhRXOgRyhQZyE7ugAa + vi5EM6O5cKztKuTdHe4m5I0nVkR0RUKNJ9ZdyHuWvoeQXRb2oZ5Ec4i8oReOFnIPzdFJRi/QzlRv + WILeilDl+gh5W6gvUbmt5BhsjQL1I7qnvvQcqD/IrVUEGiBk1wRGKh6oCIEGCdlhHObw728UCw3I + cz/kYwZjfS1v2J+ov91CQ4TsXAg0VKgfkfz+RolQb6LeNtAwRWjJh4PGNCyi6lsUBuuCSnOMUNe8 + urKuNuMIotuJuuTV9exiM44kuomoc15dx85h/P2gwIxSNL79mYXmWNC+FEtXVH3Sy5QqQsbjFCHj + aKKrI0LG44U65dXldLIZx4DWJSwh41iiG4kKiQptw3eC0FFER9lAJ2riQGWo0Y7ib1Cgk0Bbkixl + JFUUmnGKzq5a28ucrAiBxhNdS3QkrcIjbaBTHOUyIdCpRLcmsoTQTpymCIEmKMJudbrQUXQwlEBn + 1M9VeaQNdCboNdM5t24RbaFXKNBEoUKaq9DWwrOE7LImcqCzheyyEOgcoiujudDwTQJVBY4o0LmK + EOg8RQh0PtFVESHQ5AMp21yALTTREQe6UMiWPv52vMBcpOjtiXcVmSmKzuBAF2PxE4NORJ1soEtA + dXWWEOhSomlE9oMIdJmQnQuBLhfyAl2hiQNdKYRVGOcpvqA8AReUOd1V/t9tuqvVUuKvULprhI4g + OiKcXty5yFyrPoh014EmBt7muh7HvIn126bE3HAglZobFWGHmipkl4V00xTh2tH0jdyxc4RANwnZ + oiJQOQ71bi4EmqFodbvfu5iZiiZwoJsVIdAsRQh0y0bulrrtjEC3Ctm5zHJqzG5ThIyzFSHj7Ypw + UXOOImS8QxNnnKsIGe8kOjki7GN3KZpQ9WEvUyFk1z0yziM6Wme8W8jLeI8iVMl7FSHQ/I38RNTE + gPb9ys72ouZ9ihDofqLe0X6BQA8oir9PgRYI2Q8i0IOKEOghou4RIdDDoI6hJQRaKNSFqIsN9IhQ + N6JuNtAioSKiIhvoUaHuRN1tLVwMmhv2oE51DxvoMU0c6HFF8a+pFXxC0erHKzqZJYrOqFrXyzxJ + 1D5RZiwh0FNCVIiy7jbQ0wdSqVmqCFXuGUUI9CwoP2YJgZ4Tom8skUCVmjjQ80I9c+t69gzj31Gg + FxRlbutSaF4ElceOJjqajlPVvcwyoV60rF420EuKDAd6magZUW8i+eGrfwn1yY1+rWw5aES8Ly2+ + rw20QhGq3CuKEOhVIVpWR/m1stcU4dfKXgdlJVmav+3gQvPGRn7Dz9GUqi97mTcVIdBKRdhCbx1I + pebtjTyEx5YkypjfO8z9iqrcO4oQaNVGflg3Ig70riIEWq2JA72nKP4bBariI0BE2IfWCNG6L+sV + XlL1dS/zvhBttMlHh8Euar/+LUSlL5OMazfy87tYVkdaPN8C/kCIlpXfy2b8UFHuGsr4kSL02ddt + 5Ke1HeFYvB7UP5kW31MybhCiuXr2shk3Ctn6hVq4ieh7IlsL5yZ3LTSbFV3DGatBi5OpRveU3apm + I79u5SiZA9UKUQvQs8gG+liIdpiS7rad+IQozc5VUmQDfQrKSrKE08QtihDoMyFqc3p2s4E+VxT/ + hAJ9sZHfa8MHy4rC8iHvdDJfgq7iuUq6hTdUfd7LfCVkF49AX2/kYV3cXLjg940QzTVZAm0VokDT + JNC3oMo4fbCim62F3xGFicq4bQsRaNtGfoPUEQJ9r4kDbReixVd0tw3fD6ARcVrRi3rYWvijkG1X + r6na0svsqJ+rUrbQT0SNornQn/1ZyC4LgX4Roq1d0dMG2qkIgX5VhIbvN7UsBPq9fq7KnjbQLkWo + crsVVa2mLfSHEFXMRUeHV3GgPxUh0B7s7o4Q6C/Q99yITu5pA+1VhEB/K0KgfUK0rLKjbaB/1FwI + tF/NhUB1iuI/UKBgk0/YQqGiKziQ2RQtnlYhAsXq53KB4kRbI0KgJEUIlKwIgRKK8FR0yiZ+M8yt + LwRqoIkDpQrZzRF8zz+tWD9XpWRMU1T+3qOdTSOi1yO6jDOmK0LGxkLUFlb2sRkzNvG4YG4uZGyi + CBkziT6MCBmbKsJl5yxFyNhME2dsrgiBWoAqhbDRsoWoxazkxp0C5ShCoJbqgwiUq+ZCoDxQVhId + RSv72sNvKyG7JhCotRA123Ruj1rYRsgLlC/k7VYHEb0WUfxr6vG1JXqVyLYAye27FJmDFU3hQO2E + bKOAQIdgCznC4bc96Kp6KjWHKsIWKlCEQIcpwqGpw4GUbQ4HbXHEgToqin9OW+gITTdf2tUcSVQZ + EQIdpQiBChUhUCchuyYQqLMibKEuihCoq5Bd0dhC3YS83apIEwfqrij+MwXqQXSHPW4v6kX70PGd + TU8hOxcCHV0/l6tyvRQhUO8DqdT0UYQt1FfI1i8E6qcI+1B/RQg0gOjCeuJAA4Xs4uO/UZUbpAj7 + UDHoKvnghRxosCIEGqIIgYYSlRLZHQaBSoS8QMNAbk9DoOGKzA6+GEY0kEi2I2ccIWTnQsaRmjjj + KEXxnynjsUJ2f1z9OJ39lhINjwgZj1OEjKMVIePxQtLUcsYxipBxrCJkPEETBzpRyNutyjRxoJMU + xb+jQOOI2kXLwkY7WcgLNF4RAp1C1Nlv5UrMqULRdiw1pwn1y7UXNSnQhE084m9lvH8uXw1FoNOF + 7FzYrc4QGpDLF0gR6Ez1QQSaKJvDfvAhfkL5LEXx/ZTxbKLjI5r+3u/dzTmgLVK/LuRO4CSieyKy + 438JeRnPI1qfvEWabWQ8X5Ed/0sRMl6gCG3hhURVPmWbizRh/C8hu1ZRCy8GLU625Vo1pLyLuUQR + Al2qyI7/RbQ2IgS6/EAqNVcosuN/KUKgq4RsuXCyeLWQXYV2/C8hWvcV/WT8L9C6xEDqWck9xesU + jS9Y3Nlcr+hCPlm8QZEd/0sRzn6ngrqmDKJzK7mbMw3HR0d2/C9FCHQT0QsRoc9UrsiO/6UJ438p + wu2pm4meiuiEkomFZpaiG/hewS2K7PhfRC8m73Olx08rauKMsw+kUnM70RsRIeMcRTi3ugO1cH5K + cS6/QIc9ba4iO/6XJoz/pQj3TSvQEZmfYm/oz+aM80CzUy3hjtXdm/ileEd2/C8h+/A5HoC+VxEC + zd/Ep6eOEOg+0M5U+/A5At2vCG3hA4oQaIGQ94j6g4pwk/Qh0JiGlhbw7zA9vIlfvh7Dj0nnD7Y3 + SRcqQqBHFOFK9KIDiAI9KkSLzxwS5ym+oDw+Pb2l7W8s3sSv68rfbZV8TIiiZMoP8D1O9FNESPeE + Jk63RIiWlSbpnlS0oCReaJ4SokKmDbZ3TJ8Wou2cJj8mulTRVu7iPkNUm4xb+Qmpf88K0Z6YkNfK + nhOiNjwhP7RZqQj72POb+FzCEQK9IGSXhUAv1s+VMyCMJ1OgZYoyCyjQS0T/jmgm/7T6y4oQ6F+b + eByQkkaWsLmWH0AUaIUiBHpFEQK9SlQdEc7tXwNtTbOEQK8T/VhPHOgNIVqFZYNsoDfr55pMGXkg + 95Woko7KOdBbihDobUV45+MdITpYVvS3gVYR7YoIgd4Vsq0zdqjVoJJGlvDOx3uKEKhKEwdaQ/Qd + ES1+kfzC8PuKgoCfDFP0/pAxnc1aRbM44weKkPHD+nVfKT86/JEiZFwHwpqolI22nuiLiJBxg5B9 + rxCt4MZNPEIRNocbfX+TJs64GYS3bvEbvUkFpnoTj/vkaPqaeUWmRsi+DDqHA9UqQqCPFeGtiU+I + 6pJ3CiHQp0Le66dbNvFdAEcI9JmQ9wLh5wdStvlik33H2nvF9ktFeO/+KyH7ymJVVdci87WiuzjQ + N4oQaKsiXDL7Vi0egb7bxGOBOULDt00RdqvvhbwXdbYfSNnmB00c6EdFeAJrB1G7iLYsoSr3k6K5 + HOhnRQj0i5B9tAYPLO1UhEC/KsIW+o0oJyIE+l3IHpRQ5XYpQqDd9aXvKYH+UIRAfyrasiSr0OzZ + xBf8xvAqzC+h4xQF+ksRAu0lOiwiBPpbEQLtU4RA/2zicSQdIdB+RXgQoU4RAgWbFXGgUBHG5zCb + eeCFnamWSg7bXWhiihAoTlQQEQIlCVGVmzbMPo+erAiBEpt5dFlHqHIpQsOpxRxu96EGitCfTVUU + YGB7osKIkDENtLTRMbR4ea+gEdHAiPBeQbqi8ipqJxorwm6VoQgZmxD1SuBVA14W/wZSppB9ExAZ + mwq5jLTRsoRofU2TjdZMiGrOZNmtmoPmNbHv8CNQCyFqhibL4zDZm3lHdoQfJ88RooavrDjMm9S1 + 0LQUohazhF9T39HL5BIVJSZlUFPbU/rseYr2ci1sJURtdE9pyVtv5kFiHWGjtRGio0JPOXPMB8Uz + 6DjUs5/tIB2kCIHaauJABwvRqUrHvvaHu9tt5t3K0Ra+Y3UIqHdjS+VVW3uZ9ooQ6FCi/IhwDbBA + EQIdJkSndjlymtgBdFm6JQQ6fDPfNouIA3VUhEBHaOJAR27msYQvS/cCHQXKEJq57dFCU6hoKt/N + 6bSZh5Z0hECdFWGUwi6oExnptArL5JfIu4KmpllCoG6KsFsVKcIVpu5E3SJCoB6aOFBP0KoGVIjJ + EuhoRevav9vJ9FJUzqeJvbE/rmpAK6dC7rf1IRpLROeqk3vbQ1Nf0L4USwjUTxEC9Rei894KOe8d + oAgt+UBFCDQIND/Fu0pbLGSvQ+FEfrCQPYeeM/OxzmYI2pz5KfZMeyqfyA8V8q6+lGzmp533yeIR + aJgiBBouJNc5v+SLYYqQcQRW4b6U7tTZkgu3I0FdU4ooUJHtBI5ShIzHauKMpUSHR4RbcMcpwhWm + 0Zv5aYfJia5UiK7hdZzxeCF79wsZx6i5sFuNFbIPGiDjCURdog8i0Img/snelegyIRsb7cRJihBo + HFGHBO6IunsFJwvZSxrYaONB7oIMAp0iZC/bXMe18FQh73LSadjd3VwINEHIu855+mZ+Aj4ryevC + nqEIgc4UivqrGWYi9u2sJG/AkbOEbIcSgc4Wkg4SH37PEaIDRVlJ2HoN9ScmCdHhpGQY1cLveplz + N/MgWo4Q6DxFGMj7fNAWXlaJ9CcmK0JLfoEiBLpQyL6kjobvIqKMiBBoymYeZzklIcSBLlaEQJeg + BUhJ2MVnPbmr0FyqaHrVD73MZUL2YIhAl4P2pdgH/7GFrlCEQFcKUWz3k9dXKUKgqxWhnbgGNDvV + EgJdq4kDXSckfXIOdL2ijFnU8N2wmbt3jmby5aQbQRkyOA4CTVWEU91pm3mQo3qiQNMVocrdJOS9 + ml2+2Q4dZedCSz5DEQLN1MSBblYUb00nGbMUvb3t9y7mls384yeObuW3Im5VhBF6blOEAQJmC0Un + GSXm9gOp1MwRsmcnyHiHkO1ZIeNcRWgn7hTyXqi6SxNnrADlpXkvVM1TNG7Nqk7mbkUY9uYeIfsi + NALdqwiB5m/mXzda2og+2FPexr5PEWrh/UL0wY4S6IH6ufJHhM050AJFCPQgaGFjIQ70kCIEeljR + Am4nFgqNzK3LHGkH2XhEEQItIro7eXymJQR69EAqNYsVYQs9pgiBHhcalVuXNspecHkCNKupJQRa + ookDPakI7/A9tZl/udoRWvKnFd1fldzDLAUtaW7fxcRu9YyiVL4Y8SzRWREh0HOKci+mQJWK0EF6 + nuji5AXZpVQnSm078YIiBHqR6Np64kDLFMWHUKCXhI6jQ/lxNtDLoLktaa7K0nARB/qXEM3lfnZi + OdEVEaHhWyFEa8INhf6KotxzKdCrIHyj+42J14TsN2ILvU50UUQI9IYmDvSmEK0c/lVV3kIrZVn2 + G80ttA+9pWhhVbyHeZtoOpH3pvI7ihBolSIEepdoXjJeEXRvKq9WhEDvES1LxluDlSNsb6hKyM6F + QGvUXAj0PghjFfAH+c3ufwvZ0ZIwfv1aoseiuVal3F1kPlD0EGf8UBEyfkT0r2SMjlA5Ms5TfEH5 + 5PT0XNvSr/P/bgOvF7KrGI3Ghs38y3l7mnhbcKPQ8XRQOt629JtAvRtbQuDNRO/yYD10ZBxjA1cL + jSWSH9+pUZTyAx26ajfzRTpHD3GV/BgUz7CEdJ8I0eIXjbFb8FNFCLSFaB2RLRe24GeKEOjzzfw4 + zKSM0bnymzAZ5gshmsuNzPOlmguBvlJz4bdqvlZUPnx3d/MNaK3QAg60VYiK6oYt/lYoKkSJ+e5A + KjXb1LIQ6Hs1FwJtV4Tu3w8HUrb5URMH2rGZL047QqCfhOw3otH4eTNfpl+bYXdOBPpFyM6FQDsV + IdCvB1Kp+U0RAv0uZFcOAu3azHftHOFy0m5FCPSHJg70J6iwiSUE2iNkv3H6ml3dzV+K7q9K6WH2 + En1AZNcEAv0t5AXaB9rTxAv0j5D9IALtV3MhUJ0iNBpBtf9BBAqruTlYmeltIVPNd+0cYXT+mKKq + J7sVmbgiBEpShEDJ1bzz7WjqVbmEo7yoyqUoyh1LgRpU829BOkKgVCHvl4kagtLkN4fQ0qdV8+0W + R8jYSBNnTFcUH0gZGxNtJ7JVbuCTXYtMBmhijh0WCxmbVPMpgSNkzBSKxh8rMU0PpFKTJSS/4tGJ + MjYjapBwv4OOjM2FbIuJhq+Fo7yopc9WcyFQjqJ4EQVqCXot17b0VTdToFwh24bP50B51Ty0pyME + aqUIgVpX8xOkr+VSx65SBhJpA8rPs3MhUL4iBDpIEdqJtkJ2WQh0cDXf1sjPs0VFoHZCdq74kRTo + EEUDn6Tdqn0138NwhECHKkKgAkUIdFg1j5iLAQLcFuogZOfK7UaBDq/msxdHCNRREarcEYoQ6EjQ + rpZeoKOIcom8QIWKRn1PW6iTIgTqLGSXhUBdqvm3ZBwhUFchex6HQN0UYQsVKUKg7gd+MMP0qOZ7 + dx1b0tlLT7mO3lMTBzpayLsx0EvR+3xJtreiedyT6FPNTygvyLaEQH2r+VaEIwTqdyCVmv5CMsZa + J+o8DFCEQANBU1oIcaBBQnJBmQMVa+JAg4XsS+p4jGJINd/9mtJiENGgMP1mOpEfCipuPpBoYDiX + zzhKqvkXjYqb9yeSu4XDFOGO6HAhe8sy2McXwzRxxhHV/LB+aVZfor52o41UhIyjFKHPfqwiZCwV + 8h6bOw770J4mcjlpb7zAjFb09tmPdjbHV/Nz8o7m8EAiYxQh41hF2GgngCZleJeTTlSEQGWKEOgk + RWgnxh1I2eZk0FpHHGi8IgQ6RcherVp1dkWROVXNhUCnKUKgCaC8NC/Q6ULe41ZnEP2WnJcmj5Rx + LTxTEQJNVIQtdBZoVQNLCHR2NQ/Kv6qB90jZOUL23nA8ldqJSdV8N9rRqlm7uphzhdyAvBToPNCE + Bt74tedX85MTExrYK3IINPlAKjUXKMJo6xcK2et2CHRRNf/ohSNsoSkHUra5WMi7+nKJWhbeNb9U + fSN6fJeBVKDLhbx71lcoQqArq7m37VGpuUoROkhXK0KgaxRhC12rCIGuq+YniiLiQNcj4yopPQLd + AMKDLDQXAt0oZOeazYGmqrkQaJpQdDGsxEwX8oYuvKma+6tuWRwoUV6thqXlyTH+oMMzqtWwtDPw + dx6Mt+1xK2Mzo6mKnBWxm91UwL9oMataBh3GL1rcUu0PQXyr+lLDkyuTl0vhMSztbULRha/lZraa + i7/f3K5oYj515eYIeYMs3qGWxas+MVennovS2Y8g9Z069Z2u9BiM9y43FcxttSJWoZLN08l48oXk + 5f7gyncLRZ2I5eYeooeiAmLA3XsV4UcK5wvZZaFu3KdoDh9D7ie6Mbn+eYagv3lAEerGgmp+Nnpq + mndd8UFFqOwPET1I5I3w/LCQjD7JlX2hIqzxR0BbHXFlX0R0H5FU9paNCsyjQnYuw6O3LVY0mwM9 + RvRERBhK+XG99XjSFRJb7wm99Z7A393WW+KmgrlUZ590U9h6T+mt9xS+2q0S+0OUIAwR5IZLXqoI + W+8ZogeSFzb2+lXPVvNlD49KzXNC3hqvBNX6V6ufr+ZHJN1I8XzhM/GCzs+T7u/I/6LO/yL+7vIv + c1PI/1K1P0j2yzr/y/jq3o292vsvIW+Q7OVEj9ePSM/5Vwh5VeIVoueSx2d6DfqrilDHXxOyq2QP + Pwf9ejWfDY7P9Kr9G0K2EFxLEm/qVcKThU3s37FKVupVshJ/d6vkLTeFVfK2m+K6FnvHTWEFrdIr + iCef55/rqq8g7wpFDfFys7rans/Wr6DEe7q4POn+juJW6eJW4e+uuGuq8WOtUtz3oyn+vaN/uykU + d60u7loUZFKGV9wPFKG4H6KBym5mNx6250dC3tFl3YFUatYLeXcmNlTzZTo3l70mB1qWZefCBZJN + iuw1OSHvEa9qopciwk+J1RC9FRHqRi2oXVP7jWhBPlaEJvETHKDbNfWO/58eSKVmiyJ7TQ60MtM2 + Y/aaHNGbRHYuPAr6hZD30P+XRB8T1Xc5E1/pSvAVNrLtIKISfK0rwdeuEozJm/NW7JuoSvChd6ub + 4hdYYt+6qbSbH+0c+85NBcH+XrFtbgoV5HtdQXjy31FNRQXZLuRVkB+IaiLi0iR+1FF+xJfYvyPK + Dh2FJ9dmuPr8k5tCff7ZTaGAv+gC/oKvxgCpbgD7nYpQwF95EVEBscP9pgv424EF/F0X8He1w+2K + 1iAXcLebQvvwB03tidqHP3Vx/0RB9jTxGtA9Ql778JciFHevLu5efInXPvyti8uTVTl1uXH+D752 + fiZfO0fZ98mfbNn/iaaoysf2uyn7WwG67HXYm6tyvFUd1FjyDn6hIvtbATV8Mc2bq9TEhLwdKU70 + HpHXMiSBZjW1H8SVxmQhuf7BO1Kihi8+zmrqHUhShLyWoYGQd9RIJdqSXNjEznU2dxYbCnmNRZpQ + fXfDNKrh8y1HaCzShbz+U+MafogkL80W1f5WgJD3PGgTRbgwl0k0nMi799xUyGv9smp4JCRH8bbr + C0wzRcjYXMgL1ELI6xBmK0KgHLUsBGpJdHk0FwLlCtmMHCiRV6NqKk+6paCmtqpRNbUV/u52rNZu + CpWzjZviZxZj+W4KlfMg9TWGJydFOe1PZzrKi3asg0HuHjt2rHa6uDzpfh0KxT1EF/eQGvmdchS3 + vZtCcQ91U7zJYgU0dVm6+92Nw3RxD0NB3K+Qo7gdhLzf3Ti8hsdXc4TidtTF7YgvsX9HcY/QxeXJ + 3o1dcY90UyjuUW4KP5VS6KZQ3E66uJ1QkN6NvR8m7QxSP+LahWhkRChuV11cnlQ/4tpNF7dbjfyS + LIpbVBP95iwVtztNLWnufmK1h5tCcXvq4vIk34v2inu0IhS3l5D3O6q9a/g+rSPsQH2E7DpG17Kv + DtUXRfFC9dOh+rmiIlR/N4VQA9wUDh0DVahBOtQgKa4tCEIV/9dQg2v4jVNHCDUEtKlFNFeJGUp0 + JZE36lyJkB1Pzr6EKuT9yNrwGr7B7paF8+tjFOHyzQgh7zdeRtbwKadbvH0JVVG89eACc6yQt/5L + 1Vw4oz1OfaN9CVV9I96hOF6RfQmVaG5E9iVUIbus1jsbNzQnCNnYuBB/Yg2f5Gxq4f0yXpmQdFHx + EmoN/+zrphZyB/zIJgVmHGhijj23ty+h1vAvQk6UAcMxiPx4Ie/OwilC9vYGAp1K9FdE9iVURfYl + VEUIdLoiBDpDLd6+hKrKZV9CBU1N8wZYP6uG77E4Wl21uLM5W9FCvh51Tg0/8uYIgSYpQqBzFSHQ + eTX8SKUjBDpfEQJNJhpMZB+UQKALFCHQhZo40EWK4kcnFZgpNTy4kiNsoYuF7C2cJRzoEkUIdCla + u8Im0Y2eEnOZkPdgyeVqLgS6gmhoRHhS5kpFeDjrKtDKTPvwAgJdjU7Aykw7FwJdI2TvLcb7UqBr + 1Vy4iHId0aiIHudA14N2NLVFRaAbFOHJ2xsVIdBURQg0rYafvHWEdmI6CL/gwM+acKCbFCFQeQ0/ + 9Ipfg3APlswQkkBFDQrMTCH7QWyhm0FuHP7FHGiWIgS6RREC3UrUKqJk/CKBkJdxdg0/7e+ep0HG + 24W8O5BzFKHndof6IDLOVXMh4501fA/P7e7xzpTxLiEvY4WaC7vVvBr+UU3VTtwtZBePjPfU8AO0 + VTneLdV7hbx2Yr6aC7XwPiHvHvH9Ql53+wF841z/HvECRditHqzh5zrdA1VD1uzqYh5StIgDPawI + gRYSDUhMaSG7KL8U8ogiBFpEdHxECPSoIgRarAjtxGMgV1cR6HFVoxHoCSF5Xot3qyVqrukc6Emi + E6O5UAufAk3K8NqJp4VsjcYWWirkBXpGEQI9qwhV7jnQUvntLASqFPIeQHtezYVAL6BRWNpIAvFu + 9SIaGDcXqtwyRdhCLwl5Ve5lNGl4ytJVuX8JeS358hoeQ9DNhUArhLwH0F5RhCr3qvogAr0mJPfB + OdDrNTxEuaP4kRToDUUI9KaQe9qMAq0U8m56v6Xmwstjbwt5p6zvgEoaeadzqxShyr2rCFtoNdEQ + Iu8u/nuaOFAVKnmJFALPWawRsiunvGB3F/M+tqMj04OfuxPydqu1ipDxA1BGututkkvMhyiEI2T8 + SEgavgGUcR02rSNstPWK0OPbAMIDtG6jbcRGw9OyrhZuUoT+xGZFqxp0KzLVitDw1RBdnMDTsq5x + ryWaGxE22seKEOgTRbil+qkiBNoCcr8agyuQnylCoM+Jrq8nDvSFIgT6UhFq4VdC7pkzCvR1DZ83 + u7kQ6BtFeCpwaw2PFovfvHE9vm8V4ab3d6Di5t6haZuQd0n1e0UItF3Iu6jwA9Fl0Vx4iPNH0IJs + W6MRaIci7FY/CXlV7mc1F961+kXIOzTtJDqNDgFeB+lXIa8l/43ofCKbEbdUfxfyttAuNRcC7UbN + cY8JxftSO/GHIvuDnUK2XNiH9gh57cRfai4cmvbW8Ek7ftbFVbm/FSHQvhoepdZ9IwL9I2Tnwg8x + 7BfyDk11oPI8r8oFtZZcO0GBwloeJ708z+vCGiH7QfT4YkLe81hxRWjJk2p53ZfneVsoWchryROK + UOVS1AexhRqouRAoVc2F/ldDolPq5+KMaYrQQWqkqHxN1yKTDnJrFRutsSJkzKjlA1i+n7GJkLfR + MhUhY1OQ+5klZMyq5VMR9ywcMjZThIzNNXGgForQuGcTtUx0FHr7vN3dTY4iNHwta/mNZUcIlKsI + gfIUIVArkPtZKgRqrQiB2ijC0Sq/ll/AdIRAB2niQG1BbndHw3ewkGRMpaNVO0Vo+A5RH0Sg9orQ + 8B0K2mQ7bnGeigYUQboC/+823WGKkK5DLT8htqmFdHo43eFC3j7WEdQj2zurOkIRun9HKlp162Od + zVGK7ud0hULe5uqkF88vcneu5WdNesgLAgjUpZYflXKEQF2F7AkgGo1uai5sriLQlBZe96+7Jg7U + o5Z/Gt1RfAgF6km0l8guHo3G0ULuhYqgh+kF2tTCe/K2t5ArBPUk+gjZZSFQXxTCEQL1U4RA/aWo + 8oQ+BxpQy9ccHCHQQCEv0CBFeMy2WFExP70+GIR3UmjdI9AQRQg0VBF2qBIhbwsNE/J2qOFEn1Eg + 7yWIYxShFo4Qsk0e3r4fqQgZRwl5z3UeS/RlsjtYxjtQxlIhO9cqbjSOU4Rj8WhFyHi8IvSWxihC + xrFC3gX+ExQh0IlC0Q94Z5iyWh7C0M2FQCdp4kDjavmSmftG/MrTyYrKGlCjMV4RGo1ThGhNVMhJ + yKlESyJCo3GaIgSaoAiBTheiLTRNttAZtTyEoSPsVmeCesgHEWgi0dv1xIHOUoTBEM5WVLqdThPP + EbK/64l2YhIIb9RUyHHqXEUIdJ4iBDq/lh8mwK91TZOTkMlC9hvtiGy1fHetuHlU+gxz4YGUbS4S + 8qrcFEX42aqLa/m+u+sRTi/Z1d1couge/vG0SxXZEdlQete7RKDLhbxHBK6o5dG3HNkR2UBfNvOe + qLtKyN5kx43Aq4W8YW2uERqQW7dIxiK6Vsgbuuc60LIsS+bmiiJzvaK5/EtpNyiyI7IpQqCptTzK + 6LIsWwgEmgZamWkfvMR7SNMV2RHZFOG8t1yRHZFNE0ZkI1qavDbDEgLdrGjWzVTlZgnZB0Ln8NuY + tyiyI7IpwnPDt4Ew+lFlP3tRc/aBVGpur+WHkhzZEdmEvIx3EN0fzYXD71zQ8oZexjs1YUQ2RchY + QTQjouIC6v7NU4SMd4PcQ692RLZafn5sVYNoJKUSc6+QnQuB5tfyU0ZuLjsimyI7IlstD947P8US + fgbzAUV2RLZavuQfEUZkU4QRsR5SNCvxRxfzsJB9GBe/BrdQzWVHZKvll1Ad2RHZhLxa+KiaC4EW + E30SzWUHYVOEV2gfV2QHYavlB1UwQF6ljJm3RBFGi3pSyO61A5/4vbt5Ss11F+9WT9fawfa839he + WhuNv+d+5ekZRQj0LGiflMsOwqbIDsKGBsYRqtzzQnat2kHYhLxAL9byUzzuueF4Jp1xLBPynrx9 + ScguHoFeVh+0g7CpuRBoea19/Nd78naF1C8v0CtC3vBXrwrZxWMLvYb90c1lB2EDuULYQdhq+RGn + KBA/XfmmkBdopaL5HOitWn68xz1nbQdhA61q4A741IV9h+ibiBBolZDXeXhXyLs+tloRekPv1fJv + IOClcNcbqiI6vZ4wCJuQnF7wlYn3hfyXUIkej+ZCxrWgqTLXAs74gSI7CBvRoxGhE/iRkHcqvE6R + HYSNW5OIUAs3KMK5/UYh7zr6Jk0YhE0RenzVigZ2/KO7qVGEjVYr5B1+P1aEQJ8Q3RYRAn0qJE+c + nsSDsClCoM9q+TeXHOHw+7kiOwibJgzCpijelgdhU/T2NmonvlZ0Dwf6RsgfhK2Wr485wm71LWir + H+i7Wv5Vv63+MyrbFKEWfi/kXaXdrsgOwibknff+qObCu1Y7avlHpNziUeV+ErIVAFXuZ0V2EDaQ + u+yME6mdtXxxxxEC/arIDsIm5FW532v50lT9sngQNpAawWK3kLdb/SHkAlHD96eaCz9UuqeWfyHQ + EX5K9i8QBu9ygfYqsoOwEZ0REQLtU2QHYRPyzpr2oxCOcKmlTpEdhO3j0/tNrScMwqYI7YRRtHpm + lyITI7ojsbCxexuOAsWFvEYhiehf0VyocslC3hZKqLnsIGxEH9mfgHeBGgjJRsMgbETZDebJ7WJc + zG+oyA7CpgmDsIFmyb0onM6nE6UTeafzjYXsSex87qZnEKUSeafzTRQhYyZoR1PvdL4pURqRfRc5 + d3NSYLKE7GvArYP4TtNMzYU9rbnQWKKxNnYLorBBdrMyojJ571ToBKIT5L1TIfvB+DiqmC3VXMiY + S7Q7JbuZ/UZcMssD9ci2c9n3ThXh2YPWQicSnSjvnQqdRHRSmLueMuYrwrMHB4E6trSlx6X1tkQ/ + E9m57HunmvDeKdHXROOIxoXx8/i9U0Xv/0hnv+2JtqaU5Z5MdLK9cHuoIvveqaK9sb3DzGGK7Hun + RN9GhD3tcFB5nv1G+96pIuxpRyiy750KeYGOUhQ/m987JdqSMqKVpbXcq+2kCDdJOwvZVWjfOxWy + mwNHq65EtdFc9r1TUFZrOxcCFQnZuex7p4pwbtWDaD2RF6inkNRCvHcK2tJaAp1KgXoJ2W9EletN + tCaaC1Wuj5AXqK8iBOpH9H7K4ja2Ftr3ToW8QAPUXNiHBgp5gQYRvRSRfe8UlJLvBRosZBePfWiI + kLcPDSV6hMjuabiOXqLIvndK9Dh9o+yPfPNjuJBdVryMr38JebvVCKJ7ormQcaSQt9FGgdzWRr/w + WKIHoppj3zsV8jIeJyTlOoE6uqOFbKOAjMcTLUzZ1RKNVZynogFFEHgMyZP0d9tW2pdQhbzLgico + si+hEj1N5A2ZUAZakO0NanESWsEF/oXbcULuujC/hKrmsi+hEv2Z4gjXOU9RlNrh8q7mVKKk6IO4 + BniaIvsSqpBtsBHodCFvlI4zQNc1865En6nIvoRK9HfKdc3sIcK+hKrIvoSqCS+hEv2V4h5rwqFr + kpAtV3EH6m+cS7Q3mgvXAM8T8gKdrwiHrsmgeU28C7cXCHk3GC9Eudxc9iVURQg0RZF9CRWkhh25 + RMgLdKki+xIq0W8pbtgRXAO8XJF9CRUUz/COxVcS/ZQS94cduUrIq3JXq7nsS6g4AsWlEHik7FrQ + vCbeFrpOyAt0vZorPooajRuIvo/mWtWQmvUbhdzAMPwSKtF22hzewDDTFOEW8HSiX4ns/mpfQhWS + zgUHKldzoRWcAdrR1DYteKtmppB0GzjQzWouBJqFomKuydRMjQsLzC1En0Y0632qcreCiptbCsbz + k2FCtKyyE207MVvNhYy3E62LCLvVHEXIeAdoSgtLyDhXETbanUTvRISNdpciZKzQxBnngRZkexnv + VrTpvG6F5h6iGREt5iET7lWEQPMVIdB9RLelzG3pBbpfyI5rhEAPEM21c02TQAuEqMFeVGa7fw8K + eYPfPERUEbXhCPSwIoy3tFDRkKff7WQeUbSIAy0SokIskkCPgq5qbQm71WIh2rSL5Dj1mCIEepzo + FiIqfYUcp54QooPStJPsoBZLQCn51LmYJp2LJ4mmEVHPa/LJNtBTiuKXUKCnhcYTjQ/nNHy80CxV + tLgqtYd5BrQu/xSiU2ygZ4mujAiBnlOEQJVCpxKdagM9T3RNRNitXlCE/uyLQqfRWj3NBlpWP1fl + qTbQS4riN1Cgl4muiz5YPuKP7uZfipZWpfUwy1G/HCHQCkU4FX6F6G2iCUQTbKBXhexcCPSamguB + Xldz4ebHG0TP6UBvCtkPItBKdI2iQFdQS/4WaEJbWquVp9iW/G1Fz3KgdxQh0Cr0ASa0pe1YOd7u + Q+8KeR301YoQ6D1FqHJVRA8S2X4QOg9rhLz+7PuKzES+GAZa1dbrs69VhD77B1j3jkzq7u7mQ0VP + ccaPhLwu7jqiq+kbvS7uekXIuEHI6+JuJOoXETJuEnJnaJRxM2jfQdKSc8Zqom71xIFqFMXHUaBa + okERYaN9LGTbiSUc6BPQ/IO808RPifoQ2bmwW21RhECfKUKgz4W8Ub++AE3Ot4SN9iXRYUTe0eor + Ia/h+5qoczRXfDQdfr8R8oYx2wpa3MYu/nEO9K2QN/bhd0QdiLwO0jYhrz/xvZDXn9gO6t/G68L+ + oAgdpB+FvP7EDqJcIq8L+5MidGF/Bl3V2tJqHnbkF6IcIvcsLQXaqQiBfhXyHhX5jSiPyHv25Xch + 7+mQXYoQaLf6IPoTfyhCoD81caA9QnJfnh/m+UvNlXxL1yKzlyg1+kYE+lsRAu0jyojWBK5M/APq + 6J9k7CdqSuQ9TFGnCA1f8IklGdGPA4WKEMiAivnRhgrZQjEhO7YmhtuMK1rH9+WTFGEfSlbLQqAE + qF1TS9hCKUIUaLIEaqAIl8xShWjl9BwVBl35YtgnvL7a8RORPeWBpTRQaZYl3A9ppAgZ0zVxxsZE + YUR4YClD0YLt7QpNE0UYnTJTETI2JdqXcLSXM2YJjcity5HLgs0UYaM1V4RALYh2RoTdKluIFp8j + gXI0caCWihAoF4SXG3Lk5kce0ff22dAyfvbA9DCtZC5LCNRaUTLfU2wjRJtjmjwcnA/C41TT5ETq + IEUI1JaoOiI0fAcrQqB2mjjQIUSf/6/a7j26iur6A/jMySQ3CQExPBMCBkF5RbxgCITwkpcXpBIe + YhDEFwJiVFREVHygNymy0CIookWKERVRW2ytolXr28DPV621mgfVqhWsWmvRUqvmt/d375nMzvqt + /vpHy1ou1/3kPuZ7Z+7MmTOzz0ngjLWO9xMU6GhD+VOpxdeP6LOI7uA11N8QAg1Qom21eoZcJB0I + wuZbrZ2ag4g+JKJdWrXu+EoMIdAxSvQbqtIhQwcbQqBjQY90VuJASSXaR5fz+I0UaAjRe/Kskln+ + vvu7JN1QQ1t5XLbjlGghirWXthS0qovQtzzq1zBDCFSmRBkLdD8x3BACjVCi7yu/UrpayoleT+CH + nK+nuiOVaA3l6xqqMBSMoUCjDN0xgAKNVpKRjbdyE3YM0bsJjCmbr7+hsYZwXX4cUWOcKt3xhhBo + vBJtmFW6J5+AQCFhxzdRKRzGmAJNImppJQ40WYlil+g4wyco0fdVMsOfOuWrpEuBMIIwEQJNIfpL + RAg01ZA3jjvDlOjtqysl4zSipjhVuh+ApvUUwhBMJzWYAlN+OK2n7HdRYDq9wRSYTsffW3r4N/Wd + +UxGZfgod/3oxzNmhI8wBNNMerSyV1hCPct8jJuFBVnZKzY2wWyl2FgPJxO9HD2LP9HNMfS9zwWT + oGk9Yxepq5Ri413NJXqKKDbey6lKsRL2eeZZG1AwSfRworhInoUS9tMM4cte0JYq3elKsUmnziDa + EpHM2qkknyizdhLdF72XFEwqxe5wW6gUXsDt0j9xjl2X/DD8O9blIrsu+eHBwrAcfnH4yFvf+/GM + JeEj/loyzg0fYV0uteuSH65PHCyMDexyHsgriK3LaqI7IkLB9vl2cflh+Hcs7gV2cS/A38PFvTB8 + hMVdFj7CAl5kF/Ai89FYwIuVYgNhXNLA1+S8+GASy5XkWRgl8VKiDfSbjQ1osEIptjVcZp4lPWlE + tyWWdYuV9FyuFLvf8QqirYkdeiObDOdmSHrSLKEnTUkbimMO7++uJtqcCO81nTaQ2lXXgPrKZbqA + H3HXdFWH9j0k3bX697BdT+lWEz0RkYzt1pYq3fVKdIDYOFMaWWkQOvI26uGtxhC6nGqJ3olIutWI + 9rQSutUMBVO5Ww2E7lGiSj5eryV6KSIvxd1qhtZzm2SdIWS80b6QM97UlirdjwxJtxp+4iGhZXyz + IazBDYakW41oW2LUYbGMtyjJgNs4hN9qKG8nrcFNSjJ492YOdJsh6VYDpdoLoal/uyHpViNaGpF0 + qxlCoC0NfOtAqj0tRN0saQbf2SB3EwhJt5oldKs1yH0CQsFM7lZTklPJvXvuGeruMrSNA9WBlneI + de7erRReT+BuNaXY9YR7lGLnLvc28OX+kKRbrUHuABBCq3GHIelWU4qdXe4kOiMitBofMJS6n84u + HwQFWpa5lQM9ZEi61ZRiZ5c/a+BpjIJ4peYupdiN4A+DkofHKit+bghtkl8Ykm41S+hWI5rT+kKe + neJRUN9Och9w7YFbytxjhrZwoN2GpFvNEAI9YUi61UA4BdmoJypPGkKgpxp4nJqQEOhpQ9KtZgnd + aqDuXWI3ST/bwGUnIU3k8ZafM4QTlecbeBqjkKRbzRB+Qy8akm41olERSbeaUqwCq94QOj73NEiJ + euwOk70NUtsev8esgesTQ5JuNaXYzWmvEj0b1QujIfOaUlheSxlfBz2TH7vp5A2lsJAqO+V+Q/Qo + UayP401D0q2m1HrTSeItezTnh0m9KQVH89/Zo/nvGuKD4L0dPnLrJz2e8fuG+LB379ijOT98LBGO + foSj+btKsaN5A9H9EeFo3miJm45NSrFja3MD33YXEX/j+0DRUIG9qOn4B6VY0/G9Bm6PhbSFD6fv + K4X3LdGh5o9Ksd/9B0Q77Tf+oVLsvqWPlGK3+fyJaAdRdBtZR/exUmyr2o8DZbgQCHRAKbxvqWd/ + 94mh55bQz+TPRH+Iile3cqBPDWET+gwUTo+BTehzom8SZsaMvxD1zg4Jgb4whEB/NYQ985dEZdnh + hoRAf1OK7cgOmmfhN/GVoXru9/taSb4JBPo7Ub9sc2fZISX5VtHV/A+l2LDk3yjJtJAI9E+iI7Mx + FGWVDir2LQjDgxLhd/+dksxqikDfExW3EgdqMYSJwr1GITqnKZ/kb96/Pel8oqMiws2MzhACZSjJ + pOPY5AJDCJRpCIGyiNplFykhUEJJ5ltGB0W20nhaVL3pOUfpeCK9LT1XaRy9UCcxbmcIt97nEXkR + 1f/whSGuvaGb6g9WuA6GkPEwQ8jYEYQpq8N5jQ8nOpAICVMJ5SvJLdvI2ElJ7/XmjJ2VYpPCdSFq + JoqdYnZV0uFpeSz5bkq0AdTpIEPdG7lTAYPr1qUkUIEhBCok+ohItkIcfXooxU4qigxhpfXURY3d + B93LEA6nRxhCoGIleq86PcXsrUTLtTElgY5UokCrT/ALlxxMuj5KMlT9Bg7U1xACHaUkGyZacEe3 + fqvhVtjPEM4j+uuXE9sKByjRGiqeIDc9D2zkTr6QEGiQJQ5UYgiD4x9D9JvW9+rfOekGg2bzNpE/ + 3l/LM8oeawiBkoYQaIgSbV/5uskNJXohehbW0HGGEKiU6LVW4kDDlGLzn5e1PqtEJ3QfbgiBRjTy + MR3DaBdM8Ocv6Zt05YZqeUbZkUR7ExiMu0BrCSoMoSNzVBuiQKP1E4UQaIwhBBqrJJ+IQOOIfhs9 + C4GOt8SBxivRZlI8SXZ8Ewxt+nhi0k00hBnqJzVyiyQkBJpsCIFOaEM8GJkhGYyM6MGIZDAyQ15H + 7nJToqXfOFH6NqeBdivJYGSNfEodEQYjM4RpgKcbSu2gHV+lIWScAcIOeaOutJlE9xDRcm2cpIOR + KdGPr04LQGYbksHIlGSXhv3EHFA4ljYCnWJI+taIbkyEQ15L35ohTE14KhY1JFzpnQcKbxLHhO7z + lcK+NR6MTEl2aWhPLGjk3qTwvnHpW1OKNZDOAL3SMdZAOlMpNuLLWUrU/qrTm57PVopdH1jY+qzV + OsvdOSDcGk20NeerpFtkaD1PHrnYkAxGZijwqD1xrhJ9YkqvUi0lqpHBtVKVsuM7j+g6GZWrXE9d + q5XonLd8pr+KR6g+3xBW2gVK0s0v9Zcg3EBdoqfny5SkTx99KhcZKhp4VNJdrEQLUTxDbia7RIkW + tUCvgSwH5XF/d8F0/xDqL5ViPewrDCHjZUq00vJ1pa1s5HE7QkJ/w+WNfPqE0to8rdq5whLqLw3h + 5G+Vofn3B0l3FTejItrMga4GYXiqPG0EXmMIO/drDUn9pSFshdc18jhzIUn9JQiz4eTpbJhpos4R + Sf2lJdRfGkKgHxqav4cCrSH6OguDTiSmUSOQAt1gSOovleiFCVr6Eu4ba+TJnCLi3eO6NsT1l4ak + /rKRRwsLSeovDaHXa30jj4gWktRfWkL9JQiBEppxo6HnDtCpyC2GbuGMtxIdE5HUXxrCfJK3GZL6 + S0NSf9nIY4qFJPWXStK+x67jx0pSui31l40yGBm9sFoD3WkIgbYSDY1o4h5qM/1ESd5rC9dLbGvk + yYJDkvpLEMqt6/T0vE4pVhNyt1Ls3Gq7eRYC3WMIJ4v3NvIE5RjcPpxI9z4liS31l4bQCLyf6DA5 + IaZGYMcdFGinEh0oqidToEMV7gHQko6ggB9xZ/OCDu0LtRiTJI/+LpMX4UTrIUNSjGlIijGVZIoj + KcYEPdienrV6kpw5PqwUOxb/vJGr/yJCMaYhHIsfMdSB0/0SlFLazLPqPqokZ0JSjNn6rNREqUna + 3fqslJbLPm4Ie8EnQB/mCSHQrwxJMaYStfXK9UTrKUsoxiT6KCukIJcC/RqEcxyirtzEfUaJWpcl + x/vr+Fj8rCEpxjSEs6rnDUkxJqh/rhACvWgIgV5SkoXAHuJlJfq+SnQN1SvJWYIUYyrRZlQ+WSZy + 3kv0OZHM4+X15Y4yJZlEe+Ke5aXuFUNoxr9qSIoxifbLe6VSsqd/3ZAUYxqSYkxDUoxpCcWYIBSv + prSH6S2iT4hkxmwpxjSE39jbhmqXbB/qfm9oDQd6R4m+nI16ovWuIay0BkNSjGkIgZoMSTGmIdy3 + tE9JGpxSjGkJxZiNPC5+SGjGv29oNjdx/wj6IlcITdwPDEkxpiEcpz5qQ1yMaQhb4ccgtHrDadX2 + G8Kx+IAhKca0hGJMJfruS3QNfQpa3kFowZrSpPtMidZ2cYrW0JcV7nNDUoxpCIG+aENcjAlCR2Sx + Tvj+pSEpxlSiLTp/ijT/DhqSYkwlakHna/3v16BPOwmh7//vStLy2nKAGheHlGQi5w184P2HErX1 + 8vRixjeGcMfIP0FoEeZpE/dbJXkvBPrOkBRjKtHRLKGjubYYkmLMJiaMQpXQPkBfid4roW12Z2jf + lMykyzCEmakDpVigzCaetKm4SKgjXxDMUqJWb57eTZFQouZynl4QzFaidna+FkfkKJ1MdLK0JHKb + uBR+F983nj/H97iYqZ0hKcZUOoXeXu9AbW8oWEAZOxgqXEoZDwM18T3oeXP8e+s7j3AdDUkxpqEv + eaXlK9Gi5ukdqJ2UZtNyzZaV1rmJ59fB/aD5egdqF0PoYepqCIG6WeJA3Ym2t76QrxEWgHA3K1Ft + zj1DXaEhBOphCIGKiLZFhKu4PdtSpesFeqM4DEQr7QhDCFTcxPNXv8E3y27UldZbKXbR80hLHKgP + qLS3XvTkq7h9DaWW0pnjUYYQ6GilWLlsP0MI1J/ofPrE2EXPAYYQaGATj00SEgINUoqNflViCIGO + AWWHxIEGN/EI5SGh5ujYJp5gK6TJi0vLXNLQdg40xBACDQWFN/Ei0HFKsSKq0iaeYj4kBBpmCIHK + DKHFNxwU3uCKQCOUYjVH5eZZuEd4pKEX1tAZR4UhBBoF2tUzVkQ1mmgtUXTJNuXGKMVuqR1rCL+h + ceaFCHQ8aJo+C9cKxivFKrQnWOJAE5ViA/5NMoRu58mg/UXhMNYU6ARDCJRq4mnh97cOV5hyU5Ri + ZfVTiZZFz3J8/+yJoHR8UMNpSrEOmR8Ywko7ieg0othKm64Uu+hZCQoHSMQojTOaeLKEkJBxpiFk + nEV0dUTIONsQMp4MMsNYzzGEQKcYQqAqpVgP01yl2Eo7FTQiXmw5D4s6ons4gzjtJ+YryT0OTWtf + HOJOU5LdEAItMIRAp4Pe41r1qjkS6Iy2VOnOJFpCRAeKci2OOIvo4ogQ6GxDOO9YCEKZW7kWR5xj + iQMtUqJPLNCqsMVESyNqWNol6ZYY2lHffYQ7F7RGCYGWGkKg89pSpasmmhsRAp1vCOe9F4D6KmHH + d6EhBFpmiQNdpCQZcay92NArXEN/CWh+fhW1yav8n9YXjnDLlaRsC4EuNYRe2hVKUkODQJcRlct7 + paok0ErQjq5CCHQ50VQieq+SudLiu0KJ3qtES3SutMSBVhkKllKgq4imUNtEqOsDw5LuakOPcqBr + DCHQtYZwkrGaaFJECHQdqLpYCIGuN4RNLm0IZ4Y1hhColmhcK3GgH4LW9YkFWmNo4gO3lrkbsKgh + PcKB1irNo9/QPN9bxp1hRCuJ5hPNl4zrDGEoohsNIeNNSqcRnSYZf4S9XEhYaeuVFhAtkP3EzUQb + svr3OZ3aAFootsESZ9yoJLVjwXWU8RZDk7ny7VZDT3LGTYYQ6DZDqHzbbAiBbjeEQHcYwkr7MeiF + I4UQaItSrPLtTkscaKtSWPlGgX6iJDVtc26gFt82Jalp213fdYS7i+jaiBCoTklqxw5xh8vdhhBo + u5IUiuHwew/oWy3IQqB7lbQ8igPd15a6ux1K0pmPQPcr0YlUuY5juBO0uTedgZVM8Qv30JnhA4a2 + 83nHg4YQ6CFDHl8r+KkSvX1xOHUn0XJquAkh0C5DMnWnEr1X8RT5Wf1cSc4fEegXSnISi0CPgFb2 + orPfEr334JdKdHJdMsmfs58CPaoknTcYQe4xQwi02xD2E4+DqnrIeyHQE008t1BVD3kWNrlfGUKg + J3EAi4gDPaUk74VAT4Pe6qbEgX5tKCikQM8Qnc0z/SDjpjV9k+5ZQ7gu/5whBHoeNLGrEAK9QLQg + IgR6UYk+sUo7LV8yhEAvt75wo05nWw/qzuNR1mmgPZY40F4l6Z/wunP/lyFkfMXQqWu2J92roDWd + hNZxxtcMIePrhpDxDUPI+BtD2ArfJKqg42Osw+W3htCD9JYhZPydUmylvW0IW+HvQWuEAn7EHcoz + +O7lohStwXf077SBFE/013K6d5Xk6j7SNRB1jehrTteoJJffka5J6Xg6FdZOzWainhHJ7JuG0Fr6 + gyGke4/o2FbidO+DDh1On5invbR/xDEvpO79g6T7wFCaLzB+qCTvhUAfGXLcWvoTKMkvLNBAHxvC + Jrmf6PSIcJw6gJUaEnYanyjF7qz4MyjoqB23HOhTQ1hdnynR6kpN8t+6j3Yan5tnoUv2L0r09iW6 + hr5AQ2XUYXJTQza3lv5qCIG+NIRAfzOEIZQOGsJv7CtQxw70ias10NeWONDfiUZGhAsDh5Ro6et0 + wvd/EJVmhde01/OdFd+APsyLzY/+T6ITo1mkMZ7Nt0qx4Wm/M4RA3xPNiQhrqAUUDXPHgbzmM8cu + zDLj4/mWOJBTCi/SU6AMQwgUgMK5DdfXf1LhMpVi42hmKUlGXLpJmGchUHYzL2r4LATKMYTfUK4h + 15k7w4gWRYStME8pdiNCe0ucsYNSbFL7w5p5hx2+FzJ2NLSOMx7ezGcvRfGVlm8IGTuBdscnte/c + zKd24W1gyNjFEDJ2beYRa8MXorXUzZCMTGYJI5M189iqrbeUUaBCJZ2QdT+1lnoQvZgI6SYOVGRI + RiYzhK2wF9EjEcnIZIYQqFgpNkpjb0MyMhnRAwmzhvpYwshkSroQhTwymXnWC/0ODndHE90VEdZQ + P0MyMpkhrKEBhmRkMqXYGhpkniUjkzVzeUS40rCGjlGKBRqsFPtZHaukw8DyJpc074VNboiSbJhr + OdBQQzIymSEceEvNQsjIZIZwaCozJCOTEV0ZEU4TRxiSkcmUYnVlI4lWtN7FyGuowtC0PcPK3Cgl + WY9rONDoZp56xmxyYwwh0NhmnuvVbHLjQLOjQDwymSEEGm8Im9wEQzIyWTMPRTo7/huaBPoiVwPx + oWmyUmwNnYAtOqRaDpQyJCOTNXPBaUi4dDPVEu+/TmzzLB6ZTCmW8QfNXA0VkoxMpqS/NIxMZp4l + I5Mpxe7AmmEIg5/ONO/VtDNziJulJGsb19tmmxfKYGTNfA/5F7nh7VaUcY5S7I7uU5TCgQ9oK6xS + ilV8zQXtbkenUFUny/W2U5VOoSOydifNU6IztBIdam2+oeAsWmmnGWpaOyzpFoA+zBNCQfPpSvT2 + BafoYGSGcIn3TCW9AoPByIg2Ecl1GgQ6W2kWvVCv5ixUkhpnbIXnKMnNTzIYmSUMRmYIxUNLQJit + raDSbzo3M+nONVTHAx8sNSSDkSlp/S+3+KrbUqU7HzQ/XwiBLiC6PiIZjMwQznuXKdEnVoWDkVnC + YGQgzJ5YpdVQlxBVRZTKOXmoW25oGwe61JAMRkY0l0jGaPier0VdBkK1dziSw0pDUkJpCA2kKwwh + 0JVK9ImrNdCqZp59DFX7q/VKx1VKtPmu1i7Zq4mmJzCMXfUsKTK8xhDG2ri2mSurtnSfTRQORgaq + 6iGEDr/rlGQQK6maNCSDkRmSwciaeZq3kNDiqwWFA2JJ1aQSfeJqvbi2hujEiBDoBiVa+tWz/GkH + DibdWiWJLVWToHSREAZSWmdIBiNTkq8Qt7vcZEiqJonKI5KqSRCq0Dfq1ZybiaYQya4Dh98NhqRq + EhkjQtWkIdzFeCsIl2WZBtBWuMnQTi6rv00pdnlqc7NMzCSEo9XtSrHLU3eA1heGl6foZ/VjJbl0 + I4ORGUIT9k6l2IWBrUQTWglVk0Rj7PRN2wzhaHWXoe2846szJFWTSuFkg1w1CTKzot2jFFYmU6B7 + lWKVyfcpxSqTd5hnSdUkaFWXWANpp1KsPfGAodTivkPcg818K+UqnYhjG/ePPaQkLSupmgQ9ky+z + bmBP/jOlcbRqdYaFXUpj6dcxVgI9bEiqJpXG0G5ojA5GBgo6CknVpNJootFaNak0is5rR/nB515/ + 96hSBVGFf8vk2UPdY5b4Dr/doKI8IamabOaZforyRhKNlEBPKJUTlWvVpNIIohES6Eml4T1ayodr + 1STojBwhBHpaqYx27mVaNWkJVZNKw4iG+cHbFOhZQxg5/TlQaTa9MFXmX13/pwr3vCGpmlSShbia + 71B+UYmWvmSEtCdeakOU8WVQdUIIGesNIeMeolciQofLXkPee94u9z+GEPsV0PYsWq6C4RL7VUPB + Por9mqGmRZ2S7nUlylhQ5l9cv6/CvWEIsX8DWpkphDtg3jSEjL81hIxvGULG3zXz7QghocvsbVBn + JQT6vRKtocQwCfSOIazHdw1tmZyRdA2GquvfqXCNoF1BKVGpBGoyhCNys9JxPVrccRJonyEE+oMh + BHoPNC0kDvQ+0bfBtGAo0VAJ9EeirMyIONAHhoK9FOhDQ72OpkAfER2eGb79ovq3KtyfDCHQx4bQ + ZtrflirdAUMI9IkhBPqzIbRqPzWEQJ8RdWglDvQ5UZeIgtco0F9A4fc1nwN9QZSMCIH+agiBvjSE + QH9rS5XuINHwzM6ZsUBfGUKgrw314kB/53ZORAh0yBIH+gdoZWYs0DeGEOifRNdGhEDfEj0XEQJ9 + ZwiBvgeNy4oFajGEQN6+M8fujQiBfEM4+3WGECiD6M3M7UIBP+IO5VP4DmWkC/Tvse0v0xDSZREd + imghp0sYQrpsom5ZISFdTluqdLlEw1qpnnZm7QwhcJ4hBG6/j7tRsxNC2DF2CKkw+o0dZokzdiT6 + IDskZDw8pNaM+USdcsJnIWOnkFozdiaqIBpCNER2Gl1CKmRCxq6GEKgb0Vk51UoI1N0Q1mAB0YqI + EKjQEgfqYSh4iQIVGSriQD2JLiGKBeplCIGOMISVVkx0cZwqXW9DCHSkIQTqQ3RhRFhDfQ0h0FGW + ONDRoDcSxxVGv7F+REsjwhrqbwiBBhCdFxECDTSEQINApdkRVboSokURIdAxhhBosCHsBY8lWhwR + AiWVYoGGEC2JCJvcUEMLONBxhhCo1LwXAg0zhEBl5oUINNwQAo0g2hIRApUbwiY30hACVRDd2JqR + A40yhDU02hDW0BiiayM6iwONNYRA4wwh0PFtqdKNJ7rSrqEJhhBoIihc21hDk4guiwiBJlviQCcY + QqCUIQSaAqpOxAJNNeS9QvuvEw0h4zT7LM74A6KVcap0JxlCxumGkLGSaFlEyDjDEDLOtMQZZ4Gy + 4xlnYzMJCVvhyYaQcY4hBDrFEAJVEZ0Rp0o31xACnUp0dkQINE+plKhUAs03hECnWeJAC4jmRhS8 + SYFON7SJm39nEM2PaFH92xXuTEMYpuIsQwh0ttIwomESaKEhnNufYwiBFhnCecliQwi0hGhOK3Gg + c5WGF7bkaQN9qaG9Z1MD/TylskJuGy/i9mx167OoGY9A5xPNkmcVl0mgC9pSpbuQ6CRZiAINtMwQ + Al2kRF9OQal0yFxsCIEuIUrJqi3XTW65Ej0rpWvoUkNrJx+XdCtATZlCSzjQZUq0EOXDZJNbSdQ/ + IhS7XW4Iga4whEBXEg3K6ayEHqZVhtBldhXR4Dh1d1db4kDXGMIZx7VER+XsCoTyXnp+iFttaBkH + uk6JvvuNegp1vRKttI3DpcssrTSisKVOTxNriHrl7M8oJyr3e6ymQLWGEOiHRH2JRhKNlEBrlCqI + KiTQDZY40FpQOmNUYcuuUb53kKepxEKkM0YTjfaDbyjjOqUxRGP8t/psH+puNLSSM96kNJYC6SyY + P9JA4wpbVo/zs/kOrPVKxxe2VGtB1c2GsJ/YYAhb4UZD6DK7BdQ5UwgZbyXqRkSfWK1TXm4yhHE3 + bjO0afHCpNusREtfNVYC3Q5qyqSMqTES6A5DuAT3YyX6vlKjJdAWQwh0pyEE2krUPnovnCb+xBAC + bbPEge4iyoreK/ia1lCdofqPz066u0HjsoRWcKDthhDoHkPoMrvXEALdt4/nRQkJP6sdoO1ZsUD3 + W+JAOw0h0ANKFGi1BnpwH88EFBI2uYdAiE300seXlLqfGsIa+pkSrbQ63eR2xSmTH/E5jhd4LS1Z + /Kj8oitfamnzz/s3/vHzfK8xr3+uvkJe2dKSGb5LVvhh/4m394P/+NvHX+Gy/ytvv9CTV2Tk/he+ + nPfy7pKl9oK8tm+PYmFsq9g6cS8MOm1Tnve+1+H7oNYLarOC2gyXDlw6kZXOzkrnuHSuS7dz6TyX + bu/SLiM303fZv6TlXDhkvPfUqzp8V5uljZban+J573jtvwtqXVFtZnFtTse059K+Sx/m0llZLtf3 + 2vkuz3ftfdfB93L4fQ/9dMy/uYb+/3/v4DWrbth098NP+097O1oy+RNYkxl+S8tUz1vnVfDCBTUZ + QU1mUJMV1CSCmi5BTfegpjCo6RHUFAU1PYOa4qCmT1DbN6g9Kqg5OqjpF9T0D2qSQW1ZUCPfUAdE + 6ujSg9z1Je76Y9z1w1263KVHurTnO993AX1tvt/O9/J8j9Ie7vv5vuvEt7a4rr7r5rsC3/Xy/SN8 + v7fvjvS9Ab430HeDfTo3pZMMbi1Sk2sYT9LncjnEY873EhN874l+vnfej7bh6+m7op03q7kH3P4r + Pun9YePx9YV/C/9/8lrZ5KZ7930RPjvfD7/sCZ7v5Q6i9Vjo5Xv9tuAnnclblZd7Ij3PW44vr5a+ + vIC/udrsoDYnqM0Nauk76xXUHIFvTr6wAUEtfWEnBbUXFCeWBbXLA3dp4FYE7rLArQzSlwfpVUHt + VUHt5qB2R1Dzy2DNr4I132PLk6+2s0t3cemuLt3NpQtcutCle7v0kS7dx6X7uvRRLj3QpUtc+hiX + Ptalp7t0pUvPdelTXXqeSy916fNcutqlL3LptEvXuHStS9/m0ne69FaXvt+ld7r0wy79c5f+hUs/ + 4tJPufTTLv0CrzrP971M38vi0V1opTlZad1918N3Rb43yPcG+16574/0/Rk8aY87zXcLfHeO7xb5 + brHvlvjuXN+d77uLff8S37/CuSudu8F3a53b5Pu7fe9J33vGd8/67jnfPe+7l31X77s9vtvru3a8 + nvUndg3/dwGtQ/7ZhbuE0P+P//CPnzv3wsVn/jt7pX/1L9xeWh/f5tm/+//yfeynyHMHJ7bktLT0 + dy0tjwTrcpsyz/dy/NxBqTPo77zT6tGz9TXXIBBtbYV4o4EtLfNa/uO7ivy2u4ppnnekl/MddoqZ + QS3ts+gXl+F7AW8NLkG7rXAvyD8h+sUU0h7l6Kb/BVBLBwipDEp8X3oAAJRYAQBQSwECFAAUAAgI + CACQkytXqQxKfF96AACUWAEAGAAAAAAAAAAAAAAAAAAAAAAAMTE5OTg5NTcwMDdfQUNUSVZJVFku + Zml0UEsFBgAAAAABAAEARgAAAKV6AAAAAA== + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8051f899de562845-DFW + Connection: + - keep-alive + Content-Type: + - application/x-zip-compressed + Date: + - Mon, 11 Sep 2023 18:28:32 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=UasM5X17vbczyPuHS8ZkKgf9dhIaPVvfztkmUlVZCFpeDvl304Gx8EwjapAM4eMIjt70PTgSNnNAMmXtzkVKh0BVUVAUf9X3p6ro5v%2FIN2mLHmxnv3AU27akiMmY8QOJmwHsSrIsqQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + content-disposition: + - attachment; filename="11998957007.zip" + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_exchange.yaml b/garth/tests/cassettes/test_exchange.yaml new file mode 100644 index 0000000..fe59419 --- /dev/null +++ b/garth/tests/cassettes/test_exchange.yaml @@ -0,0 +1,105 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - python-requests/2.31.0 + method: GET + uri: https://thegarth.s3.amazonaws.com/oauth_consumer.json + response: + body: + string: '{"consumer_key": "SANITIZED", "consumer_secret": "SANITIZED"}' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '124' + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 03:43:24 GMT + ETag: + - '"20240b1013cb35419bb5b2cff1407a4e"' + Last-Modified: + - Thu, 03 Aug 2023 00:16:11 GMT + Server: + - AmazonS3 + x-amz-id-2: + - V8hHVVhXCEX7RD7Vzw8IsKS//xFr7co0468z4G834xsWIJ46GpXAwZKETm68Odczy470cauMZXo= + x-amz-request-id: + - Z03APPY9GXZFWZ69 + x-amz-server-side-encryption: + - AES256 + status: + code: 200 + message: OK +- request: + body: '' + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + Content-Length: + - !!binary | + MA== + Content-Type: + - !!binary | + YXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVk + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: POST + uri: https://connectapi.garmin.com/oauth-service/oauth/exchange/user/2.0 + response: + body: + string: '{"scope": "COMMUNITY_COURSE_READ GARMINPAY_WRITE GOLF_API_READ ATP_READ + GHS_SAMD GHS_UPLOAD INSIGHTS_READ COMMUNITY_COURSE_WRITE CONNECT_WRITE GCOFFER_WRITE + GARMINPAY_READ DT_CLIENT_ANALYTICS_WRITE GOLF_API_WRITE INSIGHTS_WRITE PRODUCT_SEARCH_READ + GCOFFER_READ CONNECT_READ ATP_WRITE", "jti": "SANITIZED", "access_token": + "SANITIZED", "token_type": "Bearer", "refresh_token": "SANITIZED", "expires_in": + 107182, "refresh_token_expires_in": 2591999}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f13cbbc2a754790-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 03:43:23 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=T5EHGPEATgD5SbyAMCZh1mKSEJkUest3sa7l%2FTpQ6dZl3uv3K%2BW7Ng20XTseNh3KPdqYzHdkCCB5d4npBML1ZgAAmVUYdkrYiM2uJhmn7WfvSdrIyme0uCf9p5t7RY6%2BRUxNYfhL8Q%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_login_command.yaml b/garth/tests/cassettes/test_login_command.yaml new file mode 100644 index 0000000..9d45d93 --- /dev/null +++ b/garth/tests/cassettes/test_login_command.yaml @@ -0,0 +1,1018 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + response: + body: + string: "\n\t\n\t GAuth Embedded Version\n\t \n\t \n\t\n\t\n\t\t\n\n
\n\t
\n\tERROR:
+        clientId parameter must be specified!!!\n\n\tUsage: https://sso.garmin.com/sso/embed?clientId=<clientId>&locale=<locale>...\n\n\tRequest
+        parameter configuration options:\n\n\tNAME                           REQ  VALUES
+        \                                                  DESCRIPTION\n\t------------------
+        \            ---  -------------------------------------------------------
+        \ ---------------------------------------------------------------------------------------------------\n\tclientId
+        \                      Yes  \"MY_GARMIN\"/\"BUY_GARMIN\"/\"FLY_GARMIN\"/                   Client
+        identifier for your web application\n\t                                    \"RMA\"/\"GarminConnect\"/\"OpenCaching\"/etc\n\tlocale
+        \                        Yes  \"en\", \"bg\", \"cs\", \"da\", \"de\", \"es\",
+        \"el\", \"fr\", \"hr\",    User's current locale, to display the GAuth login
+        widget internationalized properly.\n\t                                    \"in\",
+        \"it\", \"iw\", \"hu\", \"ms\", \"nb\", \"nl\", \"no\", \"pl\",    (All the
+        currently supported locales are listed in the Values section.)\n\t                                    \"pt\",
+        \"pt_BR\", \"ru\", \"sk\", \"sl\", \"fi\", \"sv\", \"tr\",\n\t                                    \"uk\",
+        \"th\", \"ja\", \"ko\", \"zh_TW\", \"zh\", \"vi_VN\"\n\tcssUrl                          No
+        \ Absolute URL to custom CSS file.                         Use custom CSS
+        styling for the GAuth login widget.\n\treauth                          No
+        \ true/false (Default value is false)                      Specify true if
+        you want to ensure that the GAuth login widget shows up,\n\t                                                                                             even
+        if the SSO infrastructure remembers the user and would immediately log them
+        in.\n\t                                                                                             This
+        is useful if you know a user is logged on, but want a different user to be
+        allowed to logon.\n\tinitialFocus                    No  true/false (Default
+        value is true)                       If you don't want the GAuth login widget
+        to autofocus in it's \"Email or Username\" field upon initial loading,\n\t
+        \                                                                                            then
+        specify this option and set it to false.\n\trememberMeShown                 No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box is shown in the GAuth login widget.\n\trememberMeChecked               No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box feature is checked by default.\n\tcreateAccountShown              No
+        \ true/false (Default value is true)                       Whether the \"Don't
+        have an account? Create One\" link is shown in the GAuth login widget.\n\tsocialEnabled
+        \                  No  true/false (Default value is false)                       If
+        set to false, do not show any social sign in elements or allow social sign
+        ins.\n\tlockToEmailAddress              No  Email address to pre-load and
+        lock.                      If specified, the specified email address will
+        be pre-loaded in the main \"Email\" field in the SSO login form,\n\t                                                                                             as
+        well as in in the \"Email Address\" field in the \"Forgot Password?\" password
+        reset form,\n\t                                                                                             and
+        both fields will be disabled so they can't be changed.\n\t                                                                                             (If
+        for some reason you want to force re-authentications for a known customer
+        account, you can make use of this option.)\n\topenCreateAccount               No
+        \ true/false (Default value is false)                      If set to true,
+        immediately display the the account creation screen.\n\tdisplayNameShown                No
+        \ true/false (Default value is false)                      If set to true,
+        show the \"Display Name\" field on the account creation screen, to allow the
+        user\n\t                                                                                             to
+        set their central MyGarmin display name upon account creation.\n\tglobalOptInShown
+        \               No  true/false (Default value is false)                      Whether
+        the \"Global Opt-In\" check box is shown on the create account & create social
+        account screens.\n\t                                                                                             If
+        set to true these screens will show a \"Sign Up For Email\" check box with
+        accompanying text\n\t                                                                                             \"I
+        would also like to receive email about promotions and new products.\"\n\t
+        \                                                                                            If
+        checked, the Customer 2.0 account that is created will have it's global opt-in
+        flag set to true,\n\t                                                                                             and
+        Garmin email communications will be allowed.\n\tglobalOptInChecked              No
+        \ true/false (Default value is false)                      Whether the \"Global
+        Opt-In\" check box is checked by default.\n\tconsumeServiceTicket            No
+        \ true/false (Default value is true)                       IF you don't specify
+        a redirectAfterAccountLoginUrl AND you set this to false, the GAuth login
+        widget\n\t                                                                                             will
+        NOT consume the service ticket assigned and will not seamlessly log you into
+        your webapp.\n\t                                                                                             It
+        will send a SUCCESS JavaScript event with the service ticket and service url
+        you can take\n\t                                                                                             and
+        explicitly validate against the SSO infrastructure yourself.\n\t                                                                                             (By
+        using casClient's SingleSignOnUtils.authenticateServiceTicket() utility method,\n\t
+        \                                                                                            or
+        calling web service customerWebServices_v1.2 AccountManagementService.authenticateServiceTicket().)\n\tmobile
+        \                         No  true/false (Default value is false)                      Setting
+        to true will cause mobile friendly views to be shown instead of the tradition
+        screens.\n\ttermsOfUseUrl                   No  Absolute URL to your custom
+        terms of use URL.            If not specified, defaults to http://www.garmin.com/terms\n\tprivacyStatementUrl
+        \            No  Absolute URL to your custom privacy statement URL.       If
+        not specified, defaults to http://www.garmin.com/privacy\n\tproductSupportUrl
+        \              No  Absolute URL to your custom product support URL.         If
+        not specified, defaults to http://www.garmin.com/us/support/contact\n\tgenerateExtraServiceTicket
+        \     No  true/false (Default value is false)                      If set
+        to true, generate an extra unconsumed service ticket.\n\t\t                                                                                     (The
+        service ticket validation response will include the extra service ticket.)\n\tgenerateTwoExtraServiceTickets
+        \ No  true/false (Default value is false)                      If set to true,
+        generate two extra unconsumed service tickets.\n\t\t\t\t\t\t\t\t\t \t\t\t
+        \    (The service ticket validation response will include the extra service
+        tickets.)\n\tgenerateNoServiceTicket         No  true/false (Default value
+        is false)                      If you don't want SSO to generate a service
+        ticket at all when logging in to the GAuth login widget.\n                                                                                                     (Useful
+        when allowing logins to static sites that are not SSO enabled and can't consume
+        the service ticket.)\n\tconnectLegalTerms               No  true/false (Default
+        value is false)                      Whether to show the connectLegalTerms
+        on the create account page\n\tshowTermsOfUse                  No  true/false
+        (Default value is false)                      Whether to show the showTermsOfUse
+        on the create account page\n\tshowPrivacyPolicy               No  true/false
+        (Default value is false)                      Whether to show the showPrivacyPolicy
+        on the create account page\n\tshowConnectLegalAge             No  true/false
+        (Default value is false)                      Whether to show the showConnectLegalAge
+        on the create account page\n\tlocationPromptShown             No  true/false
+        (Default value is false)                      If set to true, ask the customer
+        during account creation to verify their country of residence.\n\tshowPassword
+        \                   No  true/false (Default value is true)                       If
+        set to false, mobile version for createAccount and login screens would hide
+        the password\n\tuseCustomHeader                 No  true/false (Default value
+        is false)                      If set to true, the \"Sign in\" text will be
+        replaced by custom text. Contact CDS team to set the i18n text for your client
+        id.\n\tmfaRequired                     No  true/false (Default value is false)
+        \                     Require multi factor authentication for all authenticating
+        users.\n\tperformMFACheck                 No  true/false (Default value is
+        false)                      If set to true, ask the logged in user to pass
+        a multi factor authentication check. (Only valid for an already logged in
+        user.)\n\trememberMyBrowserShown          No  true/false (Default value is
+        false)                      Whether the \"Remember My Browser\" check box
+        is shown in the GAuth login widget MFA verification screen.\n\trememberMyBrowserChecked
+        \       No  true/false (Default value is false)                      Whether
+        the \"Remember My Browser\" check box feature is checked by default.\n\tconsentTypeIds\t\t\t\t\tNo\tconsent_types
+        ids\t\t \t\t\t\t\t\t\t\t multiple consent types ids can be passed as consentTypeIds=type1&consentTypeIds=type2\n\t
\n
\n\n\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-RAY: + - 941869b709383234-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Sun, 18 May 2025 03:54:23 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=%2FhZEGwPtUSn1pEF727RjKjHPNtxr2sPRf%2BF5WKc3ZMXKWmjzCH7P7S4f1xAWz8JL8k9xhOVRpeD2Z3SReERsBJSJifGLLnXqbOgq1IcSBDL1LC91JQ7rcXoc4eNB51%2Fg"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cf_bm=SANITIZED; path=SANITIZED; expires=SANITIZED; domain=SANITIZED; HttpOnly; + Secure; SameSite=SANITIZED + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:5 + X-B3-Traceid: + - ceabc92cf1cc4eab5579af6c7bed5278 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - ceabc92c-f1cc-4eab-5579-af6c7bed5278 + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + method: GET + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n \n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 941869b8cc823ec6-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Sun, 18 May 2025 03:54:23 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=%2BkcdBP88jar20pLHCjjfakR%2FOzTwXzSbkcJWxD0JW9bC495IlAIL6n88Ft1pAlvPb2D5646rwHmNaGL8wC5uExqzAWBnRKuMgmNjclIptexHOHRiDNH50iVYBJlKZyYW"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - SESSION=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - __VCAP_ID__=SANITIZED; Path=SANITIZED; HttpOnly; Secure + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:5 + X-B3-Traceid: + - 2c6d5a2a82c64c226a22e5b4b6229492 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 2c6d5a2a-82c6-4c22-6a22-e5b4b6229492 + status: + code: 200 + message: OK +- request: + body: username=SANITIZED&password=SANITIZED&embed=true&_csrf=5F7DFFCEEE6925027BD5D65AE28754E9B3C72046528057AB73EC766FF1992D70CF97058E5EB9CF0424436C7556B319E03564 + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '177' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 941869baadfa576f-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Sun, 18 May 2025 03:54:25 GMT + Location: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=uGPdwYnDMJlxoghO8TgYvhqacWtLTzocTh925%2BnT%2B86N7B91B%2FYe7AME8SxVYnQ7H0RCRTLExDJCWZSdQUX50SWWfmQOztRBnsSKVNu6Cti5B3L1EDHzpS%2BDxPUZCeiS"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cfruid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:5 + X-B3-Traceid: + - cc67d2dc13b147604c4e2916f0a73ed2 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - cc67d2dc-13b1-4760-4c4e-2916f0a73ed2 + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n\n\n \n + \ \n \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n \n Enter + MFA code for login\n \n + \ \n + \ \n \n \n \n\n\n\n
\n

Enter + security code

\n \n \n\n + \
\n
\n \n \n + \ Code sent to mt*****@gmail.com\n + \ \n
\n + \
\n
\n \n \n \n + \ \n \n \n
\n + \
\n
\n \n
\n + \
\n

\n
\n + \ Get help
\n
\n + \
\n + \ Request a new code\n + \
\n \n \n + \
\n \n
\n + \ \n
\n \n \n \n + \
\n
\n
\n
\n
\n
\n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-RAY: + - 941869c2bf78c4bd-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Sun, 18 May 2025 03:54:25 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=O5LoZ39MYjzPuOtwXLQ8UB0owRoKYN%2BtBapCGUTUgleoqFzc3M6W7%2FXSu5K2JfUE8wmBBA0LqRB7yd5rHtKcGWVuR%2FXwT5b6iOME8JzUmUmaLD%2FR5QDuG6L5yqjiqRIO"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:5 + X-B3-Traceid: + - 30524d14299e42f25d62f4265a1b78e0 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 30524d14-299e-42f2-5d62-f4265a1b78e0 + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +- request: + body: mfa-code=023226&embed=true&_csrf=BD65E707CBFEC6BCE56E9AE0ACFE808A1876AE4084DEAD1A36446958A8BAEBE31AB2AA1CDC6DB590E94204AB33DC7C97D060&fromPage=setupEnterMfaCode + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '160' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-RAY: + - 94186a15997a6152-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Sun, 18 May 2025 03:54:39 GMT + Location: + - https://sso.garmin.com/sso/login?logintoken=ABPBTEJqhh&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=PX9px6xuebqEzI6ITrPT4ozQoFnFIRn%2FA2FogGWPrDSs6n68ZjmqlP8j2VJe%2B17vBXl5w9qVyAea%2FLtMAdWgP5KyuX02DRRR33%2FCoTH%2FNjfJsjU5VBTVHR31t7fyIXtz"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:5 + X-B3-Traceid: + - f31b3393bb7b4e8c730d115d0f4a2a86 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - f31b3393-bb7b-4e8c-730d-115d0f4a2a86 + cf-cache-status: + - DYNAMIC + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/login?logintoken=ABPBTEJqhh&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + response: + body: + string: "\n\n\t\n\t\tSuccess\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\n\t\n\t\t
\n\t\t\t\n\t\t
\n\t\t\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 94186a1d2e3ed187-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Sun, 18 May 2025 03:54:40 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=wDr4ONg6xrCXitZpuIz%2B6LP4t%2FuaSBygx3L0qC6BLT2wgIPBBFAazol6f0wb%2BWIfUsNMFtTSo9gWlNkmueMy%2FhpySZ77oLdoWyZKsC0VNkrE5j%2BYeFSttyN18s9%2Bx48K"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + - GARMIN-SSO=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GarminNoCache=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GarminNoCache=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GARMIN-SSO-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GARMIN-SSO-CUST-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO-CUST-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:5 + X-B3-Traceid: + - 690357fd57d547734accfb38e7fbd7eb + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 690357fd-57d5-4773-4acc-fb38e7fbd7eb + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - python-requests/2.32.3 + method: GET + uri: https://thegarth.s3.amazonaws.com/oauth_consumer.json + response: + body: + string: '{"consumer_key": "SANITIZED", "consumer_secret": "SANITIZED"}' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '124' + Content-Type: + - application/json + Date: + - Sun, 18 May 2025 03:54:41 GMT + ETag: + - '"20240b1013cb35419bb5b2cff1407a4e"' + Last-Modified: + - Thu, 03 Aug 2023 00:16:11 GMT + Server: + - AmazonS3 + x-amz-id-2: + - 3HIN8BJBpqJfop3PUQfysBUAVu1Zz8JFdDSwlH2MT80JLu6iR/0zaWWfAzrW6P+M99wcStz1ads6LW4MHm/veQ== + x-amz-request-id: + - KQQ8B2P3ZE6A85TT + x-amz-server-side-encryption: + - AES256 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: GET + uri: https://connectapi.garmin.com/oauth-service/oauth/preauthorized?ticket=ST-2425445-xdILRhD2nZgHwz4nFxXl-cas&login-url=https://sso.garmin.com/sso/embed&accepts-mfa-tokens=true + response: + body: + string: oauth_token=SANITIZED&oauth_token_secret=SANITIZED&mfa_token=SANITIZED&mfa_expiration_timestamp=2026-05-18 + 03:54:40.000 + headers: + CF-RAY: + - 94186a23cfc83ec6-QRO + Connection: + - keep-alive + Content-Type: + - text/plain;charset=utf-8 + Date: + - Sun, 18 May 2025 03:54:41 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=63efB8UEGYNhPBRAe3GT6Rko3Qo9t38QqzHIy6y%2FRMm6hwpe29enVSzDhakFtudImbxKZ1rLeyctGLXS4MwYlizSPOctD0fAukFh%2FDvHq%2FFCdaYNjxGgfyT13wun8vG2EOLEKJDelw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +- request: + body: mfa_token=MFA-8794-oVhplm26G06rAQWyuxvCmuIJa4Nzu9nsGhqNYLJtBHQPY4UlKL-cas + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + Content-Length: + - '73' + Content-Type: + - !!binary | + YXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVk + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: POST + uri: https://connectapi.garmin.com/oauth-service/oauth/exchange/user/2.0 + response: + body: + string: '{"scope": "COMMUNITY_COURSE_READ GARMINPAY_WRITE GOLF_API_READ ATP_READ + GHS_SAMD GHS_UPLOAD INSIGHTS_READ DIVE_API_READ COMMUNITY_COURSE_WRITE CONNECT_WRITE + GCOFFER_WRITE DI_OAUTH_2_AUTHORIZATION_CODE_CREATE GARMINPAY_READ DT_CLIENT_ANALYTICS_WRITE + GOLF_API_WRITE INSIGHTS_WRITE PRODUCT_SEARCH_READ OMT_CAMPAIGN_READ OMT_SUBSCRIPTION_READ + GCOFFER_READ CONNECT_READ ATP_WRITE", "jti": "SANITIZED", "access_token": + "SANITIZED", "token_type": "bearer", "refresh_token": "SANITIZED", "expires_in": + 79915, "refresh_token_expires_in": 2591999}' + headers: + CF-RAY: + - 94186a270f975638-QRO + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Sun, 18 May 2025 03:54:41 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=glTmQjiik1yIrd7j46qIRxli1ZYtjP7QAt%2F0Umal4GM4mfXOTRGNL3JnFMuN64C4%2FRlfpPzwZxfk0zEUrFzodqwTMOrhZLrDvqjrpydpLrHU0i%2BuDo%2Fod4srxTaZ6qRiDpver8wYvw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_login_email_password_fail.yaml b/garth/tests/cassettes/test_login_email_password_fail.yaml new file mode 100644 index 0000000..196b6fd --- /dev/null +++ b/garth/tests/cassettes/test_login_email_password_fail.yaml @@ -0,0 +1,601 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + response: + body: + string: "\n\t\n\t GAuth Embedded Version\n\t \n\t \n\t\n\t\n\t\t\n\n
\n\t
\n\tERROR:
+        clientId parameter must be specified!!!\n\n\tUsage: https://sso.garmin.com/sso/embed?clientId=<clientId>&locale=<locale>...\n\n\tRequest
+        parameter configuration options:\n\n\tNAME                           REQ  VALUES
+        \                                                  DESCRIPTION\n\t------------------
+        \            ---  -------------------------------------------------------
+        \ ---------------------------------------------------------------------------------------------------\n\tclientId
+        \                      Yes  \"MY_GARMIN\"/\"BUY_GARMIN\"/\"FLY_GARMIN\"/                   Client
+        identifier for your web application\n\t                                    \"RMA\"/\"GarminConnect\"/\"OpenCaching\"/etc\n\tlocale
+        \                        Yes  \"en\", \"bg\", \"cs\", \"da\", \"de\", \"es\",
+        \"el\", \"fr\", \"hr\",    User's current locale, to display the GAuth login
+        widget internationalized properly.\n\t                                    \"in\",
+        \"it\", \"iw\", \"hu\", \"ms\", \"nb\", \"nl\", \"no\", \"pl\",    (All the
+        currently supported locales are listed in the Values section.)\n\t                                    \"pt\",
+        \"pt_BR\", \"ru\", \"sk\", \"sl\", \"fi\", \"sv\", \"tr\",\n\t                                    \"uk\",
+        \"th\", \"ja\", \"ko\", \"zh_TW\", \"zh\", \"vi_VN\"\n\tcssUrl                          No
+        \ Absolute URL to custom CSS file.                         Use custom CSS
+        styling for the GAuth login widget.\n\treauth                          No
+        \ true/false (Default value is false)                      Specify true if
+        you want to ensure that the GAuth login widget shows up,\n\t                                                                                             even
+        if the SSO infrastructure remembers the user and would immediately log them
+        in.\n\t                                                                                             This
+        is useful if you know a user is logged on, but want a different user to be
+        allowed to logon.\n\tinitialFocus                    No  true/false (Default
+        value is true)                       If you don't want the GAuth login widget
+        to autofocus in it's \"Email or Username\" field upon initial loading,\n\t
+        \                                                                                            then
+        specify this option and set it to false.\n\trememberMeShown                 No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box is shown in the GAuth login widget.\n\trememberMeChecked               No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box feature is checked by default.\n\tcreateAccountShown              No
+        \ true/false (Default value is true)                       Whether the \"Don't
+        have an account? Create One\" link is shown in the GAuth login widget.\n\tsocialEnabled
+        \                  No  true/false (Default value is false)                       If
+        set to false, do not show any social sign in elements or allow social sign
+        ins.\n\tlockToEmailAddress              No  Email address to pre-load and
+        lock.                      If specified, the specified email address will
+        be pre-loaded in the main \"Email\" field in the SSO login form,\n\t                                                                                             as
+        well as in in the \"Email Address\" field in the \"Forgot Password?\" password
+        reset form,\n\t                                                                                             and
+        both fields will be disabled so they can't be changed.\n\t                                                                                             (If
+        for some reason you want to force re-authentications for a known customer
+        account, you can make use of this option.)\n\topenCreateAccount               No
+        \ true/false (Default value is false)                      If set to true,
+        immediately display the the account creation screen.\n\tdisplayNameShown                No
+        \ true/false (Default value is false)                      If set to true,
+        show the \"Display Name\" field on the account creation screen, to allow the
+        user\n\t                                                                                             to
+        set their central MyGarmin display name upon account creation.\n\tglobalOptInShown
+        \               No  true/false (Default value is false)                      Whether
+        the \"Global Opt-In\" check box is shown on the create account & create social
+        account screens.\n\t                                                                                             If
+        set to true these screens will show a \"Sign Up For Email\" check box with
+        accompanying text\n\t                                                                                             \"I
+        would also like to receive email about promotions and new products.\"\n\t
+        \                                                                                            If
+        checked, the Customer 2.0 account that is created will have it's global opt-in
+        flag set to true,\n\t                                                                                             and
+        Garmin email communications will be allowed.\n\tglobalOptInChecked              No
+        \ true/false (Default value is false)                      Whether the \"Global
+        Opt-In\" check box is checked by default.\n\tconsumeServiceTicket            No
+        \ true/false (Default value is true)                       IF you don't specify
+        a redirectAfterAccountLoginUrl AND you set this to false, the GAuth login
+        widget\n\t                                                                                             will
+        NOT consume the service ticket assigned and will not seamlessly log you into
+        your webapp.\n\t                                                                                             It
+        will send a SUCCESS JavaScript event with the service ticket and service url
+        you can take\n\t                                                                                             and
+        explicitly validate against the SSO infrastructure yourself.\n\t                                                                                             (By
+        using casClient's SingleSignOnUtils.authenticateServiceTicket() utility method,\n\t
+        \                                                                                            or
+        calling web service customerWebServices_v1.2 AccountManagementService.authenticateServiceTicket().)\n\tmobile
+        \                         No  true/false (Default value is false)                      Setting
+        to true will cause mobile friendly views to be shown instead of the tradition
+        screens.\n\ttermsOfUseUrl                   No  Absolute URL to your custom
+        terms of use URL.            If not specified, defaults to http://www.garmin.com/terms\n\tprivacyStatementUrl
+        \            No  Absolute URL to your custom privacy statement URL.       If
+        not specified, defaults to http://www.garmin.com/privacy\n\tproductSupportUrl
+        \              No  Absolute URL to your custom product support URL.         If
+        not specified, defaults to http://www.garmin.com/us/support/contact\n\tgenerateExtraServiceTicket
+        \     No  true/false (Default value is false)                      If set
+        to true, generate an extra unconsumed service ticket.\n\t\t                                                                                     (The
+        service ticket validation response will include the extra service ticket.)\n\tgenerateTwoExtraServiceTickets
+        \ No  true/false (Default value is false)                      If set to true,
+        generate two extra unconsumed service tickets.\n\t\t\t\t\t\t\t\t\t \t\t\t
+        \    (The service ticket validation response will include the extra service
+        tickets.)\n\tgenerateNoServiceTicket         No  true/false (Default value
+        is false)                      If you don't want SSO to generate a service
+        ticket at all when logging in to the GAuth login widget.\n                                                                                                     (Useful
+        when allowing logins to static sites that are not SSO enabled and can't consume
+        the service ticket.)\n\tconnectLegalTerms               No  true/false (Default
+        value is false)                      Whether to show the connectLegalTerms
+        on the create account page\n\tshowTermsOfUse                  No  true/false
+        (Default value is false)                      Whether to show the showTermsOfUse
+        on the create account page\n\tshowPrivacyPolicy               No  true/false
+        (Default value is false)                      Whether to show the showPrivacyPolicy
+        on the create account page\n\tshowConnectLegalAge             No  true/false
+        (Default value is false)                      Whether to show the showConnectLegalAge
+        on the create account page\n\tlocationPromptShown             No  true/false
+        (Default value is false)                      If set to true, ask the customer
+        during account creation to verify their country of residence.\n\tshowPassword
+        \                   No  true/false (Default value is true)                       If
+        set to false, mobile version for createAccount and login screens would hide
+        the password\n\tuseCustomHeader                 No  true/false (Default value
+        is false)                      If set to true, the \"Sign in\" text will be
+        replaced by custom text. Contact CDS team to set the i18n text for your client
+        id.\n\tmfaRequired                     No  true/false (Default value is false)
+        \                     Require multi factor authentication for all authenticating
+        users.\n\tperformMFACheck                 No  true/false (Default value is
+        false)                      If set to true, ask the logged in user to pass
+        a multi factor authentication check. (Only valid for an already logged in
+        user.)\n\trememberMyBrowserShown          No  true/false (Default value is
+        false)                      Whether the \"Remember My Browser\" check box
+        is shown in the GAuth login widget MFA verification screen.\n\trememberMyBrowserChecked
+        \       No  true/false (Default value is false)                      Whether
+        the \"Remember My Browser\" check box feature is checked by default.\n\tconsentTypeIds\t\t\t\t\tNo\tconsent_types
+        ids\t\t \t\t\t\t\t\t\t\t multiple consent types ids can be passed as consentTypeIds=type1&consentTypeIds=type2\n\t
\n
\n\n\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ab8a0eff61559-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:53:41 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=j5pKqMzrTlGTnexO0FnuZsm0YObQFg1OH0auGBikdNQ44TMOIITdLtHmkIg36gVUZ65RQe4mMPXUL0SfZUdBcVPtg%2F3Dr3d4GgcIueMqtynkohsWR86sKXRVMZroPe%2Fp"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cf_bm=SANITIZED; path=SANITIZED; expires=SANITIZED; domain=SANITIZED; HttpOnly; + Secure; SameSite=SANITIZED + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:6 + X-B3-Traceid: + - 3d744417e02674885d3c4741abc1daad + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - d62a3e74-b259-4a55-437a-2635831aa9f2 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - __cf_bm=SANITIZED; _cfuvid=SANITIZED; __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + method: GET + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n \n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 7f1ab8a1e90a155f-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:53:41 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=2m3IsPHrodwZcDphNIdQkuKtFDRIq67h9%2BNyhtturCTJsq8UH%2BqzYY1lhYjgkKLu0YrwD8sYfVBP03Dj8Lf4R0Ghzc0o647YHYroy2Tkp2YQLDOtMwR56XKEVYEl0yhg"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - SESSION=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - __VCAP_ID__=SANITIZED; Path=SANITIZED; HttpOnly; Secure + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:5 + X-B3-Traceid: + - 5ebef167e205ed0449ddea900e2d06fc + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 8bb46b1b-d486-4df3-5d3e-2767045abcdd + status: + code: 200 + message: OK +- request: + body: username=SANITIZED&password=SANITIZED&embed=true&_csrf=DAA89CB8362ABB6DB2548101BE44A857AFCE1CC8C7B0825A54361D5D1FB60E47649DA070B388D04CB797C2AD4C9B9FAF9E3C + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '171' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; __VCAP_ID__=SANITIZED; + __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n
Invalid sign in. (Passwords are case sensitive.)
\n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 7f1ab8a41e554752-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:53:42 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=NmXSOa2OY4MXHw09DrfMkMUFE5FijBSW8oF9uituKDizIcYfhS1rFKYV0Q3ACOQVYT6Q8Iwzj6PiIL%2BBY6E4f%2BFqsB2a20zfVAiW65WDXm6hGdPkJozBoAfyFzQZzAOc"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cfruid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:5 + X-B3-Traceid: + - 139f06d066cf2a2d4b988ae89e0203d7 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - b2849c1b-b909-403f-57b6-e13f20fc9546 + status: + code: 401 + message: Unauthorized +version: 1 diff --git a/garth/tests/cassettes/test_login_mfa_fail.yaml b/garth/tests/cassettes/test_login_mfa_fail.yaml new file mode 100644 index 0000000..717d011 --- /dev/null +++ b/garth/tests/cassettes/test_login_mfa_fail.yaml @@ -0,0 +1,749 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + response: + body: + string: "\n\t\n\t GAuth Embedded Version\n\t \n\t \n\t\n\t\n\t\t\n\n
\n\t
\n\tERROR:
+        clientId parameter must be specified!!!\n\n\tUsage: https://sso.garmin.com/sso/embed?clientId=<clientId>&locale=<locale>...\n\n\tRequest
+        parameter configuration options:\n\n\tNAME                           REQ  VALUES
+        \                                                  DESCRIPTION\n\t------------------
+        \            ---  -------------------------------------------------------
+        \ ---------------------------------------------------------------------------------------------------\n\tclientId
+        \                      Yes  \"MY_GARMIN\"/\"BUY_GARMIN\"/\"FLY_GARMIN\"/                   Client
+        identifier for your web application\n\t                                    \"RMA\"/\"GarminConnect\"/\"OpenCaching\"/etc\n\tlocale
+        \                        Yes  \"en\", \"bg\", \"cs\", \"da\", \"de\", \"es\",
+        \"el\", \"fr\", \"hr\",    User's current locale, to display the GAuth login
+        widget internationalized properly.\n\t                                    \"in\",
+        \"it\", \"iw\", \"hu\", \"ms\", \"nb\", \"nl\", \"no\", \"pl\",    (All the
+        currently supported locales are listed in the Values section.)\n\t                                    \"pt\",
+        \"pt_BR\", \"ru\", \"sk\", \"sl\", \"fi\", \"sv\", \"tr\",\n\t                                    \"uk\",
+        \"th\", \"ja\", \"ko\", \"zh_TW\", \"zh\", \"vi_VN\"\n\tcssUrl                          No
+        \ Absolute URL to custom CSS file.                         Use custom CSS
+        styling for the GAuth login widget.\n\treauth                          No
+        \ true/false (Default value is false)                      Specify true if
+        you want to ensure that the GAuth login widget shows up,\n\t                                                                                             even
+        if the SSO infrastructure remembers the user and would immediately log them
+        in.\n\t                                                                                             This
+        is useful if you know a user is logged on, but want a different user to be
+        allowed to logon.\n\tinitialFocus                    No  true/false (Default
+        value is true)                       If you don't want the GAuth login widget
+        to autofocus in it's \"Email or Username\" field upon initial loading,\n\t
+        \                                                                                            then
+        specify this option and set it to false.\n\trememberMeShown                 No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box is shown in the GAuth login widget.\n\trememberMeChecked               No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box feature is checked by default.\n\tcreateAccountShown              No
+        \ true/false (Default value is true)                       Whether the \"Don't
+        have an account? Create One\" link is shown in the GAuth login widget.\n\tsocialEnabled
+        \                  No  true/false (Default value is false)                       If
+        set to false, do not show any social sign in elements or allow social sign
+        ins.\n\tlockToEmailAddress              No  Email address to pre-load and
+        lock.                      If specified, the specified email address will
+        be pre-loaded in the main \"Email\" field in the SSO login form,\n\t                                                                                             as
+        well as in in the \"Email Address\" field in the \"Forgot Password?\" password
+        reset form,\n\t                                                                                             and
+        both fields will be disabled so they can't be changed.\n\t                                                                                             (If
+        for some reason you want to force re-authentications for a known customer
+        account, you can make use of this option.)\n\topenCreateAccount               No
+        \ true/false (Default value is false)                      If set to true,
+        immediately display the the account creation screen.\n\tdisplayNameShown                No
+        \ true/false (Default value is false)                      If set to true,
+        show the \"Display Name\" field on the account creation screen, to allow the
+        user\n\t                                                                                             to
+        set their central MyGarmin display name upon account creation.\n\tglobalOptInShown
+        \               No  true/false (Default value is false)                      Whether
+        the \"Global Opt-In\" check box is shown on the create account & create social
+        account screens.\n\t                                                                                             If
+        set to true these screens will show a \"Sign Up For Email\" check box with
+        accompanying text\n\t                                                                                             \"I
+        would also like to receive email about promotions and new products.\"\n\t
+        \                                                                                            If
+        checked, the Customer 2.0 account that is created will have it's global opt-in
+        flag set to true,\n\t                                                                                             and
+        Garmin email communications will be allowed.\n\tglobalOptInChecked              No
+        \ true/false (Default value is false)                      Whether the \"Global
+        Opt-In\" check box is checked by default.\n\tconsumeServiceTicket            No
+        \ true/false (Default value is true)                       IF you don't specify
+        a redirectAfterAccountLoginUrl AND you set this to false, the GAuth login
+        widget\n\t                                                                                             will
+        NOT consume the service ticket assigned and will not seamlessly log you into
+        your webapp.\n\t                                                                                             It
+        will send a SUCCESS JavaScript event with the service ticket and service url
+        you can take\n\t                                                                                             and
+        explicitly validate against the SSO infrastructure yourself.\n\t                                                                                             (By
+        using casClient's SingleSignOnUtils.authenticateServiceTicket() utility method,\n\t
+        \                                                                                            or
+        calling web service customerWebServices_v1.2 AccountManagementService.authenticateServiceTicket().)\n\tmobile
+        \                         No  true/false (Default value is false)                      Setting
+        to true will cause mobile friendly views to be shown instead of the tradition
+        screens.\n\ttermsOfUseUrl                   No  Absolute URL to your custom
+        terms of use URL.            If not specified, defaults to http://www.garmin.com/terms\n\tprivacyStatementUrl
+        \            No  Absolute URL to your custom privacy statement URL.       If
+        not specified, defaults to http://www.garmin.com/privacy\n\tproductSupportUrl
+        \              No  Absolute URL to your custom product support URL.         If
+        not specified, defaults to http://www.garmin.com/us/support/contact\n\tgenerateExtraServiceTicket
+        \     No  true/false (Default value is false)                      If set
+        to true, generate an extra unconsumed service ticket.\n\t\t                                                                                     (The
+        service ticket validation response will include the extra service ticket.)\n\tgenerateTwoExtraServiceTickets
+        \ No  true/false (Default value is false)                      If set to true,
+        generate two extra unconsumed service tickets.\n\t\t\t\t\t\t\t\t\t \t\t\t
+        \    (The service ticket validation response will include the extra service
+        tickets.)\n\tgenerateNoServiceTicket         No  true/false (Default value
+        is false)                      If you don't want SSO to generate a service
+        ticket at all when logging in to the GAuth login widget.\n                                                                                                     (Useful
+        when allowing logins to static sites that are not SSO enabled and can't consume
+        the service ticket.)\n\tconnectLegalTerms               No  true/false (Default
+        value is false)                      Whether to show the connectLegalTerms
+        on the create account page\n\tshowTermsOfUse                  No  true/false
+        (Default value is false)                      Whether to show the showTermsOfUse
+        on the create account page\n\tshowPrivacyPolicy               No  true/false
+        (Default value is false)                      Whether to show the showPrivacyPolicy
+        on the create account page\n\tshowConnectLegalAge             No  true/false
+        (Default value is false)                      Whether to show the showConnectLegalAge
+        on the create account page\n\tlocationPromptShown             No  true/false
+        (Default value is false)                      If set to true, ask the customer
+        during account creation to verify their country of residence.\n\tshowPassword
+        \                   No  true/false (Default value is true)                       If
+        set to false, mobile version for createAccount and login screens would hide
+        the password\n\tuseCustomHeader                 No  true/false (Default value
+        is false)                      If set to true, the \"Sign in\" text will be
+        replaced by custom text. Contact CDS team to set the i18n text for your client
+        id.\n\tmfaRequired                     No  true/false (Default value is false)
+        \                     Require multi factor authentication for all authenticating
+        users.\n\tperformMFACheck                 No  true/false (Default value is
+        false)                      If set to true, ask the logged in user to pass
+        a multi factor authentication check. (Only valid for an already logged in
+        user.)\n\trememberMyBrowserShown          No  true/false (Default value is
+        false)                      Whether the \"Remember My Browser\" check box
+        is shown in the GAuth login widget MFA verification screen.\n\trememberMyBrowserChecked
+        \       No  true/false (Default value is false)                      Whether
+        the \"Remember My Browser\" check box feature is checked by default.\n\tconsentTypeIds\t\t\t\t\tNo\tconsent_types
+        ids\t\t \t\t\t\t\t\t\t\t multiple consent types ids can be passed as consentTypeIds=type1&consentTypeIds=type2\n\t
\n
\n\n\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-RAY: + - 949c83cf2bfb5e42-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Tue, 03 Jun 2025 04:40:52 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=cwd6V1kar7GXC7ImUBfvrwg3vgZw4sMdraKN0bkZjRt%2Bsu4gSDU%2Bv0N%2BSUhVzY7ZkTgMTuIkEmTRl7ywQ5Z%2FAD3BUh03xdXX%2B2qCgU0plnOrl93fBAlMcDC9U%2FMRzoHW"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cf_bm=SANITIZED; path=SANITIZED; expires=SANITIZED; domain=SANITIZED; HttpOnly; + Secure; SameSite=SANITIZED + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:3 + X-B3-Traceid: + - 85cea212845648ad7fbb7b5ad97acb70 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 85cea212-8456-48ad-7fbb-7b5ad97acb70 + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + method: GET + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n \n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 949c83d17d414f14-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Tue, 03 Jun 2025 04:40:52 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=REffANT2%2FfOZY9xYp%2FXinxsCOsc73u6TBWc0qVetJyK9oQhy63N6Qk3fNr5TDiEV9JM9RIKw5uZhoVeBr7vDZK1f0UsNdTsjHdr19V0Lnt%2FCqbU6Y3MTWpcTaQYMqUIo"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - SESSION=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - __VCAP_ID__=SANITIZED; Path=SANITIZED; HttpOnly; Secure + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:6 + X-B3-Traceid: + - 77e60c0ac1d641c074820aac41fbde80 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 77e60c0a-c1d6-41c0-7482-0aac41fbde80 + status: + code: 200 + message: OK +- request: + body: username=SANITIZED&password=SANITIZED&embed=true&_csrf=90280BE13709DE2C0CF38CAB2A77E3FC82F62894F2396D07630AD246706B197735797D02C4592A6D5AB3B8BF1F3B80460522 + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Content-Length: + - '177' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 949c83d32cf657bd-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Tue, 03 Jun 2025 04:40:54 GMT + Location: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=8rQsZTg41dTwDgWNQriYHPcbY3UG6NQ0v%2FN6zaizxXzpDFLJALfe7s%2BopIWHB0dvU9WeEEUreQPI2Wlkgz2Gp6z9fx51UvQZtS3N2hIGKyEW7QNno8eCyuMyHYGXjJOx"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cfruid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:6 + X-B3-Traceid: + - 1da874cc48894fdf4e1ac9d9e8e269c8 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 1da874cc-4889-4fdf-4e1a-c9d9e8e269c8 + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n\n\n \n + \ \n \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n \n Enter + MFA code for login\n \n + \ \n + \ \n \n \n \n\n\n\n
\n

Enter + security code

\n \n \n\n + \
\n
\n \n \n + \ Code sent to mt*****@gmail.com\n + \ \n
\n + \
\n
\n \n \n \n + \ \n \n \n
\n + \
\n
\n \n
\n + \
\n

\n
\n + \ Get help
\n
\n + \
\n + \ Request a new code\n + \
\n \n \n + \
\n \n
\n + \ \n
\n \n \n \n + \
\n
\n
\n
\n
\n
\n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-RAY: + - 949c83da2a5ac1ca-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Tue, 03 Jun 2025 04:40:54 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=BrVkK9BHKPEC700UIxYqeYMAufPXrsMtXb56Z5naqivj9pfj%2FKyqvweC0oLp4v4n%2BecNLLGdP4o5WUnke2Iu62u0i0gzh9hqR49I8mYeEw6ABEfR8ZFJbx0waSuNNous"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:6 + X-B3-Traceid: + - acd069da786e436a7d98ba4e5220bcfc + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - acd069da-786e-436a-7d98-ba4e5220bcfc + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +- request: + body: mfa-code=123456&embed=true&_csrf=9AF199177EE70FB2511C2DE25FE2780DEF8327EDCA5AB81C391FAF6E419E83EDF20E1EE31B76E282D8AA46124E3DC5EB1391&fromPage=setupEnterMfaCode + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Content-Length: + - '160' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n\n\n \n + \ \n \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n \n Enter + MFA code for login\n \n + \ \n + \ \n \n \n \n\n\n\n
\n

Enter + security code

\n \n \n\n + \
\n
\n \n \n + \ Code sent to mt*****@gmail.com\n + \ \n
\n + \
\n
\n \n \n
Invalid code. Please enter a valid code.
\n + \ \n \n \n
\n + \
\n
\n \n
\n + \
\n

\n
\n + \ Get help
\n
\n + \
\n + \ Request a new code\n + \
\n \n \n + \
\n \n
\n + \ \n
\n \n \n \n + \
\n
\n
\n
\n
\n
\n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-RAY: + - 949c83dc9aa555c3-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Tue, 03 Jun 2025 04:40:54 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=WVjXMWAY7m%2FICrofTUaszDZoZ1kIv1%2BQTcx49UDCpdhESBjLNt9LucYPatIj%2BHOhRkqNPuM%2F65Tz1kTrR4naiCX0yEAOcMcEAh1yxyiX%2BlU7qvovsvWodipj8YHB19mH"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:6 + X-B3-Traceid: + - 104ac62c483244cf73fb9266e97d22bb + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 104ac62c-4832-44cf-73fb-9266e97d22bb + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_login_return_on_mfa.yaml b/garth/tests/cassettes/test_login_return_on_mfa.yaml new file mode 100644 index 0000000..d2e0f24 --- /dev/null +++ b/garth/tests/cassettes/test_login_return_on_mfa.yaml @@ -0,0 +1,1017 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + response: + body: + string: "\n\t\n\t GAuth Embedded Version\n\t \n\t \n\t\n\t\n\t\t\n\n
\n\t
\n\tERROR:
+        clientId parameter must be specified!!!\n\n\tUsage: https://sso.garmin.com/sso/embed?clientId=<clientId>&locale=<locale>...\n\n\tRequest
+        parameter configuration options:\n\n\tNAME                           REQ  VALUES
+        \                                                  DESCRIPTION\n\t------------------
+        \            ---  -------------------------------------------------------
+        \ ---------------------------------------------------------------------------------------------------\n\tclientId
+        \                      Yes  \"MY_GARMIN\"/\"BUY_GARMIN\"/\"FLY_GARMIN\"/                   Client
+        identifier for your web application\n\t                                    \"RMA\"/\"GarminConnect\"/\"OpenCaching\"/etc\n\tlocale
+        \                        Yes  \"en\", \"bg\", \"cs\", \"da\", \"de\", \"es\",
+        \"el\", \"fr\", \"hr\",    User's current locale, to display the GAuth login
+        widget internationalized properly.\n\t                                    \"in\",
+        \"it\", \"iw\", \"hu\", \"ms\", \"nb\", \"nl\", \"no\", \"pl\",    (All the
+        currently supported locales are listed in the Values section.)\n\t                                    \"pt\",
+        \"pt_BR\", \"ru\", \"sk\", \"sl\", \"fi\", \"sv\", \"tr\",\n\t                                    \"uk\",
+        \"th\", \"ja\", \"ko\", \"zh_TW\", \"zh\", \"vi_VN\"\n\tcssUrl                          No
+        \ Absolute URL to custom CSS file.                         Use custom CSS
+        styling for the GAuth login widget.\n\treauth                          No
+        \ true/false (Default value is false)                      Specify true if
+        you want to ensure that the GAuth login widget shows up,\n\t                                                                                             even
+        if the SSO infrastructure remembers the user and would immediately log them
+        in.\n\t                                                                                             This
+        is useful if you know a user is logged on, but want a different user to be
+        allowed to logon.\n\tinitialFocus                    No  true/false (Default
+        value is true)                       If you don't want the GAuth login widget
+        to autofocus in it's \"Email or Username\" field upon initial loading,\n\t
+        \                                                                                            then
+        specify this option and set it to false.\n\trememberMeShown                 No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box is shown in the GAuth login widget.\n\trememberMeChecked               No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box feature is checked by default.\n\tcreateAccountShown              No
+        \ true/false (Default value is true)                       Whether the \"Don't
+        have an account? Create One\" link is shown in the GAuth login widget.\n\tsocialEnabled
+        \                  No  true/false (Default value is false)                       If
+        set to false, do not show any social sign in elements or allow social sign
+        ins.\n\tlockToEmailAddress              No  Email address to pre-load and
+        lock.                      If specified, the specified email address will
+        be pre-loaded in the main \"Email\" field in the SSO login form,\n\t                                                                                             as
+        well as in in the \"Email Address\" field in the \"Forgot Password?\" password
+        reset form,\n\t                                                                                             and
+        both fields will be disabled so they can't be changed.\n\t                                                                                             (If
+        for some reason you want to force re-authentications for a known customer
+        account, you can make use of this option.)\n\topenCreateAccount               No
+        \ true/false (Default value is false)                      If set to true,
+        immediately display the the account creation screen.\n\tdisplayNameShown                No
+        \ true/false (Default value is false)                      If set to true,
+        show the \"Display Name\" field on the account creation screen, to allow the
+        user\n\t                                                                                             to
+        set their central MyGarmin display name upon account creation.\n\tglobalOptInShown
+        \               No  true/false (Default value is false)                      Whether
+        the \"Global Opt-In\" check box is shown on the create account & create social
+        account screens.\n\t                                                                                             If
+        set to true these screens will show a \"Sign Up For Email\" check box with
+        accompanying text\n\t                                                                                             \"I
+        would also like to receive email about promotions and new products.\"\n\t
+        \                                                                                            If
+        checked, the Customer 2.0 account that is created will have it's global opt-in
+        flag set to true,\n\t                                                                                             and
+        Garmin email communications will be allowed.\n\tglobalOptInChecked              No
+        \ true/false (Default value is false)                      Whether the \"Global
+        Opt-In\" check box is checked by default.\n\tconsumeServiceTicket            No
+        \ true/false (Default value is true)                       IF you don't specify
+        a redirectAfterAccountLoginUrl AND you set this to false, the GAuth login
+        widget\n\t                                                                                             will
+        NOT consume the service ticket assigned and will not seamlessly log you into
+        your webapp.\n\t                                                                                             It
+        will send a SUCCESS JavaScript event with the service ticket and service url
+        you can take\n\t                                                                                             and
+        explicitly validate against the SSO infrastructure yourself.\n\t                                                                                             (By
+        using casClient's SingleSignOnUtils.authenticateServiceTicket() utility method,\n\t
+        \                                                                                            or
+        calling web service customerWebServices_v1.2 AccountManagementService.authenticateServiceTicket().)\n\tmobile
+        \                         No  true/false (Default value is false)                      Setting
+        to true will cause mobile friendly views to be shown instead of the tradition
+        screens.\n\ttermsOfUseUrl                   No  Absolute URL to your custom
+        terms of use URL.            If not specified, defaults to http://www.garmin.com/terms\n\tprivacyStatementUrl
+        \            No  Absolute URL to your custom privacy statement URL.       If
+        not specified, defaults to http://www.garmin.com/privacy\n\tproductSupportUrl
+        \              No  Absolute URL to your custom product support URL.         If
+        not specified, defaults to http://www.garmin.com/us/support/contact\n\tgenerateExtraServiceTicket
+        \     No  true/false (Default value is false)                      If set
+        to true, generate an extra unconsumed service ticket.\n\t\t                                                                                     (The
+        service ticket validation response will include the extra service ticket.)\n\tgenerateTwoExtraServiceTickets
+        \ No  true/false (Default value is false)                      If set to true,
+        generate two extra unconsumed service tickets.\n\t\t\t\t\t\t\t\t\t \t\t\t
+        \    (The service ticket validation response will include the extra service
+        tickets.)\n\tgenerateNoServiceTicket         No  true/false (Default value
+        is false)                      If you don't want SSO to generate a service
+        ticket at all when logging in to the GAuth login widget.\n                                                                                                     (Useful
+        when allowing logins to static sites that are not SSO enabled and can't consume
+        the service ticket.)\n\tconnectLegalTerms               No  true/false (Default
+        value is false)                      Whether to show the connectLegalTerms
+        on the create account page\n\tshowTermsOfUse                  No  true/false
+        (Default value is false)                      Whether to show the showTermsOfUse
+        on the create account page\n\tshowPrivacyPolicy               No  true/false
+        (Default value is false)                      Whether to show the showPrivacyPolicy
+        on the create account page\n\tshowConnectLegalAge             No  true/false
+        (Default value is false)                      Whether to show the showConnectLegalAge
+        on the create account page\n\tlocationPromptShown             No  true/false
+        (Default value is false)                      If set to true, ask the customer
+        during account creation to verify their country of residence.\n\tshowPassword
+        \                   No  true/false (Default value is true)                       If
+        set to false, mobile version for createAccount and login screens would hide
+        the password\n\tuseCustomHeader                 No  true/false (Default value
+        is false)                      If set to true, the \"Sign in\" text will be
+        replaced by custom text. Contact CDS team to set the i18n text for your client
+        id.\n\tmfaRequired                     No  true/false (Default value is false)
+        \                     Require multi factor authentication for all authenticating
+        users.\n\tperformMFACheck                 No  true/false (Default value is
+        false)                      If set to true, ask the logged in user to pass
+        a multi factor authentication check. (Only valid for an already logged in
+        user.)\n\trememberMyBrowserShown          No  true/false (Default value is
+        false)                      Whether the \"Remember My Browser\" check box
+        is shown in the GAuth login widget MFA verification screen.\n\trememberMyBrowserChecked
+        \       No  true/false (Default value is false)                      Whether
+        the \"Remember My Browser\" check box feature is checked by default.\n\tconsentTypeIds\t\t\t\t\tNo\tconsent_types
+        ids\t\t \t\t\t\t\t\t\t\t multiple consent types ids can be passed as consentTypeIds=type1&consentTypeIds=type2\n\t
\n
\n\n\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8f03e2cc5bdab6df-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Wed, 11 Dec 2024 07:50:49 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=Puezu%2BVdH9JIb%2B2NvX57aGY2GEiBZuFrX2T0Std5%2FzkX8e0X%2BAqfhQ%2FsJ7C27cYXcK%2F6DNHv4SAwemmm0i7ZPcJLYrTj2vS2LGN91xWkq4%2BXMRsZfKGxomSM1gya2GGO"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cf_bm=SANITIZED; path=SANITIZED; expires=SANITIZED; domain=SANITIZED; HttpOnly; + Secure; SameSite=SANITIZED + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:2 + X-B3-Traceid: + - 707927fb58c44d44526f283f17ff87ef + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 707927fb-58c4-4d44-526f-283f17ff87ef + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + method: GET + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n \n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 8f03e2cf4ba0b6e7-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Wed, 11 Dec 2024 07:50:49 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=T46elug27MoZ2iqKBAAKcijwtJBfnKoKVn%2BWnJh5asgBRlmDbuFudS8NqTJHsJQDzq8opwhlDBSxe%2BbuSN2L3oNidiAVmHdDNZh8SHp9%2Bsx7ELg1%2BJX1MIVus2SspNJC"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - SESSION=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - __VCAP_ID__=SANITIZED; Path=SANITIZED; HttpOnly; Secure + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:5 + X-B3-Traceid: + - 0ec83ff3eaac47f14c830dfeb5dcefd4 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 0ec83ff3-eaac-47f1-4c83-0dfeb5dcefd4 + status: + code: 200 + message: OK +- request: + body: username=SANITIZED&password=SANITIZED&embed=true&_csrf=DD6F770AC6B4F2FE813E32CBDCFFE6C6E5A7B73A832E25F1EB2998BA80990A269BD50E938C2062E8EEFED2FCE2228680F058 + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '177' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 8f03e2d268c86b11-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Wed, 11 Dec 2024 07:50:51 GMT + Location: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=LK7lsEzUKTbHnWj9qIE1R8fQ%2BkjgwAVfczJ5bWWimx8nMVZ8pKDj3SOB6yyENkB9hUZK0ABqjvtENDvY1eqYOil82MQMrm0C7tpDYy%2BgEij99ZQjYhqrkD1sRXcbSS8K"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cfruid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:5 + X-B3-Traceid: + - 7268da1f0b35422b6b5e01f2891186e6 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 7268da1f-0b35-422b-6b5e-01f2891186e6 + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n\n\n \n + \ \n \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n \n Enter + MFA code for login\n \n + \ \n + \ \n \n \n \n\n\n\n
\n

Enter + security code

\n \n \n\n + \
\n
\n \n \n + \ Code sent to mt*****@gmail.com\n + \ \n
\n + \
\n
\n \n \n \n + \ \n \n \n
\n + \
\n
\n \n
\n + \
\n

\n
\n + \ Get help
\n
\n + \
\n + \ Request a new code\n + \
\n \n \n + \
\n \n
\n + \ \n
\n \n \n \n + \
\n
\n
\n
\n
\n
\n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8f03e2db3e836c32-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Wed, 11 Dec 2024 07:50:51 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=69a5yve42wg%2Fug%2BUJKJZGapiftAp0V3ssRMcsTBGBjRd71dOeXiN%2B84LrE%2BmBpsqE0qCzO%2BcSui9Mj5sJCmZl4mNf2Y%2B80evi5y8aQL47J3zOjAs1zBGhHDW8F7t%2F6Q4"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:5 + X-B3-Traceid: + - ba933ac91e6f46c2773ab14761f2dbb8 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - ba933ac9-1e6f-46c2-773a-b14761f2dbb8 + status: + code: 200 + message: OK +- request: + body: mfa-code=243715&embed=true&_csrf=DD6F770AC6B4F2FE813E32CBDCFFE6C6E5A7B73A832E25F1EB2998BA80990A269BD50E938C2062E8EEFED2FCE2228680F058&fromPage=setupEnterMfaCode + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '160' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8f03e32168126bcc-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Wed, 11 Dec 2024 07:51:03 GMT + Location: + - https://sso.garmin.com/sso/login?logintoken=4vE3601wYS&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=S8A1ygrdQh1s71kF8O2MaekU525HIH5aWxRgRRD3d7gXIDO6CWr8w1%2Bv%2BJbnkUQYMn6pHjhmENYFayncUWl07bzzshYdNsqrkSXheXCiM1rkv4SVcaFpJGiDVZ2NFQxZ"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:5 + X-B3-Traceid: + - 78e9ad92788a45e2707e19040336bcfe + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 78e9ad92-788a-45e2-707e-19040336bcfe + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/login?logintoken=4vE3601wYS&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + response: + body: + string: "\n\n\t\n\t\tSuccess\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\n\t\n\t\t
\n\t\t\t\n\t\t
\n\t\t\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 8f03e328aaf26c2e-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Wed, 11 Dec 2024 07:51:04 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=Itl9hSd%2FmfO1zgpDz%2BzEwc3AQfKRrK%2BQgJoJlO7wP%2BcwF0CVBbnf1dDxL55MMXRHdfkBJL56X%2B6RezMkac9imgafMJZQi5%2Fk4wOFY6YA5eiF25Ip0Vqb1kFXDYH%2F%2BNFu"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + - GARMIN-SSO=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GarminNoCache=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GarminNoCache=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GARMIN-SSO-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GARMIN-SSO-CUST-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO-CUST-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_Olathe:5 + X-B3-Traceid: + - ee9e2564bcce49624d5254589b64b0f7 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - ee9e2564-bcce-4962-4d52-54589b64b0f7 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - python-requests/2.32.3 + method: GET + uri: https://thegarth.s3.amazonaws.com/oauth_consumer.json + response: + body: + string: '{"consumer_key": "SANITIZED", "consumer_secret": "SANITIZED"}' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '124' + Content-Type: + - application/json + Date: + - Wed, 11 Dec 2024 07:51:05 GMT + ETag: + - '"20240b1013cb35419bb5b2cff1407a4e"' + Last-Modified: + - Thu, 03 Aug 2023 00:16:11 GMT + Server: + - AmazonS3 + x-amz-id-2: + - s3pVFN2F1v75yAgvx1/ZvXKtn4CFgJU2hxDUZP6INxj8pGlMW+A4ms3jzJERG5obLkougEbN+QcN1Ko8dtopNrPu7Vw0XewgzWSVJN7PsUU= + x-amz-request-id: + - W7VC86WPXD70NJA0 + x-amz-server-side-encryption: + - AES256 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: GET + uri: https://connectapi.garmin.com/oauth-service/oauth/preauthorized?ticket=ST-01343161-FXXpWgghlgF1mqZqlwsM-cas&login-url=https://sso.garmin.com/sso/embed&accepts-mfa-tokens=true + response: + body: + string: oauth_token=SANITIZED&oauth_token_secret=SANITIZED&mfa_token=SANITIZED&mfa_expiration_timestamp=2025-12-11 + 07:51:04.000 + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8f03e32f3cc36b59-DFW + Connection: + - keep-alive + Content-Type: + - text/plain;charset=utf-8 + Date: + - Wed, 11 Dec 2024 07:51:05 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=h%2Bq3jCaVrmy6KAj9ICaLlbooW0SAd9HkgD5NMy6KzVnuDWr10Hwg4et36M4nnfSQdkq2HndhQtRlrajTPbamwQJm53xei1BVmXeYVdDLBQF9wcopqMtU%2FDYRwcRkNjP0fVq44pA4ig%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + status: + code: 200 + message: OK +- request: + body: mfa_token=MFA-14124-SX2AMCGswvbn0nvztdszPL0XaUSCHLtfPldUKlADPb1MhoPSKq-cas + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + Content-Length: + - '74' + Content-Type: + - !!binary | + YXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVk + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: POST + uri: https://connectapi.garmin.com/oauth-service/oauth/exchange/user/2.0 + response: + body: + string: '{"scope": "COMMUNITY_COURSE_READ GARMINPAY_WRITE GOLF_API_READ ATP_READ + GHS_SAMD GHS_UPLOAD INSIGHTS_READ COMMUNITY_COURSE_WRITE CONNECT_WRITE GCOFFER_WRITE + GARMINPAY_READ DT_CLIENT_ANALYTICS_WRITE GOLF_API_WRITE INSIGHTS_WRITE PRODUCT_SEARCH_READ + OMT_CAMPAIGN_READ OMT_SUBSCRIPTION_READ GCOFFER_READ CONNECT_READ ATP_WRITE", + "jti": "SANITIZED", "access_token": "SANITIZED", "token_type": "Bearer", "refresh_token": + "SANITIZED", "expires_in": 106068, "refresh_token_expires_in": 2591999}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8f03e332baa56c79-DFW + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Wed, 11 Dec 2024 07:51:06 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=eeRTFcqJTduIbdcZwq8YbTTRUGqmdqt1Oq%2BJLMCdjzo5UVT4aAp1T%2FCLD94NtAViOXKshlPxo7ZsJ6LTOUvIsEh3q7H2e59WyXd3spqGw8kift8aJ0SAdSKCcl0J87Yu8sfrQ4pLkA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_login_success.yaml b/garth/tests/cassettes/test_login_success.yaml new file mode 100644 index 0000000..3773cee --- /dev/null +++ b/garth/tests/cassettes/test_login_success.yaml @@ -0,0 +1,760 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + response: + body: + string: "\n\t\n\t GAuth Embedded Version\n\t \n\t \n\t\n\t\n\t\t\n\n
\n\t
\n\tERROR:
+        clientId parameter must be specified!!!\n\n\tUsage: https://sso.garmin.com/sso/embed?clientId=<clientId>&locale=<locale>...\n\n\tRequest
+        parameter configuration options:\n\n\tNAME                           REQ  VALUES
+        \                                                  DESCRIPTION\n\t------------------
+        \            ---  -------------------------------------------------------
+        \ ---------------------------------------------------------------------------------------------------\n\tclientId
+        \                      Yes  \"MY_GARMIN\"/\"BUY_GARMIN\"/\"FLY_GARMIN\"/                   Client
+        identifier for your web application\n\t                                    \"RMA\"/\"GarminConnect\"/\"OpenCaching\"/etc\n\tlocale
+        \                        Yes  \"en\", \"bg\", \"cs\", \"da\", \"de\", \"es\",
+        \"el\", \"fr\", \"hr\",    User's current locale, to display the GAuth login
+        widget internationalized properly.\n\t                                    \"in\",
+        \"it\", \"iw\", \"hu\", \"ms\", \"nb\", \"nl\", \"no\", \"pl\",    (All the
+        currently supported locales are listed in the Values section.)\n\t                                    \"pt\",
+        \"pt_BR\", \"ru\", \"sk\", \"sl\", \"fi\", \"sv\", \"tr\",\n\t                                    \"uk\",
+        \"th\", \"ja\", \"ko\", \"zh_TW\", \"zh\", \"vi_VN\"\n\tcssUrl                          No
+        \ Absolute URL to custom CSS file.                         Use custom CSS
+        styling for the GAuth login widget.\n\treauth                          No
+        \ true/false (Default value is false)                      Specify true if
+        you want to ensure that the GAuth login widget shows up,\n\t                                                                                             even
+        if the SSO infrastructure remembers the user and would immediately log them
+        in.\n\t                                                                                             This
+        is useful if you know a user is logged on, but want a different user to be
+        allowed to logon.\n\tinitialFocus                    No  true/false (Default
+        value is true)                       If you don't want the GAuth login widget
+        to autofocus in it's \"Email or Username\" field upon initial loading,\n\t
+        \                                                                                            then
+        specify this option and set it to false.\n\trememberMeShown                 No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box is shown in the GAuth login widget.\n\trememberMeChecked               No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box feature is checked by default.\n\tcreateAccountShown              No
+        \ true/false (Default value is true)                       Whether the \"Don't
+        have an account? Create One\" link is shown in the GAuth login widget.\n\tsocialEnabled
+        \                  No  true/false (Default value is false)                       If
+        set to false, do not show any social sign in elements or allow social sign
+        ins.\n\tlockToEmailAddress              No  Email address to pre-load and
+        lock.                      If specified, the specified email address will
+        be pre-loaded in the main \"Email\" field in the SSO login form,\n\t                                                                                             as
+        well as in in the \"Email Address\" field in the \"Forgot Password?\" password
+        reset form,\n\t                                                                                             and
+        both fields will be disabled so they can't be changed.\n\t                                                                                             (If
+        for some reason you want to force re-authentications for a known customer
+        account, you can make use of this option.)\n\topenCreateAccount               No
+        \ true/false (Default value is false)                      If set to true,
+        immediately display the the account creation screen.\n\tdisplayNameShown                No
+        \ true/false (Default value is false)                      If set to true,
+        show the \"Display Name\" field on the account creation screen, to allow the
+        user\n\t                                                                                             to
+        set their central MyGarmin display name upon account creation.\n\tglobalOptInShown
+        \               No  true/false (Default value is false)                      Whether
+        the \"Global Opt-In\" check box is shown on the create account & create social
+        account screens.\n\t                                                                                             If
+        set to true these screens will show a \"Sign Up For Email\" check box with
+        accompanying text\n\t                                                                                             \"I
+        would also like to receive email about promotions and new products.\"\n\t
+        \                                                                                            If
+        checked, the Customer 2.0 account that is created will have it's global opt-in
+        flag set to true,\n\t                                                                                             and
+        Garmin email communications will be allowed.\n\tglobalOptInChecked              No
+        \ true/false (Default value is false)                      Whether the \"Global
+        Opt-In\" check box is checked by default.\n\tconsumeServiceTicket            No
+        \ true/false (Default value is true)                       IF you don't specify
+        a redirectAfterAccountLoginUrl AND you set this to false, the GAuth login
+        widget\n\t                                                                                             will
+        NOT consume the service ticket assigned and will not seamlessly log you into
+        your webapp.\n\t                                                                                             It
+        will send a SUCCESS JavaScript event with the service ticket and service url
+        you can take\n\t                                                                                             and
+        explicitly validate against the SSO infrastructure yourself.\n\t                                                                                             (By
+        using casClient's SingleSignOnUtils.authenticateServiceTicket() utility method,\n\t
+        \                                                                                            or
+        calling web service customerWebServices_v1.2 AccountManagementService.authenticateServiceTicket().)\n\tmobile
+        \                         No  true/false (Default value is false)                      Setting
+        to true will cause mobile friendly views to be shown instead of the tradition
+        screens.\n\ttermsOfUseUrl                   No  Absolute URL to your custom
+        terms of use URL.            If not specified, defaults to http://www.garmin.com/terms\n\tprivacyStatementUrl
+        \            No  Absolute URL to your custom privacy statement URL.       If
+        not specified, defaults to http://www.garmin.com/privacy\n\tproductSupportUrl
+        \              No  Absolute URL to your custom product support URL.         If
+        not specified, defaults to http://www.garmin.com/us/support/contact\n\tgenerateExtraServiceTicket
+        \     No  true/false (Default value is false)                      If set
+        to true, generate an extra unconsumed service ticket.\n\t\t                                                                                     (The
+        service ticket validation response will include the extra service ticket.)\n\tgenerateTwoExtraServiceTickets
+        \ No  true/false (Default value is false)                      If set to true,
+        generate two extra unconsumed service tickets.\n\t\t\t\t\t\t\t\t\t \t\t\t
+        \    (The service ticket validation response will include the extra service
+        tickets.)\n\tgenerateNoServiceTicket         No  true/false (Default value
+        is false)                      If you don't want SSO to generate a service
+        ticket at all when logging in to the GAuth login widget.\n                                                                                                     (Useful
+        when allowing logins to static sites that are not SSO enabled and can't consume
+        the service ticket.)\n\tconnectLegalTerms               No  true/false (Default
+        value is false)                      Whether to show the connectLegalTerms
+        on the create account page\n\tshowTermsOfUse                  No  true/false
+        (Default value is false)                      Whether to show the showTermsOfUse
+        on the create account page\n\tshowPrivacyPolicy               No  true/false
+        (Default value is false)                      Whether to show the showPrivacyPolicy
+        on the create account page\n\tshowConnectLegalAge             No  true/false
+        (Default value is false)                      Whether to show the showConnectLegalAge
+        on the create account page\n\tlocationPromptShown             No  true/false
+        (Default value is false)                      If set to true, ask the customer
+        during account creation to verify their country of residence.\n\tshowPassword
+        \                   No  true/false (Default value is true)                       If
+        set to false, mobile version for createAccount and login screens would hide
+        the password\n\tuseCustomHeader                 No  true/false (Default value
+        is false)                      If set to true, the \"Sign in\" text will be
+        replaced by custom text. Contact CDS team to set the i18n text for your client
+        id.\n\tmfaRequired                     No  true/false (Default value is false)
+        \                     Require multi factor authentication for all authenticating
+        users.\n\tperformMFACheck                 No  true/false (Default value is
+        false)                      If set to true, ask the logged in user to pass
+        a multi factor authentication check. (Only valid for an already logged in
+        user.)\n\trememberMyBrowserShown          No  true/false (Default value is
+        false)                      Whether the \"Remember My Browser\" check box
+        is shown in the GAuth login widget MFA verification screen.\n\trememberMyBrowserChecked
+        \       No  true/false (Default value is false)                      Whether
+        the \"Remember My Browser\" check box feature is checked by default.\n\tconsentTypeIds\t\t\t\t\tNo\tconsent_types
+        ids\t\t \t\t\t\t\t\t\t\t multiple consent types ids can be passed as consentTypeIds=type1&consentTypeIds=type2\n\t
\n
\n\n\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ac05c5db34620-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:58:58 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=oT4HuH19GyKTBkqXHXwnSmUp1kcqmbthvziWIXEZLe3kQQBobYqW0Qi%2FXSjy%2B2GN5dy3Cs4ZId74RXjz6bteuof9l6R2Qsum28N4Hy0wBm4fbvYMJZUPAeRAda3mHrUW"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cf_bm=SANITIZED; path=SANITIZED; expires=SANITIZED; domain=SANITIZED; HttpOnly; + Secure; SameSite=SANITIZED + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:0 + X-B3-Traceid: + - 0338524d977495f906e0c0e47bda3479 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 8cae38fd-8c5b-4d76-5f53-ed081975bd13 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - __cf_bm=SANITIZED; _cfuvid=SANITIZED; __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + method: GET + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n \n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 7f1ac05e69e44796-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:58:58 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=Rzl0HOKLCsW3P9JRr3RwN81d8PqMActtbSq4Dr6hqeIxBIK%2FkzLeLOMRn0KALChfJIB4cSgh1DszqkKVz6dxdWoBV7jsY4WstuGcTqyiAIeGTgRqmxgjXdR2B4Q65HZU"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - SESSION=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - __VCAP_ID__=SANITIZED; Path=SANITIZED; HttpOnly; Secure + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:3 + X-B3-Traceid: + - 60593e96725f1a2f5e057d199d84874b + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 9799eaf1-bdf2-420f-52ab-755533296a5f + status: + code: 200 + message: OK +- request: + body: username=SANITIZED&password=SANITIZED&embed=true&_csrf=13F3CDCE9481A2AA198AB31BDC20A8483C5FAAAC4C9BFA97A27733E25331ECCA20D8E912E7DBB994EC0F43F2E5E018326534 + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '175' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; __VCAP_ID__=SANITIZED; + __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n\t\n\t\tSuccess\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\n\t\n\t\t
\n\t\t\t\n\t\t
\n\t\t\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 7f1ac060fe1846d4-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:58:59 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=G8f1H9875FHi4mMW3X7aS9aND4jZAZnlBDAVr3KGz1hFmtUrVwqS3KipwKZMkQ40Rq4vjHtTGn22Fm5%2Bg7VA0XNSbcb3q8f%2BK%2FI0nzh0GsR2fGk%2FH0S4yBe7bsMOwol%2F"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + - GARMIN-SSO=SANITIZED; Domain=SANITIZED; Path=SANITIZED + - GARMIN-SSO=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminNoCache=SANITIZED; Domain=SANITIZED; Path=SANITIZED + - GarminNoCache=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GARMIN-SSO-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED + - GARMIN-SSO-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GARMIN-SSO-CUST-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED + - GARMIN-SSO-CUST-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + - __cfruid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:3 + X-B3-Traceid: + - 67d13140bb74241f5ffafc30cb590ae9 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - bb5f25d2-31ab-4879-5100-1898910361aa + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - python-requests/2.31.0 + method: GET + uri: https://thegarth.s3.amazonaws.com/oauth_consumer.json + response: + body: + string: '{"consumer_key": "SANITIZED", "consumer_secret": "SANITIZED"}' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '124' + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 23:59:00 GMT + ETag: + - '"20240b1013cb35419bb5b2cff1407a4e"' + Last-Modified: + - Thu, 03 Aug 2023 00:16:11 GMT + Server: + - AmazonS3 + x-amz-id-2: + - MSQpXzot1gVYwlRRZFwqhhl2CaWvGVUOa87bLyZb9cWDw/4XeFMn4LLslomjV8xnr5ejXOTDRjM= + x-amz-request-id: + - DK3CF9X2YV7R386H + x-amz-server-side-encryption: + - AES256 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: GET + uri: https://connectapi.garmin.com/oauth-service/oauth/preauthorized?ticket=ST-2459533-YeWiOAMHdTmHqEyWcWeI-cas&login-url=https://sso.garmin.com/sso/embed&accepts-mfa-tokens=true + response: + body: + string: oauth_token=SANITIZED&oauth_token_secret=SANITIZED + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ac06849351556-QRO + Connection: + - keep-alive + Content-Type: + - text/plain;charset=utf-8 + Date: + - Fri, 04 Aug 2023 23:59:00 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=3MpWsX37CvkXmKc8KOczSqUhotPJCTd8xg30IHeNtiLn%2BgRHZ1OLmUEmEzCFRFA7bLdNQMtPMOWGkA4XmepxRdPww%2F92hfzoqcwW3lwmrqWWp9BAJtSvRfdnAfH%2F43eEBK5yLU%2F8CQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + status: + code: 200 + message: OK +- request: + body: '' + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + Content-Length: + - !!binary | + MA== + Content-Type: + - !!binary | + YXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVk + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: POST + uri: https://connectapi.garmin.com/oauth-service/oauth/exchange/user/2.0 + response: + body: + string: '{"scope": "COMMUNITY_COURSE_READ GARMINPAY_WRITE GOLF_API_READ ATP_READ + GHS_SAMD GHS_UPLOAD INSIGHTS_READ COMMUNITY_COURSE_WRITE CONNECT_WRITE GCOFFER_WRITE + GARMINPAY_READ DT_CLIENT_ANALYTICS_WRITE GOLF_API_WRITE INSIGHTS_WRITE PRODUCT_SEARCH_READ + GCOFFER_READ CONNECT_READ ATP_WRITE", "jti": "SANITIZED", "access_token": + "SANITIZED", "token_type": "Bearer", "refresh_token": "SANITIZED", "expires_in": + 102003, "refresh_token_expires_in": 2591999}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ac06b2ea41547-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 23:59:00 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=NNCYZLaC3FVERa7klmexZY7Kh3hgtxeCrxhI99bSdoSg4HYUBlJtp%2FgVylwDlkFrU%2B0S5Ufb69lEQjC583RGLoO6U8PZFyHu1Bopl%2B%2BXq0QwIoOs36XBwicE1xqC7%2B7IWFi7pOAhKw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_login_success_mfa.yaml b/garth/tests/cassettes/test_login_success_mfa.yaml new file mode 100644 index 0000000..6335d3d --- /dev/null +++ b/garth/tests/cassettes/test_login_success_mfa.yaml @@ -0,0 +1,1041 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + response: + body: + string: "\n\t\n\t GAuth Embedded Version\n\t \n\t \n\t\n\t\n\t\t\n\n
\n\t
\n\tERROR:
+        clientId parameter must be specified!!!\n\n\tUsage: https://sso.garmin.com/sso/embed?clientId=<clientId>&locale=<locale>...\n\n\tRequest
+        parameter configuration options:\n\n\tNAME                           REQ  VALUES
+        \                                                  DESCRIPTION\n\t------------------
+        \            ---  -------------------------------------------------------
+        \ ---------------------------------------------------------------------------------------------------\n\tclientId
+        \                      Yes  \"MY_GARMIN\"/\"BUY_GARMIN\"/\"FLY_GARMIN\"/                   Client
+        identifier for your web application\n\t                                    \"RMA\"/\"GarminConnect\"/\"OpenCaching\"/etc\n\tlocale
+        \                        Yes  \"en\", \"bg\", \"cs\", \"da\", \"de\", \"es\",
+        \"el\", \"fr\", \"hr\",    User's current locale, to display the GAuth login
+        widget internationalized properly.\n\t                                    \"in\",
+        \"it\", \"iw\", \"hu\", \"ms\", \"nb\", \"nl\", \"no\", \"pl\",    (All the
+        currently supported locales are listed in the Values section.)\n\t                                    \"pt\",
+        \"pt_BR\", \"ru\", \"sk\", \"sl\", \"fi\", \"sv\", \"tr\",\n\t                                    \"uk\",
+        \"th\", \"ja\", \"ko\", \"zh_TW\", \"zh\", \"vi_VN\"\n\tcssUrl                          No
+        \ Absolute URL to custom CSS file.                         Use custom CSS
+        styling for the GAuth login widget.\n\treauth                          No
+        \ true/false (Default value is false)                      Specify true if
+        you want to ensure that the GAuth login widget shows up,\n\t                                                                                             even
+        if the SSO infrastructure remembers the user and would immediately log them
+        in.\n\t                                                                                             This
+        is useful if you know a user is logged on, but want a different user to be
+        allowed to logon.\n\tinitialFocus                    No  true/false (Default
+        value is true)                       If you don't want the GAuth login widget
+        to autofocus in it's \"Email or Username\" field upon initial loading,\n\t
+        \                                                                                            then
+        specify this option and set it to false.\n\trememberMeShown                 No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box is shown in the GAuth login widget.\n\trememberMeChecked               No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box feature is checked by default.\n\tcreateAccountShown              No
+        \ true/false (Default value is true)                       Whether the \"Don't
+        have an account? Create One\" link is shown in the GAuth login widget.\n\tsocialEnabled
+        \                  No  true/false (Default value is false)                       If
+        set to false, do not show any social sign in elements or allow social sign
+        ins.\n\tlockToEmailAddress              No  Email address to pre-load and
+        lock.                      If specified, the specified email address will
+        be pre-loaded in the main \"Email\" field in the SSO login form,\n\t                                                                                             as
+        well as in in the \"Email Address\" field in the \"Forgot Password?\" password
+        reset form,\n\t                                                                                             and
+        both fields will be disabled so they can't be changed.\n\t                                                                                             (If
+        for some reason you want to force re-authentications for a known customer
+        account, you can make use of this option.)\n\topenCreateAccount               No
+        \ true/false (Default value is false)                      If set to true,
+        immediately display the the account creation screen.\n\tdisplayNameShown                No
+        \ true/false (Default value is false)                      If set to true,
+        show the \"Display Name\" field on the account creation screen, to allow the
+        user\n\t                                                                                             to
+        set their central MyGarmin display name upon account creation.\n\tglobalOptInShown
+        \               No  true/false (Default value is false)                      Whether
+        the \"Global Opt-In\" check box is shown on the create account & create social
+        account screens.\n\t                                                                                             If
+        set to true these screens will show a \"Sign Up For Email\" check box with
+        accompanying text\n\t                                                                                             \"I
+        would also like to receive email about promotions and new products.\"\n\t
+        \                                                                                            If
+        checked, the Customer 2.0 account that is created will have it's global opt-in
+        flag set to true,\n\t                                                                                             and
+        Garmin email communications will be allowed.\n\tglobalOptInChecked              No
+        \ true/false (Default value is false)                      Whether the \"Global
+        Opt-In\" check box is checked by default.\n\tconsumeServiceTicket            No
+        \ true/false (Default value is true)                       IF you don't specify
+        a redirectAfterAccountLoginUrl AND you set this to false, the GAuth login
+        widget\n\t                                                                                             will
+        NOT consume the service ticket assigned and will not seamlessly log you into
+        your webapp.\n\t                                                                                             It
+        will send a SUCCESS JavaScript event with the service ticket and service url
+        you can take\n\t                                                                                             and
+        explicitly validate against the SSO infrastructure yourself.\n\t                                                                                             (By
+        using casClient's SingleSignOnUtils.authenticateServiceTicket() utility method,\n\t
+        \                                                                                            or
+        calling web service customerWebServices_v1.2 AccountManagementService.authenticateServiceTicket().)\n\tmobile
+        \                         No  true/false (Default value is false)                      Setting
+        to true will cause mobile friendly views to be shown instead of the tradition
+        screens.\n\ttermsOfUseUrl                   No  Absolute URL to your custom
+        terms of use URL.            If not specified, defaults to http://www.garmin.com/terms\n\tprivacyStatementUrl
+        \            No  Absolute URL to your custom privacy statement URL.       If
+        not specified, defaults to http://www.garmin.com/privacy\n\tproductSupportUrl
+        \              No  Absolute URL to your custom product support URL.         If
+        not specified, defaults to http://www.garmin.com/us/support/contact\n\tgenerateExtraServiceTicket
+        \     No  true/false (Default value is false)                      If set
+        to true, generate an extra unconsumed service ticket.\n\t\t                                                                                     (The
+        service ticket validation response will include the extra service ticket.)\n\tgenerateTwoExtraServiceTickets
+        \ No  true/false (Default value is false)                      If set to true,
+        generate two extra unconsumed service tickets.\n\t\t\t\t\t\t\t\t\t \t\t\t
+        \    (The service ticket validation response will include the extra service
+        tickets.)\n\tgenerateNoServiceTicket         No  true/false (Default value
+        is false)                      If you don't want SSO to generate a service
+        ticket at all when logging in to the GAuth login widget.\n                                                                                                     (Useful
+        when allowing logins to static sites that are not SSO enabled and can't consume
+        the service ticket.)\n\tconnectLegalTerms               No  true/false (Default
+        value is false)                      Whether to show the connectLegalTerms
+        on the create account page\n\tshowTermsOfUse                  No  true/false
+        (Default value is false)                      Whether to show the showTermsOfUse
+        on the create account page\n\tshowPrivacyPolicy               No  true/false
+        (Default value is false)                      Whether to show the showPrivacyPolicy
+        on the create account page\n\tshowConnectLegalAge             No  true/false
+        (Default value is false)                      Whether to show the showConnectLegalAge
+        on the create account page\n\tlocationPromptShown             No  true/false
+        (Default value is false)                      If set to true, ask the customer
+        during account creation to verify their country of residence.\n\tshowPassword
+        \                   No  true/false (Default value is true)                       If
+        set to false, mobile version for createAccount and login screens would hide
+        the password\n\tuseCustomHeader                 No  true/false (Default value
+        is false)                      If set to true, the \"Sign in\" text will be
+        replaced by custom text. Contact CDS team to set the i18n text for your client
+        id.\n\tmfaRequired                     No  true/false (Default value is false)
+        \                     Require multi factor authentication for all authenticating
+        users.\n\tperformMFACheck                 No  true/false (Default value is
+        false)                      If set to true, ask the logged in user to pass
+        a multi factor authentication check. (Only valid for an already logged in
+        user.)\n\trememberMyBrowserShown          No  true/false (Default value is
+        false)                      Whether the \"Remember My Browser\" check box
+        is shown in the GAuth login widget MFA verification screen.\n\trememberMyBrowserChecked
+        \       No  true/false (Default value is false)                      Whether
+        the \"Remember My Browser\" check box feature is checked by default.\n\tconsentTypeIds\t\t\t\t\tNo\tconsent_types
+        ids\t\t \t\t\t\t\t\t\t\t multiple consent types ids can be passed as consentTypeIds=type1&consentTypeIds=type2\n\t
\n
\n\n\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ab7623b3fb6e7-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:52:50 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=2LVP2GabW9hmt5SBQnKTrfufR7w71BaCLIDcRhywiSOOr5b3PEve8VCtlRnsv2tTDexPlZTbqE7wSYqfWb930CvAm0jIkAoRp6eYCk3UEsby5uzXR%2FCpflPnA6NCPzN2"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cf_bm=SANITIZED; path=SANITIZED; expires=SANITIZED; domain=SANITIZED; HttpOnly; + Secure; SameSite=SANITIZED + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:3 + X-B3-Traceid: + - 30468320ec0db9e4756d98413af1080c + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - c63525bc-37d7-440c-6740-36a6129fe4ca + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - __cf_bm=SANITIZED; _cfuvid=SANITIZED; __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + method: GET + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n \n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 7f1ab763ff104638-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:52:50 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=InGlT5Ba%2BLzBdhsvcSmMDu1seTTKlDJttidNDvQWf5dZERrhqMuAJmGifn%2B%2BLFBS6LdcnNZlh5IMqBzzjLxv07sgGjOoo3gQ5%2B1DRGkqwoNMlL2nZHpsp5zUYUBHbJEu"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - SESSION=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - __VCAP_ID__=SANITIZED; Path=SANITIZED; HttpOnly; Secure + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:6 + X-B3-Traceid: + - 35d11ea88e42f34d4dc08e3fd5b3c746 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 32e1f3d1-8f80-459d-4d11-24978e412e76 + status: + code: 200 + message: OK +- request: + body: username=SANITIZED&password=SANITIZED&embed=true&_csrf=1C8FCC7A63FC636522294F8278D7F1DD08E00C5FDA8FD253ED93797BAAC97E0712C42221A1929E2CA3C92B0BDEB4E2B649AB + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '175' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; __VCAP_ID__=SANITIZED; + __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 7f1ab7662ddd466c-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Fri, 04 Aug 2023 23:52:52 GMT + Location: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=D5dkx%2FVxJjYHbG1%2FNq3RBFEq8YUEKSo7qugL9FcLf2UEQ4z1aHxGMK%2Fbbneme%2F6a%2FwwL98wB0UditbK7NZ8dntggx6%2BRhz2DPmgxQs9zzzeFeBQjJDEPQPtaBU7S5rkP"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cfruid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:6 + X-B3-Traceid: + - 5d4f16564994c09e767aeb869d1f3119 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 9d4da862-8730-4cff-7595-709476e1f004 + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; __cfruid=SANITIZED; + __VCAP_ID__=SANITIZED; __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n\n\n \n + \ \n \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n \n Enter + MFA code for login\n \n + \ \n + \ \n \n \n \n\n\n\n
\n

Enter + security code

\n \n \n\n + \
\n
\n \n \n + \ Code sent to mt*****@gmail.com\n + \ \n
\n + \
\n
\n \n \n \n + \ \n \n \n
\n + \
\n
\n \n
\n + \
\n

\n
\n + \ Get help
\n
\n + \
\n + \ Request a new code\n + \
\n \n \n + \
\n \n
\n + \ \n
\n \n \n \n + \
\n
\n
\n
\n
\n
\n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ab76f0ae0b6e8-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:52:52 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=Z674tWLGWzudE9EHjoD2Z6WbD8HDVo49caoIX27DFUAbHcDvQkq1YV2kHZT1WRLpY6RDovvNsT3g3bwVsVUAamdC1GbBu3kPl%2FzQWfVGg0dSInr76rWCXemH9T29xIA6"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:6 + X-B3-Traceid: + - 259b6899c5257de0216d0d08074c00d2 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 1ab5c70b-d4dd-41bd-5f84-72c19a3cb327 + status: + code: 200 + message: OK +- request: + body: mfa-code=536947&embed=true&_csrf=E68248EA7D89A572B43FA93876000B651D682EE3C8FACF219078E0889281085C27FD2600FBD9258E298F7831374801807F43&fromPage=setupEnterMfaCode + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '160' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; __cf_bm=SANITIZED; __cfruid=SANITIZED; _cfuvid=SANITIZED; + __VCAP_ID__=SANITIZED; __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ab7bd5ebb1557-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Fri, 04 Aug 2023 23:53:05 GMT + Location: + - https://sso.garmin.com/sso/login?logintoken=utu1SKtOQl&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=U97OXuKEiYsMFcDJXk9DZ26CaUwPfYd4Ypq5EWk01J4r7y09A%2BTldx7kc8vMVaYWd2aEPW5LO0Qajmhr1krffmftuwF%2B8uTYggV8Tsj%2BG7ShUQTM3x4OmNs%2FX2uA8MSB"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:6 + X-B3-Traceid: + - 4a38b2c7a5d3f6d03e7da32cf647e89c + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 41369645-9bd5-40ee-7061-27eb8e5f7c53 + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; __cf_bm=SANITIZED; __cfruid=SANITIZED; _cfuvid=SANITIZED; + __VCAP_ID__=SANITIZED; __cflb=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/login?logintoken=utu1SKtOQl&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + response: + body: + string: "\n\n\t\n\t\tSuccess\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\n\t\n\t\t
\n\t\t\t\n\t\t
\n\t\t\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 7f1ab7c10bbeb6ed-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 23:53:05 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=2G4DISzhJxQTgPyt928sxPIrBCPiA02sPpyxNjBdGaTUYporonO0fXu9kxF1WtUS3WHigdl6xSpPYoIOpH23NIG2DJ%2FGpIDERYsg1WmeSMrFUNlNSW5ve7NWz18Wx8er"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + - GARMIN-SSO=SANITIZED; Domain=SANITIZED; Path=SANITIZED + - GARMIN-SSO=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminNoCache=SANITIZED; Domain=SANITIZED; Path=SANITIZED + - GarminNoCache=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GARMIN-SSO-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED + - GARMIN-SSO-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GARMIN-SSO-CUST-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED + - GARMIN-SSO-CUST-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:6 + X-B3-Traceid: + - 10dc5ed9527183de031b6e923d04a154 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - dba4714d-cf7a-42d4-5798-347cf492ac0b + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - python-requests/2.31.0 + method: GET + uri: https://thegarth.s3.amazonaws.com/oauth_consumer.json + response: + body: + string: '{"consumer_key": "SANITIZED", "consumer_secret": "SANITIZED"}' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '124' + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 23:53:07 GMT + ETag: + - '"20240b1013cb35419bb5b2cff1407a4e"' + Last-Modified: + - Thu, 03 Aug 2023 00:16:11 GMT + Server: + - AmazonS3 + x-amz-id-2: + - q9jx2xc+YzHSK2IvG72GFo56Z//9aHcYSWRv/OvLL8wTMIgeFztRORDZolSbiqd2zAut1xN2ftA= + x-amz-request-id: + - Y0VP24YYF9QFEK8Y + x-amz-server-side-encryption: + - AES256 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: GET + uri: https://connectapi.garmin.com/oauth-service/oauth/preauthorized?ticket=ST-2493679-FvaBwl5Of6mdyXQlO9as-cas&login-url=https://sso.garmin.com/sso/embed&accepts-mfa-tokens=true + response: + body: + string: oauth_token=SANITIZED&oauth_token_secret=SANITIZED&mfa_token=SANITIZED&mfa_expiration_timestamp=2024-08-03 + 23:53:05.000 + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ab7c79948480a-DFW + Connection: + - keep-alive + Content-Type: + - text/plain;charset=utf-8 + Date: + - Fri, 04 Aug 2023 23:53:06 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=4p0O390qlFhl9RxlYgnDW%2BkNgLiQW%2Buoz%2F%2BItcaWI%2FHremxMaUd6SuAKOLzOW1WFr1SXsLyt%2F0pA1HuXSdhii6hz%2BqetK8pN285CuX1l5oERPJ7r5PD1KX7c6q89IgKVoHqULiHzoQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + status: + code: 200 + message: OK +- request: + body: mfa_token=MFA-1571-OjGRdKOuYI3OmN2fCGvPI24f9eulUGVrnCWafAcktRfTSbx3q3-cas + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + Content-Length: + - '73' + Content-Type: + - !!binary | + YXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVk + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: POST + uri: https://connectapi.garmin.com/oauth-service/oauth/exchange/user/2.0 + response: + body: + string: '{"scope": "COMMUNITY_COURSE_READ GARMINPAY_WRITE GOLF_API_READ ATP_READ + GHS_SAMD GHS_UPLOAD INSIGHTS_READ COMMUNITY_COURSE_WRITE CONNECT_WRITE GCOFFER_WRITE + GARMINPAY_READ DT_CLIENT_ANALYTICS_WRITE GOLF_API_WRITE INSIGHTS_WRITE PRODUCT_SEARCH_READ + GCOFFER_READ CONNECT_READ ATP_WRITE", "jti": "SANITIZED", "access_token": + "SANITIZED", "token_type": "Bearer", "refresh_token": "SANITIZED", "expires_in": + 68725, "refresh_token_expires_in": 2591999}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f1ab7cb49d0b6ed-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 23:53:07 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=Y7WspgfIFSb%2BebaZ2ILsben4mjQds8FLY5dLlbmXTp3vbU8ngdeqQhotPZWT3c0OdC1s%2Bp0uNU2VL1RHXbBnQQeSQTyIVOSERIZlqxSdwpbPCGJwl7KByUE7WcepidmqKO4fR%2FKUVg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_login_success_mfa_async.yaml b/garth/tests/cassettes/test_login_success_mfa_async.yaml new file mode 100644 index 0000000..20cefe1 --- /dev/null +++ b/garth/tests/cassettes/test_login_success_mfa_async.yaml @@ -0,0 +1,1144 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + response: + body: + string: "\n\t\n\t GAuth Embedded Version\n\t \n\t \n\t\n\t\n\t\t\n\n
\n\t
\n\tERROR:
+        clientId parameter must be specified!!!\n\n\tUsage: https://sso.garmin.com/sso/embed?clientId=<clientId>&locale=<locale>...\n\n\tRequest
+        parameter configuration options:\n\n\tNAME                           REQ  VALUES
+        \                                                  DESCRIPTION\n\t------------------
+        \            ---  -------------------------------------------------------
+        \ ---------------------------------------------------------------------------------------------------\n\tclientId
+        \                      Yes  \"MY_GARMIN\"/\"BUY_GARMIN\"/\"FLY_GARMIN\"/                   Client
+        identifier for your web application\n\t                                    \"RMA\"/\"GarminConnect\"/\"OpenCaching\"/etc\n\tlocale
+        \                        Yes  \"en\", \"bg\", \"cs\", \"da\", \"de\", \"es\",
+        \"el\", \"fr\", \"hr\",    User's current locale, to display the GAuth login
+        widget internationalized properly.\n\t                                    \"in\",
+        \"it\", \"iw\", \"hu\", \"ms\", \"nb\", \"nl\", \"no\", \"pl\",    (All the
+        currently supported locales are listed in the Values section.)\n\t                                    \"pt\",
+        \"pt_BR\", \"ru\", \"sk\", \"sl\", \"fi\", \"sv\", \"tr\",\n\t                                    \"uk\",
+        \"th\", \"ja\", \"ko\", \"zh_TW\", \"zh\", \"vi_VN\"\n\tcssUrl                          No
+        \ Absolute URL to custom CSS file.                         Use custom CSS
+        styling for the GAuth login widget.\n\treauth                          No
+        \ true/false (Default value is false)                      Specify true if
+        you want to ensure that the GAuth login widget shows up,\n\t                                                                                             even
+        if the SSO infrastructure remembers the user and would immediately log them
+        in.\n\t                                                                                             This
+        is useful if you know a user is logged on, but want a different user to be
+        allowed to logon.\n\tinitialFocus                    No  true/false (Default
+        value is true)                       If you don't want the GAuth login widget
+        to autofocus in it's \"Email or Username\" field upon initial loading,\n\t
+        \                                                                                            then
+        specify this option and set it to false.\n\trememberMeShown                 No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box is shown in the GAuth login widget.\n\trememberMeChecked               No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box feature is checked by default.\n\tcreateAccountShown              No
+        \ true/false (Default value is true)                       Whether the \"Don't
+        have an account? Create One\" link is shown in the GAuth login widget.\n\tsocialEnabled
+        \                  No  true/false (Default value is false)                       If
+        set to false, do not show any social sign in elements or allow social sign
+        ins.\n\tlockToEmailAddress              No  Email address to pre-load and
+        lock.                      If specified, the specified email address will
+        be pre-loaded in the main \"Email\" field in the SSO login form,\n\t                                                                                             as
+        well as in in the \"Email Address\" field in the \"Forgot Password?\" password
+        reset form,\n\t                                                                                             and
+        both fields will be disabled so they can't be changed.\n\t                                                                                             (If
+        for some reason you want to force re-authentications for a known customer
+        account, you can make use of this option.)\n\topenCreateAccount               No
+        \ true/false (Default value is false)                      If set to true,
+        immediately display the the account creation screen.\n\tdisplayNameShown                No
+        \ true/false (Default value is false)                      If set to true,
+        show the \"Display Name\" field on the account creation screen, to allow the
+        user\n\t                                                                                             to
+        set their central MyGarmin display name upon account creation.\n\tglobalOptInShown
+        \               No  true/false (Default value is false)                      Whether
+        the \"Global Opt-In\" check box is shown on the create account & create social
+        account screens.\n\t                                                                                             If
+        set to true these screens will show a \"Sign Up For Email\" check box with
+        accompanying text\n\t                                                                                             \"I
+        would also like to receive email about promotions and new products.\"\n\t
+        \                                                                                            If
+        checked, the Customer 2.0 account that is created will have it's global opt-in
+        flag set to true,\n\t                                                                                             and
+        Garmin email communications will be allowed.\n\tglobalOptInChecked              No
+        \ true/false (Default value is false)                      Whether the \"Global
+        Opt-In\" check box is checked by default.\n\tconsumeServiceTicket            No
+        \ true/false (Default value is true)                       IF you don't specify
+        a redirectAfterAccountLoginUrl AND you set this to false, the GAuth login
+        widget\n\t                                                                                             will
+        NOT consume the service ticket assigned and will not seamlessly log you into
+        your webapp.\n\t                                                                                             It
+        will send a SUCCESS JavaScript event with the service ticket and service url
+        you can take\n\t                                                                                             and
+        explicitly validate against the SSO infrastructure yourself.\n\t                                                                                             (By
+        using casClient's SingleSignOnUtils.authenticateServiceTicket() utility method,\n\t
+        \                                                                                            or
+        calling web service customerWebServices_v1.2 AccountManagementService.authenticateServiceTicket().)\n\tmobile
+        \                         No  true/false (Default value is false)                      Setting
+        to true will cause mobile friendly views to be shown instead of the tradition
+        screens.\n\ttermsOfUseUrl                   No  Absolute URL to your custom
+        terms of use URL.            If not specified, defaults to http://www.garmin.com/terms\n\tprivacyStatementUrl
+        \            No  Absolute URL to your custom privacy statement URL.       If
+        not specified, defaults to http://www.garmin.com/privacy\n\tproductSupportUrl
+        \              No  Absolute URL to your custom product support URL.         If
+        not specified, defaults to http://www.garmin.com/us/support/contact\n\tgenerateExtraServiceTicket
+        \     No  true/false (Default value is false)                      If set
+        to true, generate an extra unconsumed service ticket.\n\t\t                                                                                     (The
+        service ticket validation response will include the extra service ticket.)\n\tgenerateTwoExtraServiceTickets
+        \ No  true/false (Default value is false)                      If set to true,
+        generate two extra unconsumed service tickets.\n\t\t\t\t\t\t\t\t\t \t\t\t
+        \    (The service ticket validation response will include the extra service
+        tickets.)\n\tgenerateNoServiceTicket         No  true/false (Default value
+        is false)                      If you don't want SSO to generate a service
+        ticket at all when logging in to the GAuth login widget.\n                                                                                                     (Useful
+        when allowing logins to static sites that are not SSO enabled and can't consume
+        the service ticket.)\n\tconnectLegalTerms               No  true/false (Default
+        value is false)                      Whether to show the connectLegalTerms
+        on the create account page\n\tshowTermsOfUse                  No  true/false
+        (Default value is false)                      Whether to show the showTermsOfUse
+        on the create account page\n\tshowPrivacyPolicy               No  true/false
+        (Default value is false)                      Whether to show the showPrivacyPolicy
+        on the create account page\n\tshowConnectLegalAge             No  true/false
+        (Default value is false)                      Whether to show the showConnectLegalAge
+        on the create account page\n\tlocationPromptShown             No  true/false
+        (Default value is false)                      If set to true, ask the customer
+        during account creation to verify their country of residence.\n\tshowPassword
+        \                   No  true/false (Default value is true)                       If
+        set to false, mobile version for createAccount and login screens would hide
+        the password\n\tuseCustomHeader                 No  true/false (Default value
+        is false)                      If set to true, the \"Sign in\" text will be
+        replaced by custom text. Contact CDS team to set the i18n text for your client
+        id.\n\tmfaRequired                     No  true/false (Default value is false)
+        \                     Require multi factor authentication for all authenticating
+        users.\n\tperformMFACheck                 No  true/false (Default value is
+        false)                      If set to true, ask the logged in user to pass
+        a multi factor authentication check. (Only valid for an already logged in
+        user.)\n\trememberMyBrowserShown          No  true/false (Default value is
+        false)                      Whether the \"Remember My Browser\" check box
+        is shown in the GAuth login widget MFA verification screen.\n\trememberMyBrowserChecked
+        \       No  true/false (Default value is false)                      Whether
+        the \"Remember My Browser\" check box feature is checked by default.\n\tconsentTypeIds\t\t\t\t\tNo\tconsent_types
+        ids\t\t \t\t\t\t\t\t\t\t multiple consent types ids can be passed as consentTypeIds=type1&consentTypeIds=type2\n\t
\n
\n\n\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 885f8004ea726458-SJC + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Sat, 18 May 2024 23:06:51 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=leV6Y6Xwx9UQbmOXLu4nP3NDkujz32au4KjL%2FEobMvNsGNEqpuDPAQwMlfd2c%2BqzAkRK%2BY68TK78djHo8FbAUN7ljszDtl7Xwtfy%2FFi9%2FeRkqpZz8rFnSpCrTMhnst61"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cf_bm=SANITIZED; path=SANITIZED; expires=SANITIZED; domain=SANITIZED; HttpOnly; + Secure; SameSite=SANITIZED + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:6 + X-B3-Traceid: + - 2d9933cce4506f224c1357749fe86b50 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 3f00a490-dad0-4e7e-4358-9db9cce59f9c + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - ADRUM_BTa=SANITIZED; SameSite=SANITIZED; ADRUM_BT1=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + method: GET + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n \n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 885f8005caf76458-SJC + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Sat, 18 May 2024 23:06:51 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=FLNsqi36rD1PwNz8ZbQvJ8SLTSTWz1bPt%2FZJTXrm4FQXSABX3lNrctFB3Nm5Sy9oAHxSMyjG5IEFmoaldGzXu9bgyIIIJoli5lwIg35tUfWtAUK3y1%2BIcA%2BfJ6iXfDju"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - SESSION=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - __VCAP_ID__=SANITIZED; Path=SANITIZED; HttpOnly; Secure + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:7 + X-B3-Traceid: + - 0e12aedefdb2d3524dc4688d21d92602 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - b8117c93-abda-4804-6063-19bd83c0cf5e + status: + code: 200 + message: OK +- request: + body: username=SANITIZED&password=SANITIZED&embed=true&_csrf=6A05676EA0C052B46099B517C6C2A45EEC33FB655FDC59F45AFA9DDB77DF239208A8E88677D859E7C9D52FB2B9D9ABB78615 + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '177' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; SameSite=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; ADRUM_BTa=SANITIZED; ADRUM_BT1=SANITIZED; __VCAP_ID__=SANITIZED; + __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 885f80089caf6458-SJC + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Sat, 18 May 2024 23:06:53 GMT + Location: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=WmrHYyb9y9r9QiYdX9Abx1ms4DMjor35KGA0eoc5RiV3dUTCU%2F9k3qtEuCuQ906X19BhLZET%2FHb9CluX2vbLBBeSLpEsdRPE%2Fjj610XV24s5si3nCgVCOHea7DMKRV18"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - ADRUM_BTs=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - __cfruid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:7 + X-B3-Traceid: + - 292509ba8d11ebdc3d012dfab3c88ea8 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 408a7c53-5d79-4e24-45ac-3981a357cda5 + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; SameSite=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; ADRUM_BTa=SANITIZED; ADRUM_BT1=SANITIZED; + ADRUM_BTs=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; __cfruid=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n\n\n \n + \ \n \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n \n Enter + MFA code for login\n \n + \ \n + \ \n \n \n \n\n\n\n
\n

Enter + security code

\n \n \n\n + \
\n
\n \n \n + \ Code sent to mt*****@gmail.com\n + \ \n
\n + \
\n
\n \n \n \n + \ \n \n \n
\n + \
\n
\n \n
\n + \
\n

\n
\n + \ Get help
\n
\n + \
\n + \ Request a new code\n + \
\n \n \n + \
\n \n
\n + \ \n
\n \n \n \n + \
\n
\n
\n
\n
\n
\n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 885f8011ba966458-SJC + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Sat, 18 May 2024 23:06:53 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=GlwlyK%2BzKjmmM1t2Yd%2BeLaDHiZb%2BX36orkn1foFEjInoXl3iMY6iULlUhcIlXeW828GlVDCw1u2wPI%2BkN%2Ft9ZPHqTerH1xyxse5pAeXJe%2B7r6q%2FNvCK%2By0vZKS7qFCHz"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTs=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:7 + X-B3-Traceid: + - 053ae3f95f8e12db7e4c12688f1900c8 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 33a6629e-38d6-4f7a-7fb1-4cbf079564dc + status: + code: 200 + message: OK +- request: + body: mfa-code=031174&embed=true&_csrf=F359B26A20FD789AF8E7C7B2759C9319B70867BA1012DEBCFFCBECC41F6F1EBA66C09B686F3399137D074A67351872C572D2&fromPage=setupEnterMfaCode + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '160' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; SameSite=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; ADRUM_BTa=SANITIZED; ADRUM_BT1=SANITIZED; + __cf_bm=SANITIZED; _cfuvid=SANITIZED; __cfruid=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 885f806faae46458-SJC + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Sat, 18 May 2024 23:07:09 GMT + Location: + - https://sso.garmin.com/sso/login?logintoken=sk5h46m9um&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=Z9su3v5oNghi3A%2BQ6ICZYDdECWmF1Y%2But4yg8MFKy6E8fbPovvl4xAf0fuFCzxkF8W255wOKgDBleJG8p8WXkjAyfMNR5Yoi1BzSAcA5CrQBLcVSTnHDW8takinxqNl6"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - ADRUM_BTs=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:7 + X-B3-Traceid: + - 7ffc6d7faa21e767344034b533fdbefe + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 8ca5ae05-6703-490b-4663-2249172c2c4c + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; SameSite=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; ADRUM_BTa=SANITIZED; ADRUM_BT1=SANITIZED; + ADRUM_BTs=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; __cfruid=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/login?logintoken=sk5h46m9um&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + response: + body: + string: "\n\n\t\n\t\tSuccess\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\n\t\n\t\t
\n\t\t\t\n\t\t
\n\t\t\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 885f807a798f6458-SJC + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Sat, 18 May 2024 23:07:10 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=%2BIryBqMGtox%2FO4kcpIZSmiAox8EiYnyZzVo21bRFPYoG3z55sU%2FRilzKvgzm1Lz4vnpRfq95ReP4CB%2FfdT8MZLAKScd1oXuVFkSGyH5FUNy0ukp4u%2BdCHBoek2em5ZKO"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTs=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + - GARMIN-SSO=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GarminNoCache=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GarminNoCache=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GARMIN-SSO-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GARMIN-SSO-CUST-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO-CUST-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:7 + X-B3-Traceid: + - 73ac58f7d75cf14d3a193f80a80de7c4 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 8a5e2efc-6afb-4e33-6af7-749b362d7ccc + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - python-requests/2.31.0 + method: GET + uri: https://thegarth.s3.amazonaws.com/oauth_consumer.json + response: + body: + string: '{"consumer_key": "SANITIZED", "consumer_secret": "SANITIZED"}' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '124' + Content-Type: + - application/json + Date: + - Sat, 18 May 2024 23:07:11 GMT + ETag: + - '"20240b1013cb35419bb5b2cff1407a4e"' + Last-Modified: + - Thu, 03 Aug 2023 00:16:11 GMT + Server: + - AmazonS3 + x-amz-id-2: + - D+vayHnIRE0uWnxaF05fd9oQB97vhdZ0StVTzhaS6ZRFuaSuH1/TrjuZzUtbCr4OVFH7Y/v3N8Y= + x-amz-request-id: + - HWNTPEH1EE6FQV9C + x-amz-server-side-encryption: + - AES256 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: GET + uri: https://connectapi.garmin.com/oauth-service/oauth/preauthorized?ticket=ST-2880693-KiRaqzeMsV5dxDhQuf2n-cas&login-url=https://sso.garmin.com/sso/embed&accepts-mfa-tokens=true + response: + body: + string: oauth_token=SANITIZED&oauth_token_secret=SANITIZED&mfa_token=SANITIZED&mfa_expiration_timestamp=2025-05-18 + 23:07:10.000 + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 885f807f58f87abb-SJC + Connection: + - keep-alive + Content-Type: + - text/plain;charset=utf-8 + Date: + - Sat, 18 May 2024 23:07:11 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=gydJyUavxu3CnI02qEtNbuKEkdFnWDcsQrqtjfD3deM%2FETziKx1L74yS6OaEMlCAgyb%2BsJ6%2FeCT1W7rzNdw0SVb5pfbdinq9CEqlgrLaT4tavojdxmQ03xF%2BnZw5BfV9P2cRFPel4w%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + status: + code: 200 + message: OK +- request: + body: mfa_token=MFA-6241-G7vU5YelBHqKji22WwcN6eSqnrkQ6NR0wmtibCo3cOcrlcpDbR-cas + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + Content-Length: + - '73' + Content-Type: + - !!binary | + YXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVk + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: POST + uri: https://connectapi.garmin.com/oauth-service/oauth/exchange/user/2.0 + response: + body: + string: '{"scope": "COMMUNITY_COURSE_READ GARMINPAY_WRITE GOLF_API_READ ATP_READ + GHS_SAMD GHS_UPLOAD INSIGHTS_READ COMMUNITY_COURSE_WRITE CONNECT_WRITE GCOFFER_WRITE + GARMINPAY_READ DT_CLIENT_ANALYTICS_WRITE GOLF_API_WRITE INSIGHTS_WRITE PRODUCT_SEARCH_READ + OMT_SUBSCRIPTION_READ GCOFFER_READ CONNECT_READ ATP_WRITE", "jti": "SANITIZED", + "access_token": "SANITIZED", "token_type": "Bearer", "refresh_token": "SANITIZED", + "expires_in": 100707, "refresh_token_expires_in": 2591999}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 885f80825b227abb-SJC + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Sat, 18 May 2024 23:07:11 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=thPZw5vQz%2BHsts6LehoIFSICQ3kxVMYW%2FNd0THiPD%2Bp1y%2FfOMDhpMV8TAWVttLf%2BDMHnx%2FLXs71C6vsZDbhy7tngsRgIHDxay8WzP6kT8cFecEyP4JHHOBYnkATs5Fe1QWdLw5vVEg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_profile_alias.yaml b/garth/tests/cassettes/test_profile_alias.yaml new file mode 100644 index 0000000..e935f67 --- /dev/null +++ b/garth/tests/cassettes/test_profile_alias.yaml @@ -0,0 +1,82 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://connectapi.garmin.com/userprofile-service/socialProfile + response: + body: + string: '{"id": 3154645, "profileId": 2591602, "garminGUID": "0690cc1d-d23d-4412-b027-80fd4ed1c0f6", + "displayName": "mtamizi", "fullName": "Matin Tamizi", "userName": "mtamizi", + "profileImageType": "UPLOADED_PHOTO", "profileImageUrlLarge": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/73240e81-6e4d-43fc-8af8-c8f6c51b3b8f-2591602.png", + "profileImageUrlMedium": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/685a19e9-a7be-4a11-9bf9-faca0c5d1f1a-2591602.png", + "profileImageUrlSmall": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/6302f021-0ec7-4dc9-b0c3-d5a19bc5a08c-2591602.png", + "location": "Ciudad de M\u00e9xico, CDMX", "facebookUrl": null, "twitterUrl": + null, "personalWebsite": null, "motivation": null, "bio": null, "primaryActivity": + null, "favoriteActivityTypes": [], "runningTrainingSpeed": 0.0, "cyclingTrainingSpeed": + 0.0, "favoriteCyclingActivityTypes": [], "cyclingClassification": null, "cyclingMaxAvgPower": + 0.0, "swimmingTrainingSpeed": 0.0, "profileVisibility": "private", "activityStartVisibility": + "private", "activityMapVisibility": "public", "courseVisibility": "public", + "activityHeartRateVisibility": "public", "activityPowerVisibility": "public", + "badgeVisibility": "private", "showAge": false, "showWeight": false, "showHeight": + false, "showWeightClass": false, "showAgeRange": false, "showGender": false, + "showActivityClass": false, "showVO2Max": false, "showPersonalRecords": false, + "showLast12Months": false, "showLifetimeTotals": false, "showUpcomingEvents": + false, "showRecentFavorites": false, "showRecentDevice": false, "showRecentGear": + false, "showBadges": true, "otherActivity": null, "otherPrimaryActivity": + null, "otherMotivation": null, "userRoles": ["SCOPE_ATP_READ", "SCOPE_ATP_WRITE", + "SCOPE_COMMUNITY_COURSE_READ", "SCOPE_COMMUNITY_COURSE_WRITE", "SCOPE_CONNECT_READ", + "SCOPE_CONNECT_WRITE", "SCOPE_DT_CLIENT_ANALYTICS_WRITE", "SCOPE_GARMINPAY_READ", + "SCOPE_GARMINPAY_WRITE", "SCOPE_GCOFFER_READ", "SCOPE_GCOFFER_WRITE", "SCOPE_GHS_SAMD", + "SCOPE_GHS_UPLOAD", "SCOPE_GOLF_API_READ", "SCOPE_GOLF_API_WRITE", "SCOPE_INSIGHTS_READ", + "SCOPE_INSIGHTS_WRITE", "SCOPE_OMT_CAMPAIGN_READ", "SCOPE_OMT_SUBSCRIPTION_READ", + "SCOPE_PRODUCT_SEARCH_READ", "ROLE_CONNECTUSER", "ROLE_FITNESS_USER", "ROLE_WELLNESS_USER", + "ROLE_OUTDOOR_USER", "ROLE_CONNECT_2_USER", "ROLE_TACX_APP_USER"], "nameApproved": + true, "userProfileFullName": "Matin Tamizi", "makeGolfScorecardsPrivate": + true, "allowGolfLiveScoring": false, "allowGolfScoringByConnections": true, + "userLevel": 4, "userPoint": 166, "levelUpdateDate": "2024-01-31T12:18:59.0", + "levelIsViewed": false, "levelPointThreshold": 300, "userPointOffset": 0, + "userPro": false}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8f0d992ebcfb6c34-DFW + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 12 Dec 2024 12:08:11 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=niRDLu7E86gruuRnFLQL4RUQO9vMZyAA5NQ64mt7vW0Gmmsl2%2BCut6v2k9Pj6yXDDr42mqOH%2B%2BvYhVgRbnkLUTD3xXo3YREb7jiUYBGZhBKpRQafvfz0TvC63Co%2BVJCaehygZ%2B9HlA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_put.yaml b/garth/tests/cassettes/test_put.yaml new file mode 100644 index 0000000..0960274 --- /dev/null +++ b/garth/tests/cassettes/test_put.yaml @@ -0,0 +1,133 @@ +interactions: +- request: + body: '[{"changeState": "CHANGED", "trainingMethod": "HR_RESERVE", "lactateThresholdHeartRateUsed": + 170, "maxHeartRateUsed": 185, "restingHrAutoUpdateUsed": false, "sport": "DEFAULT", + "zone1Floor": 130, "zone2Floor": 140, "zone3Floor": 150, "zone4Floor": 160, + "zone5Floor": 170}]' + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Content-Length: + - '272' + Content-Type: + - application/json + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: PUT + uri: https://connectapi.garmin.com/biometric-service/heartRateZones + response: + body: + string: '' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 80f7523e7a572165-MAD + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Sun, 01 Oct 2023 20:05:35 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=CgUHNfj6nCHwLWrYOFgl0OXLp6K6aHVOe5Mh7xn1vbd30JRWu6lJQSC4quw%2FLJFh%2BXkgEOsJ8R2dJ1lX7s1TLQkg5F6rm9mey6S40Yele44L6ykjlVQmfQZPBRBCH7rl%2Bdb%2B0w393g%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 204 + message: No Content +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - ADRUM_BTa=SANITIZED; SameSite=SANITIZED; ADRUM_BT1=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/biometric-service/heartRateZones + response: + body: + string: '[{"trainingMethod": "HR_RESERVE", "restingHeartRateUsed": 42, "lactateThresholdHeartRateUsed": + 170, "zone1Floor": 130, "zone2Floor": 140, "zone3Floor": 150, "zone4Floor": + 160, "zone5Floor": 170, "maxHeartRateUsed": 185, "restingHrAutoUpdateUsed": + false, "sport": "DEFAULT", "changeState": "UNCHANGED"}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 80f752435bf2666b-MAD + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Sun, 01 Oct 2023 20:05:36 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=kkTPrb69Gsx4APeQBgtestcf2%2BIDf9pLcQhn1Bv3hfXr%2FH1B09AZNsqL%2Bk5eQygFQbE0F9pZzdJ1XmqfHBql6tqQX5pTwiDiAHy7jV2hy7qnCZmCtlV3REKoEo%2FZ0oIEtX7vyn7FRg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_refresh_oauth2_token.yaml b/garth/tests/cassettes/test_refresh_oauth2_token.yaml new file mode 100644 index 0000000..c088398 --- /dev/null +++ b/garth/tests/cassettes/test_refresh_oauth2_token.yaml @@ -0,0 +1,193 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - python-requests/2.31.0 + method: GET + uri: https://thegarth.s3.amazonaws.com/oauth_consumer.json + response: + body: + string: '{"consumer_key": "SANITIZED", "consumer_secret": "SANITIZED"}' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '124' + Content-Type: + - application/json + Date: + - Sun, 06 Aug 2023 14:28:00 GMT + ETag: + - '"20240b1013cb35419bb5b2cff1407a4e"' + Last-Modified: + - Thu, 03 Aug 2023 00:16:11 GMT + Server: + - AmazonS3 + x-amz-id-2: + - 9tePW1jJAYQ3uv6MTzPUchn0ZP+JWMF2a9Zc1mB8quIAtuIxVG/I/LUQHhTiZgd8wChW+eR2PA1ATnw0Tkjldw== + x-amz-request-id: + - 07RRD5QKQXX1GET8 + x-amz-server-side-encryption: + - AES256 + status: + code: 200 + message: OK +- request: + body: mfa_token=MFA-1578-9cKDf5iVPDPdBpT3HZtpEhyIZ4Bmger7gIpit5siAlFPGPrVJk-cas + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + Content-Length: + - '73' + Content-Type: + - !!binary | + YXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVk + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: POST + uri: https://connectapi.garmin.com/oauth-service/oauth/exchange/user/2.0 + response: + body: + string: '{"scope": "COMMUNITY_COURSE_READ GARMINPAY_WRITE GOLF_API_READ ATP_READ + GHS_SAMD GHS_UPLOAD INSIGHTS_READ COMMUNITY_COURSE_WRITE CONNECT_WRITE GCOFFER_WRITE + GARMINPAY_READ DT_CLIENT_ANALYTICS_WRITE GOLF_API_WRITE INSIGHTS_WRITE PRODUCT_SEARCH_READ + GCOFFER_READ CONNECT_READ ATP_WRITE", "jti": "SANITIZED", "access_token": + "SANITIZED", "token_type": "Bearer", "refresh_token": "SANITIZED", "expires_in": + 65481, "refresh_token_expires_in": 2591999}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f27f6bfcef57ea5-LAX + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Sun, 06 Aug 2023 14:28:01 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=1gipzcbhAhY0bP2r3RhDsanmOc8Hzo0tPhViR5ht3fD6bJu%2B7FT8M8H333APSe3wQ4WHJUwlX3xu0DvvdK3SbcTDTNWWEf3aMp1wQ0D7llAZ3%2Bjbf1ZBEE53kH2xR%2BCpZRg%2FQwx9fg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/userprofile-service/socialProfile + response: + body: + string: '{"id": 3154645, "profileId": 2591602, "garminGUID": "0690cc1d-d23d-4412-b027-80fd4ed1c0f6", + "displayName": "mtamizi", "fullName": "Matin Tamizi", "userName": "mtamizi", + "profileImageUuid": "73240e81-6e4d-43fc-8af8-c8f6c51b3b8f", "profileImageUrlLarge": + "https://s3.amazonaws.com/garmin-connect-prod/profile_images/73240e81-6e4d-43fc-8af8-c8f6c51b3b8f-2591602.png", + "profileImageUrlMedium": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/685a19e9-a7be-4a11-9bf9-faca0c5d1f1a-2591602.png", + "profileImageUrlSmall": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/6302f021-0ec7-4dc9-b0c3-d5a19bc5a08c-2591602.png", + "location": "Ciudad de M\u00e9xico, CDMX", "facebookUrl": null, "twitterUrl": + null, "personalWebsite": null, "motivation": null, "bio": null, "primaryActivity": + null, "favoriteActivityTypes": [], "runningTrainingSpeed": 0.0, "cyclingTrainingSpeed": + 0.0, "favoriteCyclingActivityTypes": [], "cyclingClassification": null, "cyclingMaxAvgPower": + 0.0, "swimmingTrainingSpeed": 0.0, "profileVisibility": "private", "activityStartVisibility": + "private", "activityMapVisibility": "public", "courseVisibility": "public", + "activityHeartRateVisibility": "public", "activityPowerVisibility": "public", + "badgeVisibility": "private", "showAge": false, "showWeight": false, "showHeight": + false, "showWeightClass": false, "showAgeRange": false, "showGender": false, + "showActivityClass": false, "showVO2Max": false, "showPersonalRecords": false, + "showLast12Months": false, "showLifetimeTotals": false, "showUpcomingEvents": + false, "showRecentFavorites": false, "showRecentDevice": false, "showRecentGear": + false, "showBadges": true, "otherActivity": null, "otherPrimaryActivity": + null, "otherMotivation": null, "userRoles": ["SCOPE_ATP_READ", "SCOPE_ATP_WRITE", + "SCOPE_COMMUNITY_COURSE_READ", "SCOPE_COMMUNITY_COURSE_WRITE", "SCOPE_CONNECT_READ", + "SCOPE_CONNECT_WRITE", "SCOPE_DT_CLIENT_ANALYTICS_WRITE", "SCOPE_GARMINPAY_READ", + "SCOPE_GARMINPAY_WRITE", "SCOPE_GCOFFER_READ", "SCOPE_GCOFFER_WRITE", "SCOPE_GHS_SAMD", + "SCOPE_GHS_UPLOAD", "SCOPE_GOLF_API_READ", "SCOPE_GOLF_API_WRITE", "SCOPE_INSIGHTS_READ", + "SCOPE_INSIGHTS_WRITE", "SCOPE_PRODUCT_SEARCH_READ", "ROLE_CONNECTUSER", "ROLE_FITNESS_USER", + "ROLE_WELLNESS_USER", "ROLE_OUTDOOR_USER", "ROLE_CONNECT_2_USER", "ROLE_TACX_APP_USER"], + "nameApproved": true, "userProfileFullName": "Matin Tamizi", "makeGolfScorecardsPrivate": + true, "allowGolfLiveScoring": false, "allowGolfScoringByConnections": true, + "userLevel": 3, "userPoint": 117, "levelUpdateDate": "2020-12-12T15:20:38.0", + "levelIsViewed": false, "levelPointThreshold": 140, "userPointOffset": 0, + "userPro": false}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f27f6cc6d8ecfb4-SJC + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Sun, 06 Aug 2023 14:28:02 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=vQb1I7nl3NUQFoAFFYc8Ez1h%2Br4sa%2FdhPV%2FmnWwcDKVnx9u5zcZbfNerjOwsMYYxfu60yEfBHhJjfrZuTtiFPW6oJF0TsOcft20SZ2E4CrbOEPJuYqkHg05AR%2BKaWXab1WNJ3csk9Q%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_resume_login.yaml b/garth/tests/cassettes/test_resume_login.yaml new file mode 100644 index 0000000..c898418 --- /dev/null +++ b/garth/tests/cassettes/test_resume_login.yaml @@ -0,0 +1,1018 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + response: + body: + string: "\n\t\n\t GAuth Embedded Version\n\t \n\t \n\t\n\t\n\t\t\n\n
\n\t
\n\tERROR:
+        clientId parameter must be specified!!!\n\n\tUsage: https://sso.garmin.com/sso/embed?clientId=<clientId>&locale=<locale>...\n\n\tRequest
+        parameter configuration options:\n\n\tNAME                           REQ  VALUES
+        \                                                  DESCRIPTION\n\t------------------
+        \            ---  -------------------------------------------------------
+        \ ---------------------------------------------------------------------------------------------------\n\tclientId
+        \                      Yes  \"MY_GARMIN\"/\"BUY_GARMIN\"/\"FLY_GARMIN\"/                   Client
+        identifier for your web application\n\t                                    \"RMA\"/\"GarminConnect\"/\"OpenCaching\"/etc\n\tlocale
+        \                        Yes  \"en\", \"bg\", \"cs\", \"da\", \"de\", \"es\",
+        \"el\", \"fr\", \"hr\",    User's current locale, to display the GAuth login
+        widget internationalized properly.\n\t                                    \"in\",
+        \"it\", \"iw\", \"hu\", \"ms\", \"nb\", \"nl\", \"no\", \"pl\",    (All the
+        currently supported locales are listed in the Values section.)\n\t                                    \"pt\",
+        \"pt_BR\", \"ru\", \"sk\", \"sl\", \"fi\", \"sv\", \"tr\",\n\t                                    \"uk\",
+        \"th\", \"ja\", \"ko\", \"zh_TW\", \"zh\", \"vi_VN\"\n\tcssUrl                          No
+        \ Absolute URL to custom CSS file.                         Use custom CSS
+        styling for the GAuth login widget.\n\treauth                          No
+        \ true/false (Default value is false)                      Specify true if
+        you want to ensure that the GAuth login widget shows up,\n\t                                                                                             even
+        if the SSO infrastructure remembers the user and would immediately log them
+        in.\n\t                                                                                             This
+        is useful if you know a user is logged on, but want a different user to be
+        allowed to logon.\n\tinitialFocus                    No  true/false (Default
+        value is true)                       If you don't want the GAuth login widget
+        to autofocus in it's \"Email or Username\" field upon initial loading,\n\t
+        \                                                                                            then
+        specify this option and set it to false.\n\trememberMeShown                 No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box is shown in the GAuth login widget.\n\trememberMeChecked               No
+        \ true/false (Default value is false)                      Whether the \"Remember
+        Me\" check box feature is checked by default.\n\tcreateAccountShown              No
+        \ true/false (Default value is true)                       Whether the \"Don't
+        have an account? Create One\" link is shown in the GAuth login widget.\n\tsocialEnabled
+        \                  No  true/false (Default value is false)                       If
+        set to false, do not show any social sign in elements or allow social sign
+        ins.\n\tlockToEmailAddress              No  Email address to pre-load and
+        lock.                      If specified, the specified email address will
+        be pre-loaded in the main \"Email\" field in the SSO login form,\n\t                                                                                             as
+        well as in in the \"Email Address\" field in the \"Forgot Password?\" password
+        reset form,\n\t                                                                                             and
+        both fields will be disabled so they can't be changed.\n\t                                                                                             (If
+        for some reason you want to force re-authentications for a known customer
+        account, you can make use of this option.)\n\topenCreateAccount               No
+        \ true/false (Default value is false)                      If set to true,
+        immediately display the the account creation screen.\n\tdisplayNameShown                No
+        \ true/false (Default value is false)                      If set to true,
+        show the \"Display Name\" field on the account creation screen, to allow the
+        user\n\t                                                                                             to
+        set their central MyGarmin display name upon account creation.\n\tglobalOptInShown
+        \               No  true/false (Default value is false)                      Whether
+        the \"Global Opt-In\" check box is shown on the create account & create social
+        account screens.\n\t                                                                                             If
+        set to true these screens will show a \"Sign Up For Email\" check box with
+        accompanying text\n\t                                                                                             \"I
+        would also like to receive email about promotions and new products.\"\n\t
+        \                                                                                            If
+        checked, the Customer 2.0 account that is created will have it's global opt-in
+        flag set to true,\n\t                                                                                             and
+        Garmin email communications will be allowed.\n\tglobalOptInChecked              No
+        \ true/false (Default value is false)                      Whether the \"Global
+        Opt-In\" check box is checked by default.\n\tconsumeServiceTicket            No
+        \ true/false (Default value is true)                       IF you don't specify
+        a redirectAfterAccountLoginUrl AND you set this to false, the GAuth login
+        widget\n\t                                                                                             will
+        NOT consume the service ticket assigned and will not seamlessly log you into
+        your webapp.\n\t                                                                                             It
+        will send a SUCCESS JavaScript event with the service ticket and service url
+        you can take\n\t                                                                                             and
+        explicitly validate against the SSO infrastructure yourself.\n\t                                                                                             (By
+        using casClient's SingleSignOnUtils.authenticateServiceTicket() utility method,\n\t
+        \                                                                                            or
+        calling web service customerWebServices_v1.2 AccountManagementService.authenticateServiceTicket().)\n\tmobile
+        \                         No  true/false (Default value is false)                      Setting
+        to true will cause mobile friendly views to be shown instead of the tradition
+        screens.\n\ttermsOfUseUrl                   No  Absolute URL to your custom
+        terms of use URL.            If not specified, defaults to http://www.garmin.com/terms\n\tprivacyStatementUrl
+        \            No  Absolute URL to your custom privacy statement URL.       If
+        not specified, defaults to http://www.garmin.com/privacy\n\tproductSupportUrl
+        \              No  Absolute URL to your custom product support URL.         If
+        not specified, defaults to http://www.garmin.com/us/support/contact\n\tgenerateExtraServiceTicket
+        \     No  true/false (Default value is false)                      If set
+        to true, generate an extra unconsumed service ticket.\n\t\t                                                                                     (The
+        service ticket validation response will include the extra service ticket.)\n\tgenerateTwoExtraServiceTickets
+        \ No  true/false (Default value is false)                      If set to true,
+        generate two extra unconsumed service tickets.\n\t\t\t\t\t\t\t\t\t \t\t\t
+        \    (The service ticket validation response will include the extra service
+        tickets.)\n\tgenerateNoServiceTicket         No  true/false (Default value
+        is false)                      If you don't want SSO to generate a service
+        ticket at all when logging in to the GAuth login widget.\n                                                                                                     (Useful
+        when allowing logins to static sites that are not SSO enabled and can't consume
+        the service ticket.)\n\tconnectLegalTerms               No  true/false (Default
+        value is false)                      Whether to show the connectLegalTerms
+        on the create account page\n\tshowTermsOfUse                  No  true/false
+        (Default value is false)                      Whether to show the showTermsOfUse
+        on the create account page\n\tshowPrivacyPolicy               No  true/false
+        (Default value is false)                      Whether to show the showPrivacyPolicy
+        on the create account page\n\tshowConnectLegalAge             No  true/false
+        (Default value is false)                      Whether to show the showConnectLegalAge
+        on the create account page\n\tlocationPromptShown             No  true/false
+        (Default value is false)                      If set to true, ask the customer
+        during account creation to verify their country of residence.\n\tshowPassword
+        \                   No  true/false (Default value is true)                       If
+        set to false, mobile version for createAccount and login screens would hide
+        the password\n\tuseCustomHeader                 No  true/false (Default value
+        is false)                      If set to true, the \"Sign in\" text will be
+        replaced by custom text. Contact CDS team to set the i18n text for your client
+        id.\n\tmfaRequired                     No  true/false (Default value is false)
+        \                     Require multi factor authentication for all authenticating
+        users.\n\tperformMFACheck                 No  true/false (Default value is
+        false)                      If set to true, ask the logged in user to pass
+        a multi factor authentication check. (Only valid for an already logged in
+        user.)\n\trememberMyBrowserShown          No  true/false (Default value is
+        false)                      Whether the \"Remember My Browser\" check box
+        is shown in the GAuth login widget MFA verification screen.\n\trememberMyBrowserChecked
+        \       No  true/false (Default value is false)                      Whether
+        the \"Remember My Browser\" check box feature is checked by default.\n\tconsentTypeIds\t\t\t\t\tNo\tconsent_types
+        ids\t\t \t\t\t\t\t\t\t\t multiple consent types ids can be passed as consentTypeIds=type1&consentTypeIds=type2\n\t
\n
\n\n\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-RAY: + - 91f86737ce67e591-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Thu, 13 Mar 2025 03:21:47 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=bxihkdjSWMGVuKwcT8kCuQLhqJQUHexTABdtfozlxL5EzqqvkAPeXJR1QNbRZxRM4I64sQpaTAExproKKXqJplALRPXnC1em2Ywiw1t5nb3buvisUOZ%2FBjR0uFzffdvz"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cf_bm=SANITIZED; path=SANITIZED; expires=SANITIZED; domain=SANITIZED; HttpOnly; + Secure; SameSite=SANITIZED + - __cflb=SANITIZED; SameSite=SANITIZED; Secure; path=SANITIZED; expires=SANITIZED; + HttpOnly + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:6 + X-B3-Traceid: + - 680e42591c55458a4b7d58d0981c37f0 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 680e4259-1c55-458a-4b7d-58d0981c37f0 + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/embed?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso + method: GET + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n \n \n \n \n GARMIN Authentication Application\n + \ \n\n\t \n\n \n + \ \n\t\t\n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n\t\t\n + \ \n + \ \n\n + \ \n \n \n + \ \n\n \n
\n + \ \n
\n \n\t \t \n + \ \n
\n + \

Sign In

\n\n
\n\n
\n\t\t\t\t\t\t\t\n + \ \n \n \n + \ \n \n \n\n + \
\n + \
\n + \
\n
\n\t\t\t\t\t\t\t\n \t\t\n\t\t\t\t\t\t\t \n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t + \ \n\n + \
\n\n
\n + \ \n (Forgot?)\n + \ \n Caps lock is on.\n\t\t\t\t\t
\n \n \n \n \n\n\n + \ \n \n\n
\n + \
\n \n\n \n\t
\n\t + \ \n\t
\n\t \n\n\t \n\t
\n \n\n\t\t\t\t\t\n\t
\n\t + \ \n
+ \n + \
\n \n\n\t\t
\n\t\t\n\n \n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 91f867398a1b6c54-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Thu, 13 Mar 2025 03:21:47 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=V7WzmkXaWvEQIrzw0Z0oSBttZtV%2F0qEJrmi4oZmSrz83XMNgJmiXbWUQBFbmcBA81wTPq%2FtBRP5KffHiyAt6s0EWpvwBINLwuHS7tmW9cywmBp9rD0tY9qh742bY8Ain"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - SESSION=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - __VCAP_ID__=SANITIZED; Path=SANITIZED; HttpOnly; Secure + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:2 + X-B3-Traceid: + - 3615d33aec31436b4d9b3ba859d7ca74 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 3615d33a-ec31-436b-4d9b-3ba859d7ca74 + status: + code: 200 + message: OK +- request: + body: username=SANITIZED&password=SANITIZED&embed=true&_csrf=C522968016DC6CA4734CA50E54BCC865B4B87F09EEE86A99B32B94354A94AD7D5FE744D4AC6966686115E88283652BB45CB4 + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '165' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 91f8673bda226c04-DFW + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Thu, 13 Mar 2025 03:21:49 GMT + Location: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=gfiBAySbYljQ5YR8KHOe6u15s7DJSSozDx9GhPJohHjpDNF0a1uFt6l40PhjuEfQvc%2B1V2%2BnMjKC%2BqfD9VfHUB9BYsirfjaPwY%2F8St6VNJDhPYj29jp6RjvR5wqcVeVz"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - __cfruid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:2 + X-B3-Traceid: + - 29f4187219dd4d8340461cf631b4b146 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 29f41872-19dd-4d83-4046-1cf631b4b146 + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/signin?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: "\n\n\n\n \n + \ \n \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n + \ \n \n Enter + MFA code for login\n \n + \ \n + \ \n \n \n \n\n\n\n
\n

Enter + security code

\n \n \n\n + \
\n
\n \n \n + \ Code sent to fl******@gmail.com\n + \ \n
\n + \
\n
\n \n \n \n + \ \n \n \n
\n + \
\n
\n \n
\n + \
\n

\n
\n + \ Get help
\n
\n + \
\n + \ Request a new code\n + \
\n \n \n + \
\n \n
\n + \ \n
\n \n \n \n + \
\n
\n
\n
\n
\n
\n \n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-RAY: + - 91f867446924b6df-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Thu, 13 Mar 2025 03:21:49 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=z71S7YkpXdjPMiDiyOXsezBUatj0DcHkXPo3L8rAGleQ%2FSt60A6FC42V63wee60bfKfLmKowf6hPSxFrA79Sx0XAtTTcgwIt8myfGYvi2dYNoLyfU3m4wmktasychX1B"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + Transfer-Encoding: + - chunked + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:2 + X-B3-Traceid: + - b078c1e7c12544965b24fdc352f98b26 + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - b078c1e7-c125-4496-5b24-fdc352f98b26 + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +- request: + body: mfa-code=264151&embed=true&_csrf=C522968016DC6CA4734CA50E54BCC865B4B87F09EEE86A99B32B94354A94AD7D5FE744D4AC6966686115E88283652BB45CB4&fromPage=setupEnterMfaCode + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Content-Length: + - '160' + Content-Type: + - application/x-www-form-urlencoded + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: POST + uri: https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + response: + body: + string: '' + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 91f867b18afa576f-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Length: + - '0' + Date: + - Thu, 13 Mar 2025 03:22:16 GMT + Location: + - https://sso.garmin.com/sso/login?logintoken=ymQGzThSUM&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=7%2Fp3peWwzjAo3kZvb0ldefabk82v6AjxCR4aJScOpa3klEehB6cjOUwouHfR0gJue4dDTEISdItt6pkg7nQG%2BSbC2sCgWnXbdvAOW6fhqGWuWNaDq83DhJA142fo0TO4"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:2 + X-B3-Traceid: + - 8d319a270bcc4ca55e0716feb33192ba + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 8d319a27-0bcc-4ca5-5e07-16feb33192ba + status: + code: 302 + message: Found +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + Cookie: + - SESSION=SANITIZED; org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + __cflb=SANITIZED; __VCAP_ID__=SANITIZED; __cf_bm=SANITIZED; _cfuvid=SANITIZED; + __cfruid=SANITIZED + User-Agent: + - GCM-iOS-5.7.2.1 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://sso.garmin.com/sso/login?logintoken=ymQGzThSUM&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&locale=en&embed=true&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&embedWidget=true + response: + body: + string: "\n\n\t\n\t\tSuccess\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\n\t\n\t\t
\n\t\t\t\n\t\t
\n\t\t\n\t\n\n" + headers: + Access-Control-Allow-Credentials: + - 'true' + Access-Control-Allow-Headers: + - Access-Control-Allow-Headers, Origin,Accept, X-Requested-With, Content-Type, + Access-Control-Request-Method, Access-Control-Request-Headers + Access-Control-Allow-Methods: + - GET,POST,OPTIONS + Access-Control-Allow-Origin: + - https://www.garmin.com + CF-Cache-Status: + - DYNAMIC + CF-Ray: + - 91f867ebdb37dccf-QRO + Connection: + - keep-alive + Content-Language: + - en + Content-Type: + - text/html;charset=UTF-8 + Date: + - Thu, 13 Mar 2025 03:22:16 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=i86741uO0SJO%2BOd7PfW9wZT6rh0eI9VSl3chEhcAjzFavcXYapX5GTZ2u19RNGqztggyE6%2FAqdiQ4wdBotyiiOP0ZRaQAncXpIOTWnxrGMfUvneT5y9bPvqXKrsrkklh"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - org.springframework.web.servlet.i18n.CookieLocaleResolver.LOCALE=SANITIZED; + Path=SANITIZED + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + - GARMIN-SSO=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GarminNoCache=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GarminNoCache=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GarminBuyCacheKey=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED + - GARMIN-SSO-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - GARMIN-SSO-CUST-GUID=SANITIZED; Domain=SANITIZED; Path=SANITIZED; Secure + - GARMIN-SSO-CUST-GUID=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Domain=SANITIZED; + Path=SANITIZED; Secure + - CASTGC=SANITIZED; Path=SANITIZED; Secure; HttpOnly + - CASTGC=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; Secure; + HttpOnly + Transfer-Encoding: + - chunked + Vary: + - Accept-Encoding + X-Application-Context: + - casServer:cloud,prod,prod-US_1102:2 + X-B3-Traceid: + - 07c55023566746e26206c422c90cf00f + X-Robots-Tag: + - noindex + X-Vcap-Request-Id: + - 07c55023-5667-46e2-6206-c422c90cf00f + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Connection: + - keep-alive + User-Agent: + - python-requests/2.32.3 + method: GET + uri: https://thegarth.s3.amazonaws.com/oauth_consumer.json + response: + body: + string: '{"consumer_key": "SANITIZED", "consumer_secret": "SANITIZED"}' + headers: + Accept-Ranges: + - bytes + Content-Length: + - '124' + Content-Type: + - application/json + Date: + - Thu, 13 Mar 2025 03:22:18 GMT + ETag: + - '"20240b1013cb35419bb5b2cff1407a4e"' + Last-Modified: + - Thu, 03 Aug 2023 00:16:11 GMT + Server: + - AmazonS3 + x-amz-id-2: + - MBz7VoZLeM3B50zspN38HZlT4arI2OfJnu8fY0hS4wezQrXkzfkNFK+5OnknL8FZ1oRYHfV7ml+ErqF+HJqpDA== + x-amz-request-id: + - 2FAA3J9EMFHD2KYM + x-amz-server-side-encryption: + - AES256 + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: GET + uri: https://connectapi.garmin.com/oauth-service/oauth/preauthorized?ticket=ST-2579345-qeRATEiLFqrrbpepTqea-cas&login-url=https://sso.garmin.com/sso/embed&accepts-mfa-tokens=true + response: + body: + string: oauth_token=SANITIZED&oauth_token_secret=SANITIZED&mfa_token=SANITIZED&mfa_expiration_timestamp=2026-03-13 + 03:22:16.000 + headers: + CF-RAY: + - 91f867f28f673798-QRO + Connection: + - keep-alive + Content-Type: + - text/plain;charset=utf-8 + Date: + - Thu, 13 Mar 2025 03:22:17 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=OmmGNaAchMrJba3EkfByrw4CgT7woQ4B20iytJvXD2%2BJqy3MZcj4yG5pIWD2jeM0RJXcc15wIVcdqyTdpI7KHACx%2BLIbGIJHuaHjUu08Bumx%2FxmbxpLqRyO3ExDTixQuXeRafiH5%2B1l%2FP0Xes3ziSLK3cQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + status: + code: 200 + message: OK +- request: + body: mfa_token=MFA-10963-fvtFwN9S0eCECl1i4lmuZci0UN3fauY54Efa0OpOwryxLeEX6j-cas + headers: + Accept: + - !!binary | + Ki8q + Accept-Encoding: + - !!binary | + Z3ppcCwgZGVmbGF0ZQ== + Authorization: + - Bearer SANITIZED + Connection: + - !!binary | + a2VlcC1hbGl2ZQ== + Content-Length: + - '74' + Content-Type: + - !!binary | + YXBwbGljYXRpb24veC13d3ctZm9ybS11cmxlbmNvZGVk + User-Agent: + - !!binary | + Y29tLmdhcm1pbi5hbmRyb2lkLmFwcHMuY29ubmVjdG1vYmlsZQ== + method: POST + uri: https://connectapi.garmin.com/oauth-service/oauth/exchange/user/2.0 + response: + body: + string: '{"scope": "COMMUNITY_COURSE_READ GARMINPAY_WRITE GOLF_API_READ ATP_READ + GHS_SAMD GHS_UPLOAD INSIGHTS_READ DIVE_API_READ COMMUNITY_COURSE_WRITE CONNECT_WRITE + GCOFFER_WRITE DI_OAUTH_2_AUTHORIZATION_CODE_CREATE GARMINPAY_READ DT_CLIENT_ANALYTICS_WRITE + GOLF_API_WRITE INSIGHTS_WRITE PRODUCT_SEARCH_READ OMT_CAMPAIGN_READ OMT_SUBSCRIPTION_READ + GCOFFER_READ CONNECT_READ ATP_WRITE", "jti": "SANITIZED", "access_token": + "SANITIZED", "token_type": "Bearer", "refresh_token": "SANITIZED", "expires_in": + 96516, "refresh_token_expires_in": 2591999}' + headers: + CF-RAY: + - 91f867f6499a3584-DFW + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 13 Mar 2025 03:22:18 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=wGZL07IXVGwyLs6bKElkAzHDD%2FGMV9CruAgjwvD394rb7Zh88HxjIzHr2xbegGCxgh4itQ%2B4%2BHNSMI0xOocV8m9ahig0eRxxlBeZiaMlesFsTglEuHj%2Fzdj6RO4Uxv1S2GW2TxhVm6mqUfpb8%2BGqEZhuGA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_upload.yaml b/garth/tests/cassettes/test_upload.yaml new file mode 100644 index 0000000..7477fa0 --- /dev/null +++ b/garth/tests/cassettes/test_upload.yaml @@ -0,0 +1,181 @@ +interactions: +- request: + body: !!binary | + LS0yYTllN2ZiNzAxNjU4NzI1M2M0ZmIwNWZhMGFkMzZkOQ0KQ29udGVudC1EaXNwb3NpdGlvbjog + Zm9ybS1kYXRhOyBuYW1lPSJmaWxlIjsgZmlsZW5hbWU9IjEyMTI5MTE1NzI2X0FDVElWSVRZLmZp + dCINCg0KDhB5UpkUAAAuRklUyeVAAAAAAAcDBIwEBIYHBIYBAoQCAoQFAoQAAQAAOXF7xhLKeD// + ////AQDbDP//BEEAADEABQIUBwAChAEBAgMBAAQBAAEAAAAAAAAAAAAAAAAAAAAAAAAAACgK//// + QgAAIAEE/QSGAgKEAAEBAQEBAhHKeD///39/QwAARwEI/QSGAwSGBASGBQSGAAECAQECAgECBgEA + AxHKeD8MAAAAoCAAAAQAAAAJAQIAAxHKeD8MAAAAoCAAAAQAAAAJAQIARAAARgED/QSGAASGAQSG + BBHKeD8xAAAAAwAAAEUAABUAB/0EhgMEhgABAAEBAAQBAhMBAhQBAgURyng/AAAAAAAAAP//RgAA + FwAc/QSGAwSMBwSGCASGDwSGEASGESAHGASMHwSGAgKEBAKEBQKECgKEDQKEFQKLAAECAQECBgEC + CQECCwECEgEAFAEKFgEAFwECGQEAHQYCHgECIAECBhHKeD85cXvG/////////////////////wAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP////8BANsMKAr/////AAAA//////8A + //8F//////////8GEcp4PwAAAAD/////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA/////wEA2wwoCv////8AAAEE/////wD//wX//////////wYRyng/AAAA + AP////////////////////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD///// + /////////////wAAAgj/////AP//Bf//////////BhHKeD8AAAAA/////////////////////wAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP//////////ZAD/////AAADCv////8A + //8F//////////8GEcp4PwAAAAD/////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAA/////wEA4AyhCP////8AAAQM/////wD//wX//////////0cAABYAC/0E + hgABAgEBAgIBAgMBAgQBAgUBAAYBAggBAg4BAg8BAgcRyng//////wMD/////0gAAI0ABf0EhgEE + hgIEhgMEhgABAAgRyng/AHZ3P4CwgD//////AUkAAAIAawEEhgIEhloEhqdABwgChDEChDoChDsC + hAABAgMBAAQBAAUBAQkBAAoBAAsBAAwBAA0BAg4BAg8BAhYBABcBABkBABoBABwBAB4BAB8BACIB + ACMBACQBACYBACkBACoBACsBACwBAC0BAC4BAC8BADABADUBADYBADcBADgBAD8NAEABAEEBAEIB + AEMBAEQBAEUBAEsBAEwBAE0BAFABAFEBAFIBAFMBAFQBAFUBAFcBAF4BAmABAGEBCmIBAGUBAGge + AGsBAGwBAG0BAG4BAG8BAHABAHQBAHUBAHwBAn0BAn4BAH8BAIABAIEBAIIBAIMBAIQBAIUBAIkB + AIoBAIsBAI0BAo4BAo8BApABAJEBAJQBAJUBAJcBAKABAKEBAKMBAKQBAqgBAKoPArEBArIBArMB + ALQBALUBANoBANsBAAkAAAAAoKv//////38AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////9AH8AAAAgEA/wADAwQeMgABAf7/ + Af//AQEBAQEA/wEAAQAB//8BAQAAAAAAAAEAAQABAQEAAgEBAwEBCQEBAQIAAQH/AAMAAgAhBBAO + DAYaAwId/////////////////////////wEBAQEBAQACMgQBAQIAAQIAAQAAAQMAZAEBAQAAAQAA + KAAIBwkNCwwFBg4KAQQAAgMFHgEBAAEBSgAAAwAkHASGHQSGKQSGKgSGBAKEHwKEIAKEIQKEJQKE + JgKEAQEAAwECBQEABgEABwEACAECDAEADQEADgEAEQEAEgEAFQEAGAECHgEAJAECKwEALAECLQEK + LwEANAEANQECNgECOQEAOgEAPAcAPgEACsBdAAAQOgEA/ChFPv////9FA////////30A//8BtgAA + AAABAAAyAgBUAAAAEQoBAAMEAAEAAAAAAAICAUsAAJMAQQAEjAIQBw0EhhIEChQMCkAEhkEEhkYE + hv4ChAoChAsChBUChBkChBoChCAChCEChCIChCMChCgCizcChDgChDkChEkCi1UChAEBAgMBAAQB + AAUBAAYBAAcBAAkBAgwBAg4BAg8BAhABAhEBChMBChgBAB8BAiQBACUHACYHACcHACkHAioBACsB + ACwBCi0BAC4BAC8BADABADIGAjMBADQBADUBAjoBADsBAjwBAD0BAD4BAj8BAEcBAFIBAFYBAFcB + AAvkR3ihSFJNLVBybzo2NzM3NjQAAP////8AAAAAAAAAAAAAAAAAAAAA////////////////AAD/ + ////////////5AwBAHAD//8AAP///////wMA//8AAf///////////wAA//////////////////// + ////////////////////////vwEB//9U5BJ+o90AAAH/////AP//////CwAAAABCZWF0cyBGaXQg + UHJvAAAA/////wAAAAAAAAAAAAAAAAAAAAD///////////////8BAP////////////////////// + /wAA////////BAD///8B////////////AAD///////////////////////////////////////// + //8A//////TUiNzp7wIW//////////////9MAABPACf9BIYQBIYRBIUSBIUTBIUVBIUWBIUZBIYa + BIYdBIYeBIYjBIYkBIUAAoQDAoQIAoQJAoQLAoQMAoQNAoQUAoQXAoMhAoQiAoQlAoMBAQICAQIE + AQAFAQAGAQIHAQEKAQIOAQIPAQIYAQIbAQIcAQIfAQIgAQIMEcp4P0MEN+sHwQwAi70OACTADABP + cAEAIdAeAMBdAAAQOgEAfDIpAGj+ZgCSAizrHTEWAAQzPgMBAH8CqADIAH0AAACY/gAAswAAACa2 + AUa+ASoAGf8MAP//TQAADAANAyAHCgQCAAEAAQEABQEABgEACQECCwEADAECDQEADwEAEwMAFQEA + DVlvZ2EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/1UA/worAQAAAf8A/wD//wFOAAANAEsE + BIYFBIUGBIUfBIYhBIYpBIU2BIZEBIVJEIVKEIVaBIb+AoQCAoQIAoQWAoQgAoRAAoQBAQADAQAH + AQALAQIMAQANAQAOAQAPAQAQAQAVAQAXAQAYAQAbAQAcAQAdAQAeAQAiAQAjAQAkAQAlAQAmAQIn + AQIoAQAqAQIrAQAsAQAtAQAuAQAvAQAwAQAzAQA1AQA3AQA5AQA8AQA+AQA/AQBBAQBCAQBHAQBI + AQBLAQBMAQBOAQBPAQBRAQBSAQBTAQBVAQBWAQJZAQBdAQBeAQBoAQBrAQBsAQB0AQB4AQAOoIYB + AP///3////9/pnQCAP////8bQQAA/////////3////9/////f////3////9/////f////3////9/ + ////f/////8AAEcQbQX//zIaTQAABgAKAAAAAAH//wAA//8AAQAAAP//AR7///8B/////wD/Af8A + AAD///8AAf///////wD///8AAP//TwAABwANEASG/gKEAwKECAKEDwKEAQECAgECBQEABwEACQEA + CgEACwEADAEAD/////8AAMgA/////76oAQEAAQEAQAAAFAAH/QSGdAKEAwECDQEBhgEChwECiAEC + ABHKeD+cGFYi/7BWQQAA6QABAgQNARsBBAAAEsp4P5wYVSL/sFUBHqAPCwATyng/nBhWIv+wVgEI + AAAQABTKeD+cGFci/7BXQgAA4QAO/gSGAASGBgSGAwKEBAKEBwaECAaECQKECgKECwKEDAKEDQKE + AgMKBQECAhTKeD9lCwAAEcp4P////////////////////////wAA////////AAAAAUMAANgADf0E + hgIchgUghgkQhAAChAEChA8ChAYGAgoBAAsBAgwBAg0BAg4BAAMUyng/ywoAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAP////////////////////////////////////////////////////////// + /////9gAAAD//3yJlqOxvgG+AKj/AQoAABgAFcp4P5wYViL/sFYBCkAJIAAWyng/nBhWIv+wVgEE + XgUoABjKeD+cGFki/7BZAcAf8DcAGcp4P5wYWCL/sFgCGcp4PyUPAAAUyng///////////////// + ////////AQD///////8AAAABAxnKeD8gDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////// + ////////////////////////////////////////////////////////2AABAP//fImWo7G+Ab4A + qP8BrsgCOAAayng/cBdYIv+wWAEoZCBAABvKeD9wF1ci/7BXBRvKeD8AAAAAAAQA//8GG8p4Pzlx + e8b/////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//// + /wEA2wwoCv////8AAAD//////wD//wX//////////wYbyng/AAAAAP////////////////////8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AQDbDCgK/////wAAAQT///// + AP//Bf//////////BhvKeD8AAAAA/////////////////////wAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAP//////////////////AAACCP////8A//8F//////////8GG8p4PwAA + AAD/////////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//// + //////9kAP////8AAAMK/////wD//wX//////////wYbyng/AAAAAP////////////////////8A + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD/////AQDgDKEI/////wAABAz///// + AP//Bf//////////AQwADEgBAAAAUAEbAQQAAR6gDwsBEgAAEAEKAAAYAiDKeD9CCwAAGcp4P/// + /////////////////////wIA////////AAAAAQMgyng/PgsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAP///////////////////////////////////////////////////////////////9gAAgD/ + /3yJlqOxvgG+AKj/BSHKeD/YAAAAMAMB//9EAACMADv9BIYCBIUDBIUFBIUGBIUHBIUVBIUYBIUa + BIUbBIUcBIUdBIUgBIUjBIYkBIYlBIUmBIUnBIUoBIUwBIY2BIUJAoQKAoQOAoQPAoQQAoQrAoMs + AoMtAoM3AoQ5AoQ6AoQAAQIBAQIEAQIIAQELAQAMAQANAQIRAQESAQITAQIUAQIWAQIXAQIZAQIe + AQEfAQEhAQIiAQApAQAqAQIuAQIxAQIyAQIzAQA0AQA1AQI4AQIEIcp4P8QUAADEFAAAn9MEAKJD + AQAAAAAA+KYVALXAGwDEFAAAAAAAAAAAAAAAAAAAAAAgTucmAAD/////xBQAAAAAAADEFAAAAAAA + AMF1eD8AAAAAAQCn8AAAAAAAAAAAAAAAAAAA/////1oAAAAKKwAAARQAEgAZnP8AAAD/Av//AP8A + CkcAABIAdP0EhgIEhgMEhQQEhQcEhggEhgkEhgoEhh0EhR4EhR8EhSAEhSYEhScEhSkEhjAEhk4E + hm4gB3AEhnQEAnUEAnYEAncEAngEhHkEhHwEhn0EhpgEhqgEhbUEiLsEiP4ChAsChA4ChA8ChBQC + hBUChBYChBcChBkChBoChCEChCIChCMChCQChCUChCoChCwChC0ChC8ChE8ChFAChFkChFoChFsC + hGoChGsChGwChHEChIQChIUChIYChJcChJ0ChJ4ChKkChKoChLEChLIChLMChLQChL0ChL4ChMQC + hAABAAEBAAUBAAYBABABAhEBAhIBAhMBAhgBAhsBAhwBACsBAC4BADkBAToBAVEBAFwBAl0BAl4B + AmUBAmYBAmcBAmgBAmkBAm0BAnIBAXMBAXoCAnsCAokBAooCApYBAbgBALwBAMABAsEBAsIBAsMB + AscBAsgBAskBAsoBAgchyng/Ecp4P////3////9/zCUAAMwlAAD/////AAAAAP///3////9///// + f////3////9/////f///////////zCUAAFlvZ2EAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ////////////////////////////////////////////////AAAAAMQUAAD//////////wAAAQD/ + //////////////8AAAMA/////////////////////////////////////wAA//////////////// + AwD/////////////AQD/////nBhwFwAACQEKK1dZ//8A/wD//yIiAP///////////39//////wAS + ACIAAP///z7//z//AyHKeD8pJQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA//////////////// + ////////////////////////////////////////////////EgAAAP//fImWo7G+Ab4AqP9IAAAi + AAn9BIYABIYFBIYBAoQCAQADAQAEAQAGAQIHAQIIIcp4P8wlAADBdXg/AQAAGgH//z81DQotLTJh + OWU3ZmI3MDE2NTg3MjUzYzRmYjA1ZmEwYWQzNmQ5LS0NCg== + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Content-Length: + - '5449' + Content-Type: + - multipart/form-data; boundary=2a9e7fb7016587253c4fb05fa0ad36d9 + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: POST + uri: https://connectapi.garmin.com/upload-service/upload + response: + body: + string: '{"detailedImportResult": {"uploadId": 212157427938, "uploadUuid": {"uuid": + "6e56051d-1dd4-4f2c-b8ba-00a1a7d82eb3"}, "owner": 2591602, "fileSize": 5289, + "processingTime": 36, "creationDate": "2023-09-29 01:58:19.113 GMT", "ipAddress": + null, "fileName": "12129115726_ACTIVITY.fit", "report": null, "successes": + [], "failures": []}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 80e09ed13b9a2e61-DFW + Connection: + - keep-alive + Content-Length: + - '306' + Content-Type: + - application/json + Date: + - Fri, 29 Sep 2023 01:58:19 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=quFuhjwXbu43jBRTUG6ygPyLzpTrl7hb9J0FKhbc18TnrdjIvIWV8RmYcKVuXmw6QNmCb9E7IxGdoO0h1zUCKS0JhGmlfUxPi39dpZ%2Fz80FyuPPGQSSsSBY9SmgJAWComnBkN5LiNw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + location: + - https://connectapi.garmin.com/activity-service/activity/status/1695952699113/6e56051d1dd44f2cb8ba00a1a7d82eb3 + location-in-milliseconds: + - '1000' + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 202 + message: Accepted +version: 1 diff --git a/garth/tests/cassettes/test_user_profile.yaml b/garth/tests/cassettes/test_user_profile.yaml new file mode 100644 index 0000000..9c1b23e --- /dev/null +++ b/garth/tests/cassettes/test_user_profile.yaml @@ -0,0 +1,105 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://connectapi.garmin.com/userprofile-service/socialProfile + response: + body: + string: '{"id": 3154645, "profileId": 2591602, "garminGUID": "0690cc1d-d23d-4412-b027-80fd4ed1c0f6", + "displayName": "mtamizi", "fullName": "Matin Tamizi", "userName": "mtamizi", + "profileImageType": "UPLOADED_PHOTO", "profileImageUrlLarge": + "https://s3.amazonaws.com/garmin-connect-prod/profile_images/73240e81-6e4d-43fc-8af8-c8f6c51b3b8f-2591602.png", + "profileImageUrlMedium": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/685a19e9-a7be-4a11-9bf9-faca0c5d1f1a-2591602.png", + "profileImageUrlSmall": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/6302f021-0ec7-4dc9-b0c3-d5a19bc5a08c-2591602.png", + "location": "Ciudad de M\u00e9xico, CDMX", "facebookUrl": null, "twitterUrl": + null, "personalWebsite": null, "motivation": null, "bio": null, "primaryActivity": + null, "favoriteActivityTypes": [], "runningTrainingSpeed": 0.0, "cyclingTrainingSpeed": + 0.0, "favoriteCyclingActivityTypes": [], "cyclingClassification": null, "cyclingMaxAvgPower": + 0.0, "swimmingTrainingSpeed": 0.0, "profileVisibility": "private", "activityStartVisibility": + "private", "activityMapVisibility": "public", "courseVisibility": "public", + "activityHeartRateVisibility": "public", "activityPowerVisibility": "public", + "badgeVisibility": "private", "showAge": false, "showWeight": false, "showHeight": + false, "showWeightClass": false, "showAgeRange": false, "showGender": false, + "showActivityClass": false, "showVO2Max": false, "showPersonalRecords": false, + "showLast12Months": false, "showLifetimeTotals": false, "showUpcomingEvents": + false, "showRecentFavorites": false, "showRecentDevice": false, "showRecentGear": + false, "showBadges": true, "otherActivity": null, "otherPrimaryActivity": + null, "otherMotivation": null, "userRoles": ["SCOPE_ATP_READ", "SCOPE_ATP_WRITE", + "SCOPE_COMMUNITY_COURSE_READ", "SCOPE_COMMUNITY_COURSE_WRITE", "SCOPE_CONNECT_READ", + "SCOPE_CONNECT_WRITE", "SCOPE_DT_CLIENT_ANALYTICS_WRITE", "SCOPE_GARMINPAY_READ", + "SCOPE_GARMINPAY_WRITE", "SCOPE_GCOFFER_READ", "SCOPE_GCOFFER_WRITE", "SCOPE_GHS_SAMD", + "SCOPE_GHS_UPLOAD", "SCOPE_GOLF_API_READ", "SCOPE_GOLF_API_WRITE", "SCOPE_INSIGHTS_READ", + "SCOPE_INSIGHTS_WRITE", "SCOPE_PRODUCT_SEARCH_READ", "ROLE_CONNECTUSER", "ROLE_FITNESS_USER", + "ROLE_WELLNESS_USER", "ROLE_OUTDOOR_USER", "ROLE_CONNECT_2_USER", "ROLE_TACX_APP_USER"], + "nameApproved": true, "userProfileFullName": "Matin Tamizi", "makeGolfScorecardsPrivate": + true, "allowGolfLiveScoring": false, "allowGolfScoringByConnections": true, + "userLevel": 3, "userPoint": 118, "levelUpdateDate": "2020-12-12T15:20:38.0", + "levelIsViewed": false, "levelPointThreshold": 140, "userPointOffset": 0, + "userPro": false}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8151c9a72daf49d9-MFE + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 12 Oct 2023 19:35:44 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=R8lDBzpYOR3%2FKDhkcX7x9WXPLE2Ta1MmqgZzYqack%2F9HmkidgIW8z0cDhgWQ6rWprYuN3oyv%2FS5AGsx8HRk8jJf7qR%2B6ogw0VgKh%2BXZXH83duGw3x3g492pKPeIj6hazTlIxSeK6HA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_user_settings.yaml b/garth/tests/cassettes/test_user_settings.yaml new file mode 100644 index 0000000..86c23dc --- /dev/null +++ b/garth/tests/cassettes/test_user_settings.yaml @@ -0,0 +1,92 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://connectapi.garmin.com/userprofile-service/userprofile/user-settings + response: + body: + string: '{"id": 2591602, "userData": {"gender": "MALE", "weight": 83000.0, "height": + 182.0, "timeFormat": "time_twenty_four_hr", "birthDate": "2000-01-01", "measurementSystem": + "metric", "activityLevel": null, "handedness": "RIGHT", "powerFormat": {"formatId": + 30, "formatKey": "watt", "minFraction": 0, "maxFraction": 0, "groupingUsed": + true, "displayFormat": null}, "heartRateFormat": {"formatId": 21, "formatKey": + "bpm", "minFraction": 0, "maxFraction": 0, "groupingUsed": false, "displayFormat": + null}, "firstDayOfWeek": {"dayId": 2, "dayName": "sunday", "sortOrder": 2, + "isPossibleFirstDay": true}, "vo2MaxRunning": 45.0, "vo2MaxCycling": null, + "lactateThresholdSpeed": 0.34722125000000004, "lactateThresholdHeartRate": + null, "diveNumber": null, "intensityMinutesCalcMethod": "AUTO", "moderateIntensityMinutesHrZone": + 3, "vigorousIntensityMinutesHrZone": 4, "hydrationMeasurementUnit": "milliliter", + "hydrationContainers": [], "hydrationAutoGoalEnabled": true, "firstbeatMaxStressScore": + null, "firstbeatCyclingLtTimestamp": null, "firstbeatRunningLtTimestamp": + 1044719868, "thresholdHeartRateAutoDetected": true, "ftpAutoDetected": null, + "trainingStatusPausedDate": null, "weatherLocation": null, "golfDistanceUnit": + "statute_us", "golfElevationUnit": null, "golfSpeedUnit": null, "externalBottomTime": + null}, "userSleep": {"sleepTime": 80400, "defaultSleepTime": false, "wakeTime": + 24000, "defaultWakeTime": false}, "connectDate": null, "sourceType": null}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8151c6bdebf649df-MFE + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 12 Oct 2023 19:33:45 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=Mi%2Fn%2B7ExcrekhLBUA3vIWTc6xe5E0cMSeFdwGALv%2FKUypkIKnfCikzoAsV5BFgVarsRYtmB0Um640X9SA9p0dMp%2F1saQUEs7VRjVvLn4W0I2%2FLTw5qKr6A1w%2BN8x3SWzFXZX5dojfA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_user_settings_sleep_windows.yaml b/garth/tests/cassettes/test_user_settings_sleep_windows.yaml new file mode 100644 index 0000000..e141213 --- /dev/null +++ b/garth/tests/cassettes/test_user_settings_sleep_windows.yaml @@ -0,0 +1,116 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + referer: + - https://sso.garmin.com/sso/verifyMFA/loginEnterMfaCode?id=gauth-widget&embedWidget=true&gauthHost=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&service=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&source=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountLoginUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed&redirectAfterAccountCreationUrl=https%3A%2F%2Fsso.garmin.com%2Fsso%2Fembed + method: GET + uri: https://connectapi.garmin.com/userprofile-service/userprofile/user-settings + response: + body: + string: '{"id": 2591602, "userData": {"gender": "MALE", "weight": 83000.0, "height": + 182.0, "timeFormat": "time_twenty_four_hr", "birthDate": "2000-01-01", "measurementSystem": + "metric", "activityLevel": null, "handedness": "RIGHT", "powerFormat": {"formatId": + 30, "formatKey": "watt", "minFraction": 0, "maxFraction": 0, "groupingUsed": + true, "displayFormat": null}, "heartRateFormat": {"formatId": 21, "formatKey": + "bpm", "minFraction": 0, "maxFraction": 0, "groupingUsed": false, "displayFormat": + null}, "firstDayOfWeek": {"dayId": 2, "dayName": "sunday", "sortOrder": 2, + "isPossibleFirstDay": true}, "vo2MaxRunning": 45.0, "vo2MaxCycling": null, + "lactateThresholdSpeed": 0.34722125000000004, "lactateThresholdHeartRate": + null, "diveNumber": null, "intensityMinutesCalcMethod": "AUTO", "moderateIntensityMinutesHrZone": + 3, "vigorousIntensityMinutesHrZone": 4, "hydrationMeasurementUnit": "milliliter", + "hydrationContainers": [], "hydrationAutoGoalEnabled": true, "firstbeatMaxStressScore": + null, "firstbeatCyclingLtTimestamp": null, "firstbeatRunningLtTimestamp": + 1044719868, "thresholdHeartRateAutoDetected": true, "ftpAutoDetected": null, + "trainingStatusPausedDate": null, "weatherLocation": null, "golfDistanceUnit": + "statute_us", "golfElevationUnit": null, "golfSpeedUnit": null, "externalBottomTime": + null}, "userSleep": {"sleepTime": 80400, "defaultSleepTime": false, "wakeTime": + 24000, "defaultWakeTime": false}, "connectDate": null, "sourceType": null, + "userSleepWindows": [{"sleepWindowFrequency": "SUNDAY", + "startSleepTimeSecondsFromMidnight": 77400, + "endSleepTimeSecondsFromMidnight": 19800}, + {"sleepWindowFrequency": "MONDAY", + "startSleepTimeSecondsFromMidnight": 77400, + "endSleepTimeSecondsFromMidnight": 19800}, + {"sleepWindowFrequency": "TUESDAY", + "startSleepTimeSecondsFromMidnight": 77400, + "endSleepTimeSecondsFromMidnight": 19800}, + {"sleepWindowFrequency": "WEDNESDAY", + "startSleepTimeSecondsFromMidnight": 77400, + "endSleepTimeSecondsFromMidnight": 19800}, + {"sleepWindowFrequency": "THURSDAY", + "startSleepTimeSecondsFromMidnight": 77400, + "endSleepTimeSecondsFromMidnight": 19800}, + {"sleepWindowFrequency": "FRIDAY", + "startSleepTimeSecondsFromMidnight": 77400, + "endSleepTimeSecondsFromMidnight": 19800}, + {"sleepWindowFrequency": "SATURDAY", + "startSleepTimeSecondsFromMidnight": 77400, + "endSleepTimeSecondsFromMidnight": 19800}, + {"sleepWindowFrequency": "DAILY", + "startSleepTimeSecondsFromMidnight": 77400, + "endSleepTimeSecondsFromMidnight": 19800}]}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 8151c6bdebf649df-MFE + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 12 Oct 2023 19:33:45 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=Mi%2Fn%2B7ExcrekhLBUA3vIWTc6xe5E0cMSeFdwGALv%2FKUypkIKnfCikzoAsV5BFgVarsRYtmB0Um640X9SA9p0dMp%2F1saQUEs7VRjVvLn4W0I2%2FLTw5qKr6A1w%2BN8x3SWzFXZX5dojfA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/cassettes/test_username.yaml b/garth/tests/cassettes/test_username.yaml new file mode 100644 index 0000000..9c4668d --- /dev/null +++ b/garth/tests/cassettes/test_username.yaml @@ -0,0 +1,91 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/userprofile-service/socialProfile + response: + body: + string: '{"id": 3154645, "profileId": 2591602, "garminGUID": "0690cc1d-d23d-4412-b027-80fd4ed1c0f6", + "displayName": "mtamizi", "fullName": "Matin Tamizi", "userName": "mtamizi", + "profileImageUuid": "73240e81-6e4d-43fc-8af8-c8f6c51b3b8f", "profileImageUrlLarge": + "https://s3.amazonaws.com/garmin-connect-prod/profile_images/73240e81-6e4d-43fc-8af8-c8f6c51b3b8f-2591602.png", + "profileImageUrlMedium": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/685a19e9-a7be-4a11-9bf9-faca0c5d1f1a-2591602.png", + "profileImageUrlSmall": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/6302f021-0ec7-4dc9-b0c3-d5a19bc5a08c-2591602.png", + "location": "Ciudad de M\u00e9xico, CDMX", "facebookUrl": null, "twitterUrl": + null, "personalWebsite": null, "motivation": null, "bio": null, "primaryActivity": + null, "favoriteActivityTypes": [], "runningTrainingSpeed": 0.0, "cyclingTrainingSpeed": + 0.0, "favoriteCyclingActivityTypes": [], "cyclingClassification": null, "cyclingMaxAvgPower": + 0.0, "swimmingTrainingSpeed": 0.0, "profileVisibility": "private", "activityStartVisibility": + "private", "activityMapVisibility": "public", "courseVisibility": "public", + "activityHeartRateVisibility": "public", "activityPowerVisibility": "public", + "badgeVisibility": "private", "showAge": false, "showWeight": false, "showHeight": + false, "showWeightClass": false, "showAgeRange": false, "showGender": false, + "showActivityClass": false, "showVO2Max": false, "showPersonalRecords": false, + "showLast12Months": false, "showLifetimeTotals": false, "showUpcomingEvents": + false, "showRecentFavorites": false, "showRecentDevice": false, "showRecentGear": + false, "showBadges": true, "otherActivity": null, "otherPrimaryActivity": + null, "otherMotivation": null, "userRoles": ["SCOPE_ATP_READ", "SCOPE_ATP_WRITE", + "SCOPE_COMMUNITY_COURSE_READ", "SCOPE_COMMUNITY_COURSE_WRITE", "SCOPE_CONNECT_READ", + "SCOPE_CONNECT_WRITE", "SCOPE_DT_CLIENT_ANALYTICS_WRITE", "SCOPE_GARMINPAY_READ", + "SCOPE_GARMINPAY_WRITE", "SCOPE_GCOFFER_READ", "SCOPE_GCOFFER_WRITE", "SCOPE_GHS_SAMD", + "SCOPE_GHS_UPLOAD", "SCOPE_GOLF_API_READ", "SCOPE_GOLF_API_WRITE", "SCOPE_INSIGHTS_READ", + "SCOPE_INSIGHTS_WRITE", "SCOPE_PRODUCT_SEARCH_READ", "ROLE_CONNECTUSER", "ROLE_FITNESS_USER", + "ROLE_WELLNESS_USER", "ROLE_OUTDOOR_USER", "ROLE_CONNECT_2_USER", "ROLE_TACX_APP_USER"], + "nameApproved": true, "userProfileFullName": "Matin Tamizi", "makeGolfScorecardsPrivate": + true, "allowGolfLiveScoring": false, "allowGolfScoringByConnections": true, + "userLevel": 3, "userPoint": 117, "levelUpdateDate": "2020-12-12T15:20:38.0", + "levelIsViewed": false, "levelPointThreshold": 140, "userPointOffset": 0, + "userPro": false}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d41c38a11557-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:54:20 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=G2IB1TvEJWwpf1qx1pmxuSXoRW%2FSZEU8HyTOlPTBTCyG2dipRZTZe8A9ulowoM3j%2F6hYqLLs1uU2ifU%2FnZpB2j2uzj6ePqBlmx4IjtlABarp0HGJAvv98zpC%2F5t8DFDPLSS58dBYsA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/conftest.py b/garth/tests/conftest.py new file mode 100644 index 0000000..ea1c565 --- /dev/null +++ b/garth/tests/conftest.py @@ -0,0 +1,169 @@ +import gzip +import io +import json +import os +import re +import time + +import pytest +from requests import Session + +from garth.auth_tokens import OAuth1Token, OAuth2Token +from garth.http import Client + + +@pytest.fixture +def session(): + return Session() + + +@pytest.fixture +def client(session) -> Client: + return Client(session=session) + + +@pytest.fixture +def oauth1_token_dict() -> dict: + return dict( + oauth_token="7fdff19aa9d64dda83e9d7858473aed1", + oauth_token_secret="49919d7c4c8241ac93fb4345886fbcea", + mfa_token="ab316f8640f3491f999f3298f3d6f1bb", + mfa_expiration_timestamp="2024-08-02 05:56:10.000", + domain="garmin.com", + ) + + +@pytest.fixture +def oauth1_token(oauth1_token_dict) -> OAuth1Token: + return OAuth1Token(**oauth1_token_dict) + + +@pytest.fixture +def oauth2_token_dict() -> dict: + return dict( + scope="CONNECT_READ CONNECT_WRITE", + jti="foo", + token_type="Bearer", + access_token="bar", + refresh_token="baz", + expires_in=3599, + refresh_token_expires_in=7199, + ) + + +@pytest.fixture +def oauth2_token(oauth2_token_dict: dict) -> OAuth2Token: + token = OAuth2Token( + expires_at=int(time.time() + 3599), + refresh_token_expires_at=int(time.time() + 7199), + **oauth2_token_dict, + ) + return token + + +@pytest.fixture +def authed_client( + oauth1_token: OAuth1Token, oauth2_token: OAuth2Token +) -> Client: + client = Client() + try: + client.load(os.environ["GARTH_HOME"]) + except KeyError: + client.configure(oauth1_token=oauth1_token, oauth2_token=oauth2_token) + assert client.oauth2_token and isinstance(client.oauth2_token, OAuth2Token) + assert not client.oauth2_token.expired + return client + + +@pytest.fixture +def vcr(vcr): + if "GARTH_HOME" not in os.environ: + vcr.record_mode = "none" + return vcr + + +def sanitize_cookie(cookie_value) -> str: + return re.sub(r"=[^;]*", "=SANITIZED", cookie_value) + + +def sanitize_request(request): + if request.body: + try: + body = request.body.decode("utf8") + except UnicodeDecodeError: + ... + else: + for key in ["username", "password", "refresh_token"]: + body = re.sub(key + r"=[^&]*", f"{key}=SANITIZED", body) + request.body = body.encode("utf8") + + if "Cookie" in request.headers: + cookies = request.headers["Cookie"].split("; ") + sanitized_cookies = [sanitize_cookie(cookie) for cookie in cookies] + request.headers["Cookie"] = "; ".join(sanitized_cookies) + return request + + +def sanitize_response(response): + try: + encoding = response["headers"].pop("Content-Encoding") + except KeyError: + ... + else: + if encoding[0] == "gzip": + body = response["body"]["string"] + buffer = io.BytesIO(body) + try: + body = gzip.GzipFile(fileobj=buffer).read() + except gzip.BadGzipFile: # pragma: no cover + ... + else: + response["body"]["string"] = body + + for key in ["set-cookie", "Set-Cookie"]: + if key in response["headers"]: + cookies = response["headers"][key] + sanitized_cookies = [sanitize_cookie(cookie) for cookie in cookies] + response["headers"][key] = sanitized_cookies + + try: + body = response["body"]["string"].decode("utf8") + except UnicodeDecodeError: + pass + else: + patterns = [ + "oauth_token=[^&]*", + "oauth_token_secret=[^&]*", + "mfa_token=[^&]*", + ] + for pattern in patterns: + body = re.sub(pattern, pattern.split("=")[0] + "=SANITIZED", body) + try: + body_json = json.loads(body) + except json.JSONDecodeError: + pass + else: + if body_json and isinstance(body_json, dict): + for field in [ + "access_token", + "refresh_token", + "jti", + "consumer_key", + "consumer_secret", + ]: + if field in body_json: + body_json[field] = "SANITIZED" + + body = json.dumps(body_json) + response["body"]["string"] = body.encode("utf8") + + return response + + +@pytest.fixture(scope="session") +def vcr_config(): + return { + "filter_headers": [("Authorization", "Bearer SANITIZED")], + "before_record_request": sanitize_request, + "before_record_response": sanitize_response, + } diff --git a/garth/tests/data/cassettes/test_body_battery_data_get.yaml b/garth/tests/data/cassettes/test_body_battery_data_get.yaml new file mode 100644 index 0000000..9d479de --- /dev/null +++ b/garth/tests/data/cassettes/test_body_battery_data_get.yaml @@ -0,0 +1,35 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/bodyBattery/events/2023-07-20 + response: + body: + string: '[{"event": {"eventType": "sleep", "eventStartTimeGmt": "2023-07-19T21:30:00.000", + "timezoneOffset": -25200000, "durationInMilliseconds": 28800000, "bodyBatteryImpact": 35, + "feedbackType": "good_sleep", "shortFeedback": "Good sleep restored your Body Battery"}, + "activityName": null, "activityType": null, "activityId": null, "averageStress": 15.5, + "stressValuesArray": [[1689811800000, 12], [1689812100000, 18], [1689812400000, 15]], + "bodyBatteryValuesArray": [[1689811800000, "charging", 45, 1.0], [1689812100000, "charging", 48, 1.0], + [1689812400000, "charging", 52, 1.0], [1689840600000, "draining", 85, 1.0]]}]' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 20 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_body_battery_data_list.yaml b/garth/tests/data/cassettes/test_body_battery_data_list.yaml new file mode 100644 index 0000000..7ee451f --- /dev/null +++ b/garth/tests/data/cassettes/test_body_battery_data_list.yaml @@ -0,0 +1,90 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/bodyBattery/events/2023-07-20 + response: + body: + string: '[{"event": {"eventType": "sleep", "eventStartTimeGmt": "2023-07-19T21:30:00.000", + "timezoneOffset": -25200000, "durationInMilliseconds": 28800000, "bodyBatteryImpact": 35, + "feedbackType": "good_sleep", "shortFeedback": "Good sleep restored your Body Battery"}, + "activityName": null, "activityType": null, "activityId": null, "averageStress": 15.5, + "stressValuesArray": [[1689811800000, 12], [1689812100000, 18]], + "bodyBatteryValuesArray": [[1689811800000, "charging", 45, 1.0], [1689840600000, "draining", 85, 1.0]]}]' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 20 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/bodyBattery/events/2023-07-19 + response: + body: + string: '[]' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 19 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/bodyBattery/events/2023-07-18 + response: + body: + string: '[{"event": null, "activityName": "Running", "activityType": "running", + "activityId": "12345", "averageStress": 45.2, "stressValuesArray": [], + "bodyBatteryValuesArray": [[1689667200000, "draining", 75, 1.0], [1689670800000, "draining", 65, 1.0]]}]' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Tue, 18 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_body_battery_properties_edge_cases.yaml b/garth/tests/data/cassettes/test_body_battery_properties_edge_cases.yaml new file mode 100644 index 0000000..7c35970 --- /dev/null +++ b/garth/tests/data/cassettes/test_body_battery_properties_edge_cases.yaml @@ -0,0 +1,33 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailyStress/2023-07-20 + response: + body: + string: '{"userProfilePK": 2591602, "calendarDate": "2023-07-20", + "startTimestampGMT": "2023-07-20T06:00:00.000Z", "endTimestampGMT": "2023-07-21T05:59:59.999Z", + "startTimestampLocal": "2023-07-19T23:00:00.000Z", "endTimestampLocal": "2023-07-20T22:59:59.999Z", + "maxStressLevel": 0, "avgStressLevel": 0, "stressChartValueOffset": 0, "stressChartYAxisOrigin": 0, + "stressValuesArray": [], "bodyBatteryValuesArray": []}' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 20 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_daily_body_battery_stress_get.yaml b/garth/tests/data/cassettes/test_daily_body_battery_stress_get.yaml new file mode 100644 index 0000000..23a25d0 --- /dev/null +++ b/garth/tests/data/cassettes/test_daily_body_battery_stress_get.yaml @@ -0,0 +1,41 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailyStress/2023-07-20 + response: + body: + string: '{"userProfilePK": 2591602, "calendarDate": "2023-07-20", + "startTimestampGMT": "2023-07-20T06:00:00.000Z", "endTimestampGMT": "2023-07-21T05:59:59.999Z", + "startTimestampLocal": "2023-07-19T23:00:00.000Z", "endTimestampLocal": "2023-07-20T22:59:59.999Z", + "maxStressLevel": 85, "avgStressLevel": 25, "stressChartValueOffset": 0, "stressChartYAxisOrigin": 0, + "stressValuesArray": [[1689811800000, 12], [1689812100000, 18], [1689812400000, 15], + [1689815700000, 45], [1689819300000, 85], [1689822900000, 35], [1689826500000, 20], + [1689830100000, 15], [1689833700000, 25], [1689837300000, 30]], + "bodyBatteryValuesArray": [[1689811800000, "charging", 45, 1.0], [1689812100000, "charging", 48, 1.0], + [1689812400000, "charging", 52, 1.0], [1689815700000, "charging", 65, 1.0], + [1689819300000, "draining", 85, 1.0], [1689822900000, "draining", 75, 1.0], + [1689826500000, "draining", 65, 1.0], [1689830100000, "draining", 55, 1.0], + [1689833700000, "draining", 45, 1.0], [1689837300000, "draining", 35, 1.0], + [1689840900000, "draining", 25, 1.0]]}' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 20 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_daily_body_battery_stress_get_no_data.yaml b/garth/tests/data/cassettes/test_daily_body_battery_stress_get_no_data.yaml new file mode 100644 index 0000000..1e0d5e0 --- /dev/null +++ b/garth/tests/data/cassettes/test_daily_body_battery_stress_get_no_data.yaml @@ -0,0 +1,29 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailyStress/2020-01-01 + response: + body: + string: 'null' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Wed, 01 Jan 2020 12:00:00 GMT + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_daily_body_battery_stress_list.yaml b/garth/tests/data/cassettes/test_daily_body_battery_stress_list.yaml new file mode 100644 index 0000000..4fd8e93 --- /dev/null +++ b/garth/tests/data/cassettes/test_daily_body_battery_stress_list.yaml @@ -0,0 +1,93 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailyStress/2023-07-20 + response: + body: + string: '{"userProfilePK": 2591602, "calendarDate": "2023-07-20", + "startTimestampGMT": "2023-07-20T06:00:00.000Z", "endTimestampGMT": "2023-07-21T05:59:59.999Z", + "startTimestampLocal": "2023-07-19T23:00:00.000Z", "endTimestampLocal": "2023-07-20T22:59:59.999Z", + "maxStressLevel": 85, "avgStressLevel": 25, "stressChartValueOffset": 0, "stressChartYAxisOrigin": 0, + "stressValuesArray": [[1689811800000, 12], [1689812100000, 18]], + "bodyBatteryValuesArray": [[1689811800000, "charging", 45, 1.0], [1689840900000, "draining", 25, 1.0]]}' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Thu, 20 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailyStress/2023-07-19 + response: + body: + string: '{"userProfilePK": 2591602, "calendarDate": "2023-07-19", + "startTimestampGMT": "2023-07-19T06:00:00.000Z", "endTimestampGMT": "2023-07-20T05:59:59.999Z", + "startTimestampLocal": "2023-07-18T23:00:00.000Z", "endTimestampLocal": "2023-07-19T22:59:59.999Z", + "maxStressLevel": 65, "avgStressLevel": 30, "stressChartValueOffset": 0, "stressChartYAxisOrigin": 0, + "stressValuesArray": [[1689725400000, 25], [1689729000000, 40]], + "bodyBatteryValuesArray": [[1689725400000, "draining", 80, 1.0], [1689754200000, "charging", 30, 1.0]]}' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Wed, 19 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailyStress/2023-07-18 + response: + body: + string: 'null' + headers: + Content-Type: + - application/json;charset=UTF-8 + Date: + - Tue, 18 Jul 2023 12:00:00 GMT + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_get_daily_weight_data.yaml b/garth/tests/data/cassettes/test_get_daily_weight_data.yaml new file mode 100644 index 0000000..3208c6c --- /dev/null +++ b/garth/tests/data/cassettes/test_get_daily_weight_data.yaml @@ -0,0 +1,58 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://connectapi.garmin.com/weight-service/weight/dayview/2025-06-15 + response: + body: + string: '{"startDate": "2025-06-15", "endDate": "2025-06-15", "dateWeightList": + [{"samplePk": 1749996902851, "date": 1749975276000, "calendarDate": "2025-06-15", + "weight": 59720.0, "bmi": 22.799999237060547, "bodyFat": 19.3, "bodyWater": + 58.9, "boneMass": 3539, "muscleMass": 26979, "physiqueRating": null, "visceralFat": + null, "metabolicAge": null, "sourceType": "INDEX_SCALE", "timestampGMT": 1749996876000, + "weightDelta": 200.00000000000284}], "totalAverage": {"from": 1749945600000, + "until": 1750031999999, "weight": 59720.0, "bmi": 22.799999237060547, "bodyFat": + 19.3, "bodyWater": 58.9, "boneMass": 3539, "muscleMass": 26979, "physiqueRating": + null, "visceralFat": null, "metabolicAge": null}}' + headers: + CF-RAY: + - 9505ceb74f5fd875-QRO + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Sun, 15 Jun 2025 23:22:05 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=UH9A8geP4FHMJjd6y07FBmPslL9A%2B3JKPZa2WHai0fGEwDokhD2YqXsG155VIgSjGPY8Av3IYcI%2B%2FH%2B38GY15TN4THIsNucuROuGSc3NlFY1c%2BmSER4pGCfCqwF1BH1cmMr%2Fu8TKFKFjkS8bzk1P%2FM4l%2Bg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_get_manual_weight_data.yaml b/garth/tests/data/cassettes/test_get_manual_weight_data.yaml new file mode 100644 index 0000000..d954790 --- /dev/null +++ b/garth/tests/data/cassettes/test_get_manual_weight_data.yaml @@ -0,0 +1,62 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://connectapi.garmin.com/weight-service/weight/dayview/2025-06-14 + response: + body: + string: '{"startDate": "2025-06-14", "endDate": "2025-06-14", "dateWeightList": + [{"samplePk": 1749948744411, "date": 1749927125175, "calendarDate": "2025-06-14", + "weight": 59500.0, "bmi": null, "bodyFat": null, "bodyWater": null, "boneMass": + null, "muscleMass": null, "physiqueRating": null, "visceralFat": null, "metabolicAge": + null, "sourceType": "MANUAL", "timestampGMT": 1749948725175, "weightDelta": + 399.9999999999986}, {"samplePk": 1749909217098, "date": 1749887580000, "calendarDate": + "2025-06-14", "weight": 59130.0, "bmi": 22.5, "bodyFat": 20.3, "bodyWater": + 58.2, "boneMass": 3430, "muscleMass": 26840, "physiqueRating": null, "visceralFat": + null, "metabolicAge": null, "sourceType": "INDEX_SCALE", "timestampGMT": 1749909180000, + "weightDelta": -100.00000000000142}], "totalAverage": {"from": 1749859200000, + "until": 1749945599999, "weight": 59315.0, "bmi": 22.5, "bodyFat": 20.3, "bodyWater": + 58.2, "boneMass": 3430, "muscleMass": 26840, "physiqueRating": null, "visceralFat": + null, "metabolicAge": null}}' + headers: + CF-RAY: + - 95064313addc55c3-QRO + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Mon, 16 Jun 2025 00:41:31 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=4k83lvSQ0EaF3v3SPJQfFUMAz%2FRDzu%2BJpC4JQGBU9eLNTYcx5pUfnIWwmgS0AdXoavdcbR4CvPW0TyI%2BRQBpV%2FQo3qe1GcGAaUzrQq5KRBbEpkHZseRhz1jmcUv17rnmwMucrfKf9wMne477n%2BBT0wPNgg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_get_nonexistent_weight_data.yaml b/garth/tests/data/cassettes/test_get_nonexistent_weight_data.yaml new file mode 100644 index 0000000..0b72d52 --- /dev/null +++ b/garth/tests/data/cassettes/test_get_nonexistent_weight_data.yaml @@ -0,0 +1,53 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://connectapi.garmin.com/weight-service/weight/dayview/2020-01-01 + response: + body: + string: '{"startDate": "2020-01-01", "endDate": "2020-01-01", "dateWeightList": + [], "totalAverage": {"from": 1577836800000, "until": 1577923199999, "weight": + null, "bmi": null, "bodyFat": null, "bodyWater": null, "boneMass": null, "muscleMass": + null, "physiqueRating": null, "visceralFat": null, "metabolicAge": null}}' + headers: + CF-RAY: + - 950644801ca4d9f7-QRO + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Mon, 16 Jun 2025 00:42:29 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=BJIcx9Zh1zt1cLoKMZAVgYYQfsvpXBQP04VMD2f4iMyfjHCnNu5Sh%2BdA7NcZ2FkaJ7%2Bxw8up1nDASiKuMf8XqsAi1BYG2kqRNBvEQQEkvhY0L63y%2BXwDbb%2BUcurig3gGRUI3oNq%2F8II2iL62j6q0iLJ9pA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_hrv_data_get.yaml b/garth/tests/data/cassettes/test_hrv_data_get.yaml new file mode 100644 index 0000000..9d88dba --- /dev/null +++ b/garth/tests/data/cassettes/test_hrv_data_get.yaml @@ -0,0 +1,222 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/2023-07-20 + response: + body: + string: '{"userProfilePk": 2591602, "hrvSummary": {"calendarDate": "2023-07-20", + "weeklyAvg": 39, "lastNightAvg": 42, "lastNight5MinHigh": 66, "baseline": + {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.25}, + "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": + "2023-07-20T12:14:11.898"}, "hrvReadings": [{"hrvValue": 54, "readingTimeGMT": + "2023-07-20T05:29:48.0", "readingTimeLocal": "2023-07-19T23:29:48.0"}, {"hrvValue": + 56, "readingTimeGMT": "2023-07-20T05:34:48.0", "readingTimeLocal": "2023-07-19T23:34:48.0"}, + {"hrvValue": 51, "readingTimeGMT": "2023-07-20T05:39:48.0", "readingTimeLocal": + "2023-07-19T23:39:48.0"}, {"hrvValue": 50, "readingTimeGMT": "2023-07-20T05:44:48.0", + "readingTimeLocal": "2023-07-19T23:44:48.0"}, {"hrvValue": 55, "readingTimeGMT": + "2023-07-20T05:49:48.0", "readingTimeLocal": "2023-07-19T23:49:48.0"}, {"hrvValue": + 55, "readingTimeGMT": "2023-07-20T05:54:48.0", "readingTimeLocal": "2023-07-19T23:54:48.0"}, + {"hrvValue": 55, "readingTimeGMT": "2023-07-20T05:59:48.0", "readingTimeLocal": + "2023-07-19T23:59:48.0"}, {"hrvValue": 43, "readingTimeGMT": "2023-07-20T06:04:48.0", + "readingTimeLocal": "2023-07-20T00:04:48.0"}, {"hrvValue": 53, "readingTimeGMT": + "2023-07-20T06:09:48.0", "readingTimeLocal": "2023-07-20T00:09:48.0"}, {"hrvValue": + 53, "readingTimeGMT": "2023-07-20T06:14:48.0", "readingTimeLocal": "2023-07-20T00:14:48.0"}, + {"hrvValue": 41, "readingTimeGMT": "2023-07-20T06:19:48.0", "readingTimeLocal": + "2023-07-20T00:19:48.0"}, {"hrvValue": 47, "readingTimeGMT": "2023-07-20T06:24:48.0", + "readingTimeLocal": "2023-07-20T00:24:48.0"}, {"hrvValue": 45, "readingTimeGMT": + "2023-07-20T06:29:48.0", "readingTimeLocal": "2023-07-20T00:29:48.0"}, {"hrvValue": + 38, "readingTimeGMT": "2023-07-20T06:34:48.0", "readingTimeLocal": "2023-07-20T00:34:48.0"}, + {"hrvValue": 33, "readingTimeGMT": "2023-07-20T06:39:48.0", "readingTimeLocal": + "2023-07-20T00:39:48.0"}, {"hrvValue": 43, "readingTimeGMT": "2023-07-20T06:44:48.0", + "readingTimeLocal": "2023-07-20T00:44:48.0"}, {"hrvValue": 49, "readingTimeGMT": + "2023-07-20T06:49:48.0", "readingTimeLocal": "2023-07-20T00:49:48.0"}, {"hrvValue": + 43, "readingTimeGMT": "2023-07-20T06:54:48.0", "readingTimeLocal": "2023-07-20T00:54:48.0"}, + {"hrvValue": 47, "readingTimeGMT": "2023-07-20T06:59:48.0", "readingTimeLocal": + "2023-07-20T00:59:48.0"}, {"hrvValue": 38, "readingTimeGMT": "2023-07-20T07:04:48.0", + "readingTimeLocal": "2023-07-20T01:04:48.0"}, {"hrvValue": 39, "readingTimeGMT": + "2023-07-20T07:09:48.0", "readingTimeLocal": "2023-07-20T01:09:48.0"}, {"hrvValue": + 33, "readingTimeGMT": "2023-07-20T07:14:48.0", "readingTimeLocal": "2023-07-20T01:14:48.0"}, + {"hrvValue": 43, "readingTimeGMT": "2023-07-20T07:19:48.0", "readingTimeLocal": + "2023-07-20T01:19:48.0"}, {"hrvValue": 45, "readingTimeGMT": "2023-07-20T07:24:48.0", + "readingTimeLocal": "2023-07-20T01:24:48.0"}, {"hrvValue": 36, "readingTimeGMT": + "2023-07-20T07:29:48.0", "readingTimeLocal": "2023-07-20T01:29:48.0"}, {"hrvValue": + 47, "readingTimeGMT": "2023-07-20T07:34:48.0", "readingTimeLocal": "2023-07-20T01:34:48.0"}, + {"hrvValue": 46, "readingTimeGMT": "2023-07-20T07:39:48.0", "readingTimeLocal": + "2023-07-20T01:39:48.0"}, {"hrvValue": 53, "readingTimeGMT": "2023-07-20T07:44:48.0", + "readingTimeLocal": "2023-07-20T01:44:48.0"}, {"hrvValue": 35, "readingTimeGMT": + "2023-07-20T07:49:48.0", "readingTimeLocal": "2023-07-20T01:49:48.0"}, {"hrvValue": + 28, "readingTimeGMT": "2023-07-20T07:54:48.0", "readingTimeLocal": "2023-07-20T01:54:48.0"}, + {"hrvValue": 30, "readingTimeGMT": "2023-07-20T07:59:48.0", "readingTimeLocal": + "2023-07-20T01:59:48.0"}, {"hrvValue": 38, "readingTimeGMT": "2023-07-20T08:04:48.0", + "readingTimeLocal": "2023-07-20T02:04:48.0"}, {"hrvValue": 49, "readingTimeGMT": + "2023-07-20T08:09:48.0", "readingTimeLocal": "2023-07-20T02:09:48.0"}, {"hrvValue": + 46, "readingTimeGMT": "2023-07-20T08:14:48.0", "readingTimeLocal": "2023-07-20T02:14:48.0"}, + {"hrvValue": 31, "readingTimeGMT": "2023-07-20T08:19:48.0", "readingTimeLocal": + "2023-07-20T02:19:48.0"}, {"hrvValue": 29, "readingTimeGMT": "2023-07-20T08:24:48.0", + "readingTimeLocal": "2023-07-20T02:24:48.0"}, {"hrvValue": 32, "readingTimeGMT": + "2023-07-20T08:29:48.0", "readingTimeLocal": "2023-07-20T02:29:48.0"}, {"hrvValue": + 27, "readingTimeGMT": "2023-07-20T08:34:48.0", "readingTimeLocal": "2023-07-20T02:34:48.0"}, + {"hrvValue": 31, "readingTimeGMT": "2023-07-20T08:39:48.0", "readingTimeLocal": + "2023-07-20T02:39:48.0"}, {"hrvValue": 33, "readingTimeGMT": "2023-07-20T08:44:48.0", + "readingTimeLocal": "2023-07-20T02:44:48.0"}, {"hrvValue": 32, "readingTimeGMT": + "2023-07-20T08:49:48.0", "readingTimeLocal": "2023-07-20T02:49:48.0"}, {"hrvValue": + 29, "readingTimeGMT": "2023-07-20T08:54:48.0", "readingTimeLocal": "2023-07-20T02:54:48.0"}, + {"hrvValue": 35, "readingTimeGMT": "2023-07-20T08:59:48.0", "readingTimeLocal": + "2023-07-20T02:59:48.0"}, {"hrvValue": 30, "readingTimeGMT": "2023-07-20T09:04:48.0", + "readingTimeLocal": "2023-07-20T03:04:48.0"}, {"hrvValue": 32, "readingTimeGMT": + "2023-07-20T09:09:48.0", "readingTimeLocal": "2023-07-20T03:09:48.0"}, {"hrvValue": + 37, "readingTimeGMT": "2023-07-20T09:14:48.0", "readingTimeLocal": "2023-07-20T03:14:48.0"}, + {"hrvValue": 40, "readingTimeGMT": "2023-07-20T09:19:48.0", "readingTimeLocal": + "2023-07-20T03:19:48.0"}, {"hrvValue": 39, "readingTimeGMT": "2023-07-20T09:24:48.0", + "readingTimeLocal": "2023-07-20T03:24:48.0"}, {"hrvValue": 47, "readingTimeGMT": + "2023-07-20T09:29:48.0", "readingTimeLocal": "2023-07-20T03:29:48.0"}, {"hrvValue": + 45, "readingTimeGMT": "2023-07-20T09:34:48.0", "readingTimeLocal": "2023-07-20T03:34:48.0"}, + {"hrvValue": 43, "readingTimeGMT": "2023-07-20T09:39:48.0", "readingTimeLocal": + "2023-07-20T03:39:48.0"}, {"hrvValue": 31, "readingTimeGMT": "2023-07-20T09:44:48.0", + "readingTimeLocal": "2023-07-20T03:44:48.0"}, {"hrvValue": 35, "readingTimeGMT": + "2023-07-20T09:49:48.0", "readingTimeLocal": "2023-07-20T03:49:48.0"}, {"hrvValue": + 40, "readingTimeGMT": "2023-07-20T09:54:48.0", "readingTimeLocal": "2023-07-20T03:54:48.0"}, + {"hrvValue": 44, "readingTimeGMT": "2023-07-20T09:59:48.0", "readingTimeLocal": + "2023-07-20T03:59:48.0"}, {"hrvValue": 35, "readingTimeGMT": "2023-07-20T10:04:48.0", + "readingTimeLocal": "2023-07-20T04:04:48.0"}, {"hrvValue": 43, "readingTimeGMT": + "2023-07-20T10:09:48.0", "readingTimeLocal": "2023-07-20T04:09:48.0"}, {"hrvValue": + 54, "readingTimeGMT": "2023-07-20T10:14:48.0", "readingTimeLocal": "2023-07-20T04:14:48.0"}, + {"hrvValue": 57, "readingTimeGMT": "2023-07-20T10:19:48.0", "readingTimeLocal": + "2023-07-20T04:19:48.0"}, {"hrvValue": 66, "readingTimeGMT": "2023-07-20T10:24:48.0", + "readingTimeLocal": "2023-07-20T04:24:48.0"}, {"hrvValue": 58, "readingTimeGMT": + "2023-07-20T10:29:48.0", "readingTimeLocal": "2023-07-20T04:29:48.0"}, {"hrvValue": + 61, "readingTimeGMT": "2023-07-20T10:34:48.0", "readingTimeLocal": "2023-07-20T04:34:48.0"}, + {"hrvValue": 45, "readingTimeGMT": "2023-07-20T10:39:48.0", "readingTimeLocal": + "2023-07-20T04:39:48.0"}, {"hrvValue": 52, "readingTimeGMT": "2023-07-20T10:44:48.0", + "readingTimeLocal": "2023-07-20T04:44:48.0"}, {"hrvValue": 43, "readingTimeGMT": + "2023-07-20T10:49:48.0", "readingTimeLocal": "2023-07-20T04:49:48.0"}, {"hrvValue": + 33, "readingTimeGMT": "2023-07-20T10:54:48.0", "readingTimeLocal": "2023-07-20T04:54:48.0"}, + {"hrvValue": 31, "readingTimeGMT": "2023-07-20T10:59:48.0", "readingTimeLocal": + "2023-07-20T04:59:48.0"}, {"hrvValue": 11, "readingTimeGMT": "2023-07-20T11:04:48.0", + "readingTimeLocal": "2023-07-20T05:04:48.0"}, {"hrvValue": 32, "readingTimeGMT": + "2023-07-20T11:09:48.0", "readingTimeLocal": "2023-07-20T05:09:48.0"}, {"hrvValue": + 38, "readingTimeGMT": "2023-07-20T11:14:48.0", "readingTimeLocal": "2023-07-20T05:14:48.0"}, + {"hrvValue": 38, "readingTimeGMT": "2023-07-20T11:19:48.0", "readingTimeLocal": + "2023-07-20T05:19:48.0"}, {"hrvValue": 29, "readingTimeGMT": "2023-07-20T11:24:48.0", + "readingTimeLocal": "2023-07-20T05:24:48.0"}, {"hrvValue": 38, "readingTimeGMT": + "2023-07-20T11:29:48.0", "readingTimeLocal": "2023-07-20T05:29:48.0"}, {"hrvValue": + 27, "readingTimeGMT": "2023-07-20T11:34:48.0", "readingTimeLocal": "2023-07-20T05:34:48.0"}, + {"hrvValue": 30, "readingTimeGMT": "2023-07-20T11:39:48.0", "readingTimeLocal": + "2023-07-20T05:39:48.0"}, {"hrvValue": 55, "readingTimeGMT": "2023-07-20T11:44:48.0", + "readingTimeLocal": "2023-07-20T05:44:48.0"}, {"hrvValue": 33, "readingTimeGMT": + "2023-07-20T11:49:48.0", "readingTimeLocal": "2023-07-20T05:49:48.0"}, {"hrvValue": + 40, "readingTimeGMT": "2023-07-20T11:54:48.0", "readingTimeLocal": "2023-07-20T05:54:48.0"}, + {"hrvValue": 42, "readingTimeGMT": "2023-07-20T11:59:48.0", "readingTimeLocal": + "2023-07-20T05:59:48.0"}, {"hrvValue": 50, "readingTimeGMT": "2023-07-20T12:04:48.0", + "readingTimeLocal": "2023-07-20T06:04:48.0"}, {"hrvValue": 38, "readingTimeGMT": + "2023-07-20T12:09:48.0", "readingTimeLocal": "2023-07-20T06:09:48.0"}], "startTimestampGMT": + "2023-07-20T05:25:00.0", "endTimestampGMT": "2023-07-20T12:09:48.0", "startTimestampLocal": + "2023-07-19T23:25:00.0", "endTimestampLocal": "2023-07-20T06:09:48.0", "sleepStartTimestampGMT": + "2023-07-20T05:25:00.0", "sleepEndTimestampGMT": "2023-07-20T12:11:00.0", + "sleepStartTimestampLocal": "2023-07-19T23:25:00.0", "sleepEndTimestampLocal": + "2023-07-20T06:11:00.0"}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7fea5791ac5b155e-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Wed, 30 Aug 2023 04:38:03 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=WPNDBwn%2Bfxqb0O6vEmlCrJ8G95qISZzDCH%2BKyUwlszTlFuY1obIOOv%2Flxxab8UwAeJMjXilnv4GT5%2Be6xR62sdLvcthLHgBQS9Imf3tn%2FOtkM0RaVRGP7MnFn1Klb26eMJo3fXWLjw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/2021-07-20 + response: + body: + string: '' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7fea5792ff3b154b-QRO + Connection: + - keep-alive + Date: + - Wed, 30 Aug 2023 04:38:04 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=AbFAU6ePddXCH6t5Ivd3iEs8icSg%2BboWeYfDzAOhakCxvGS0NvnCzxvNFMi5Cog2IvU82WhBEv8tUKYeIFzeOW%2BvE4c%2BQ1E4RCmoWq%2FeAc859qFp7U0wQgbZXS%2F5r8dBFEb0244AOA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + status: + code: 204 + message: No Content +version: 1 diff --git a/garth/tests/data/cassettes/test_hrv_data_list.yaml b/garth/tests/data/cassettes/test_hrv_data_list.yaml new file mode 100644 index 0000000..c06a220 --- /dev/null +++ b/garth/tests/data/cassettes/test_hrv_data_list.yaml @@ -0,0 +1,162 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/2023-07-20 + response: + body: + string: !!binary | + H4sIAAAAAAAAA52aXU/bMBSG/4uvA/LxRxLnjg00LgAh6LiZJhRa01ZNP5S0IIT636cUiiizd975 + ksT49WMnT46TvopN59vrdvk4bfz1TFTKOsqlysSkfbrdzOd1+yKqVzGsG78Y1e1pvfaiEkoqfSSL + IyVFJp69nzUvJ09jUWmXiabu1lfT8WS9O2LUpyP2cro4n44nosrzTDzUnW+mC9/33yyff65WvhWV + 3p1p6sXQjy6Wz2997g+8t7EqE/O6nfn2rm42XlTyWNltJrp1vd50ohLfTi5Orr6fnYpMPHo/eqiH + s+tJW3f92M9v7u735+8LkYlh6+u1H0zn/nZdz1cHeANSFZmK6Lh0pdjupuXG16PpYtyJ6tdr//f7 + GKzJRPt2qu/rx+XgsCdpK+UqUx73c/ap4cVyWDefmpIbKP3RdJsdZORshjZwxr7plwziM3AOHeaQ + bIbBOUyYw/IZOIdxiRkW57CpHBbnsEEOo5mMvJIIR99UfjT9wgFkODzDJWYQzkFBDkN8Bs5B4fUo + 2AyFc6gwh+UzcI6wr3TJZmicI+wrza+5xjl06v1hcI6wr4zjM3AOk8phcY6wr4Br1+IcNu26KnBf + UcRX2vEZDs9wSddugfuKYr4CMnCOiK8sm6FwjrCvdM5n4BwqzbsF7iuK+MrwHBrn0GnPwQL3FUV8 + pfk1NzhH2FeKv88tzhH2lZZ8Bs6R6KsS95WK+Ip9fpS4r1TEV+y1W+K+UhFfaeIzcI6wrxQ/Vwrn + iPhK8Rk4R9hXqmAzNM6hU9dD4xw67TlY4r5SMV/x62FwDpN6XVmcw6Z5t8R9pWK+4pzocF/pWH2l + +AyHZ4Q5CjaDcI5IfcXPFeEcYV+xtajDfaVj+0F+rhTOodLqRIf7Kvb+iq13He6r2Psr1okO95VO + ra8c7qvY+yvg2rU4R2Q/aPgMnCPiK2auSOK+MrH6SvMZDs8I1+2GzSCcI+wrW/AZOEfYV3nOZiic + I+wrW/IZOEfYVzmxGRrn0Env4UjivjKx/aBiMwzOYVLvD4NzmKQ6kSTuKxOrr/g1tzhH2FfEZRDu + K5tYXxHhvrKx+qpkMwjniOwHgQycI20/SIT7ysb2gzyHwjnS9oNEuK9sbD8o+QycQyd9VyPCfWVj + 9ZXmM3COtPqKCPeVjdVX/H1ucQ6b9L2WFO6rPOarks9weMae4/fuZwHtum/a9d/3gx/mbSXlrmO/ + GMVbHgzhsNfIV/xgv/8ecSa6xvvV7X8MevcPZ8zIe9/LWP/c8P9KCDPsM7Z/ALlCPuhYIgAA + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 812800c81f4c479e-DFW + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 07 Oct 2023 17:53:20 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=1efXaZ9bQvYJF8jZkRNJeCENTFUGwDN6ljNCY3V9t8M17uF6Eq4aI4bI%2BrhUvg2sw5dEWCCf7SVlDKE0sYvbYE1MtrVNYOqposaDhcgu3w7t9t1Vpz1Lher36IKgicfzMAEw5RmXtw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/2023-07-19 + response: + body: + string: !!binary | + H4sIAAAAAAAAA52aUW/TPBSG/4uvw+Rz7JPUuRsf6ONioIn14wYhFFqzVUu7Ke2Y0LT//qmFTVT4 + cF58ucTz68eOn9pOHtzdNk/n083X1ZjPr13Pkqj13Lir6dvF3Xo9TN9d/+AWw5g3y2F6Neyy6x17 + Di9894KSa9x9ztfj99Nvl64PqXHjsN29W11e7Q5XYvjlirxdbd6sLq9c3/rGfRm2eVxt8r7+8eb+ + v9vbPLk+tPs747BZ5OXZzf2POp8u/Cwj3Lj1MF3n6cMw3mXX+xOWx8Ztd8Pubut69/L07PTdP69f + ucZ9zXn5ZVhcn19Nw3bf9jfvP3x+uv85usYtpjzs8ny1zhe7YX17hDen2MfQU3sSUnSPh255n4fl + anO5df3Hh/3fP9sQuXHTj1v7uv59Oz+uyUsfUh9nJ94dFTy7WQzjr0Vncw7PRR+bv8yIEc54Knqc + EcTOwDlimcObGYJzSJmjtTNwDilyhJmR0fYe4khz75+LHmdwZ2ckPKPIwcnMIJyDyuMBZOAcVB6P + YGYwzsFlDrYzcA4uz49oZgScI5SfK/vZDThH2VdAX0WcQ/GVzRFxjkpftaCvDhlS+1wJziF186PD + fUWKr5CMhGeUOTozg3AOqvv96HBfkeYrm4NxjrKvxOZgnIPr5keH+4oUX0WbI+AcyvpqZmZEnKPs + KyQD54i181xwjkpfdbivSPOVNeYz3Fes+CqSnZHwjLp5PsN9xZqv2M7AOcq+EruvGOeo9NUM9xVr + vrI5As6h+Moe84BzKOurZGZEnKPsK/F2Bs6hrK9sDsE5pJZDcA6pmx8J91VQfCViZyQ8o8zRmRmE + c1DdeCTcV0HxVbT7inEOrluXJNxXQfPVzMwIOIfiq2Rn4BxlXwmbGRHniLXPVcQ5Yi2H4BxlX7U2 + h+Aciq+M54o87quo+SrYGQnPqBoP8rivouIra49DHvdV1Hxl9xXjHFx1XkIe91VUfBWimRFwjlC1 + PyeP+ypq+0E7I+IcdftB8rivouIrFjNDcI6yr9juK8E5yr5ia54T7ivR9oOdnZHwjKrzEiLcV1Lr + K8J9Jdp+MJgZjHNw1XsDItxXovhK7DEPOEfZV2I/uwHnqFtfEeG+ksr3g0S4r0Q7v7IzBOeQut9B + wn0liq+sNTUx7qtWO2/v7IyEZ1TtP4hxX7XafjDYGThHpa8Y91WrnV+JnYFzcNW5DzHuq1ZbX0U7 + A+eoez9IjPuq1dZX9phHnOPZV58On5tMu33R7f67EeWDD+8PFefNUi951ITjWtWvQwr1/rnFjduO + Od9e/EWjD//w2mi5UB9Fq99q/m8JZYanjMf/AU1pYOmwJAAA + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 812800c8f836479e-DFW + Connection: + - keep-alive + Content-Encoding: + - gzip + Content-Type: + - application/json + Date: + - Sat, 07 Oct 2023 17:53:20 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=aYF7%2Fjff6q%2BSW3DoLj4L0k%2BOVpTIJg1uTyZAJlPPxWfk8qcKnyoYSbdeMeFKDwiveT57hbjuS7p2fiY%2FKfvkmhY4ie2PKVugdBz29e64xajlg0jA3eE5e9fSMkV%2BZHMbJkLa4r%2BPOw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_sleep_data_get.yaml b/garth/tests/data/cassettes/test_sleep_data_get.yaml new file mode 100644 index 0000000..188169a --- /dev/null +++ b/garth/tests/data/cassettes/test_sleep_data_get.yaml @@ -0,0 +1,170 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/userprofile-service/socialProfile + response: + body: + string: '{"id": 3154645, "profileId": 2591602, "garminGUID": "0690cc1d-d23d-4412-b027-80fd4ed1c0f6", + "displayName": "mtamizi", "fullName": "Matin Tamizi", "userName": "mtamizi", + "profileImageUuid": "73240e81-6e4d-43fc-8af8-c8f6c51b3b8f", "profileImageUrlLarge": + "https://s3.amazonaws.com/garmin-connect-prod/profile_images/73240e81-6e4d-43fc-8af8-c8f6c51b3b8f-2591602.png", + "profileImageUrlMedium": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/685a19e9-a7be-4a11-9bf9-faca0c5d1f1a-2591602.png", + "profileImageUrlSmall": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/6302f021-0ec7-4dc9-b0c3-d5a19bc5a08c-2591602.png", + "location": "Ciudad de M\u00e9xico, CDMX", "facebookUrl": null, "twitterUrl": + null, "personalWebsite": null, "motivation": null, "bio": null, "primaryActivity": + null, "favoriteActivityTypes": [], "runningTrainingSpeed": 0.0, "cyclingTrainingSpeed": + 0.0, "favoriteCyclingActivityTypes": [], "cyclingClassification": null, "cyclingMaxAvgPower": + 0.0, "swimmingTrainingSpeed": 0.0, "profileVisibility": "private", "activityStartVisibility": + "private", "activityMapVisibility": "public", "courseVisibility": "public", + "activityHeartRateVisibility": "public", "activityPowerVisibility": "public", + "badgeVisibility": "private", "showAge": false, "showWeight": false, "showHeight": + false, "showWeightClass": false, "showAgeRange": false, "showGender": false, + "showActivityClass": false, "showVO2Max": false, "showPersonalRecords": false, + "showLast12Months": false, "showLifetimeTotals": false, "showUpcomingEvents": + false, "showRecentFavorites": false, "showRecentDevice": false, "showRecentGear": + false, "showBadges": true, "otherActivity": null, "otherPrimaryActivity": + null, "otherMotivation": null, "userRoles": ["SCOPE_ATP_READ", "SCOPE_ATP_WRITE", + "SCOPE_COMMUNITY_COURSE_READ", "SCOPE_COMMUNITY_COURSE_WRITE", "SCOPE_CONNECT_READ", + "SCOPE_CONNECT_WRITE", "SCOPE_DT_CLIENT_ANALYTICS_WRITE", "SCOPE_GARMINPAY_READ", + "SCOPE_GARMINPAY_WRITE", "SCOPE_GCOFFER_READ", "SCOPE_GCOFFER_WRITE", "SCOPE_GHS_SAMD", + "SCOPE_GHS_UPLOAD", "SCOPE_GOLF_API_READ", "SCOPE_GOLF_API_WRITE", "SCOPE_INSIGHTS_READ", + "SCOPE_INSIGHTS_WRITE", "SCOPE_PRODUCT_SEARCH_READ", "ROLE_CONNECTUSER", "ROLE_FITNESS_USER", + "ROLE_WELLNESS_USER", "ROLE_OUTDOOR_USER", "ROLE_CONNECT_2_USER", "ROLE_TACX_APP_USER"], + "nameApproved": true, "userProfileFullName": "Matin Tamizi", "makeGolfScorecardsPrivate": + true, "allowGolfLiveScoring": false, "allowGolfScoringByConnections": true, + "userLevel": 3, "userPoint": 117, "levelUpdateDate": "2020-12-12T15:20:38.0", + "levelIsViewed": false, "levelPointThreshold": 140, "userPointOffset": 0, + "userPro": false}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0081a724797-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:33 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=7Jm3%2BQkQNnW8yDQr8zz%2FW93FRmApY0UugFBzK5SgwmO8atpbxSWdU7uz2UcLfuGZajQJkLQ28E%2FBQ7f0ki9S6f2eY3EDSfVn7CNNgmuZdvo38guNpuMK5guqKP3cYIQy4fF5GLPHUQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-20 + response: + body: + string: '{"dailySleepDTO": {"id": 1626758400000, "userProfilePK": 2591602, "calendarDate": + "2021-07-20", "sleepTimeSeconds": 25740, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626758400000, "sleepEndTimestampGMT": 1626785940000, "sleepStartTimestampLocal": + 1626740400000, "sleepEndTimestampLocal": 1626767940000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 4440, "lightSleepSeconds": + 18720, "remSleepSeconds": 2580, "awakeSleepSeconds": 1800, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 84, "highestSpO2Value": 100, "averageSpO2HRSleep": 51.0, "averageRespirationValue": + 15.0, "lowestRespirationValue": 8.0, "highestRespirationValue": 18.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-20T05:21:00.0", "sleepMeasurementEndGMT": "2021-07-20T12:56:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 51.0, "lowestSPO2": 84}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0093b58b6e2-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:34 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=asU9NqPsuSmxxN96St1ca3wY06WSkANwfXch1MOBitkjzSuq45fyuSUC%2BXGE%2F7S9FHwRT13HYOi%2FDLINfwbYmWT9Vrwld3zjhkDxpGkSP2EsN7vdWSKXrF23uV3RSIoBkU9JthnrZQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_sleep_data_list.yaml b/garth/tests/data/cassettes/test_sleep_data_list.yaml new file mode 100644 index 0000000..d2e294b --- /dev/null +++ b/garth/tests/data/cassettes/test_sleep_data_list.yaml @@ -0,0 +1,1665 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/userprofile-service/socialProfile + response: + body: + string: '{"id": 3154645, "profileId": 2591602, "garminGUID": "0690cc1d-d23d-4412-b027-80fd4ed1c0f6", + "displayName": "mtamizi", "fullName": "Matin Tamizi", "userName": "mtamizi", + "profileImageUuid": "73240e81-6e4d-43fc-8af8-c8f6c51b3b8f", "profileImageUrlLarge": + "https://s3.amazonaws.com/garmin-connect-prod/profile_images/73240e81-6e4d-43fc-8af8-c8f6c51b3b8f-2591602.png", + "profileImageUrlMedium": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/685a19e9-a7be-4a11-9bf9-faca0c5d1f1a-2591602.png", + "profileImageUrlSmall": "https://s3.amazonaws.com/garmin-connect-prod/profile_images/6302f021-0ec7-4dc9-b0c3-d5a19bc5a08c-2591602.png", + "location": "Ciudad de M\u00e9xico, CDMX", "facebookUrl": null, "twitterUrl": + null, "personalWebsite": null, "motivation": null, "bio": null, "primaryActivity": + null, "favoriteActivityTypes": [], "runningTrainingSpeed": 0.0, "cyclingTrainingSpeed": + 0.0, "favoriteCyclingActivityTypes": [], "cyclingClassification": null, "cyclingMaxAvgPower": + 0.0, "swimmingTrainingSpeed": 0.0, "profileVisibility": "private", "activityStartVisibility": + "private", "activityMapVisibility": "public", "courseVisibility": "public", + "activityHeartRateVisibility": "public", "activityPowerVisibility": "public", + "badgeVisibility": "private", "showAge": false, "showWeight": false, "showHeight": + false, "showWeightClass": false, "showAgeRange": false, "showGender": false, + "showActivityClass": false, "showVO2Max": false, "showPersonalRecords": false, + "showLast12Months": false, "showLifetimeTotals": false, "showUpcomingEvents": + false, "showRecentFavorites": false, "showRecentDevice": false, "showRecentGear": + false, "showBadges": true, "otherActivity": null, "otherPrimaryActivity": + null, "otherMotivation": null, "userRoles": ["SCOPE_ATP_READ", "SCOPE_ATP_WRITE", + "SCOPE_COMMUNITY_COURSE_READ", "SCOPE_COMMUNITY_COURSE_WRITE", "SCOPE_CONNECT_READ", + "SCOPE_CONNECT_WRITE", "SCOPE_DT_CLIENT_ANALYTICS_WRITE", "SCOPE_GARMINPAY_READ", + "SCOPE_GARMINPAY_WRITE", "SCOPE_GCOFFER_READ", "SCOPE_GCOFFER_WRITE", "SCOPE_GHS_SAMD", + "SCOPE_GHS_UPLOAD", "SCOPE_GOLF_API_READ", "SCOPE_GOLF_API_WRITE", "SCOPE_INSIGHTS_READ", + "SCOPE_INSIGHTS_WRITE", "SCOPE_PRODUCT_SEARCH_READ", "ROLE_CONNECTUSER", "ROLE_FITNESS_USER", + "ROLE_WELLNESS_USER", "ROLE_OUTDOOR_USER", "ROLE_CONNECT_2_USER", "ROLE_TACX_APP_USER"], + "nameApproved": true, "userProfileFullName": "Matin Tamizi", "makeGolfScorecardsPrivate": + true, "allowGolfLiveScoring": false, "allowGolfScoringByConnections": true, + "userLevel": 3, "userPoint": 117, "levelUpdateDate": "2020-12-12T15:20:38.0", + "levelIsViewed": false, "levelPointThreshold": 140, "userPointOffset": 0, + "userPro": false}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d00c9e4f46c8-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:34 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=SXM84DDSSI7c2TJJIKh4622LJWgHbCgtQVtcjQc4SQGNDgPqWUJh7vb%2FX%2FdHtnARXtM3%2FXoDj%2FsE0xyvVmQn8pWqyjKc1ZHrpqhNKFluwNgtDZlMCAXkhD%2BMfw0D%2B0%2FAMRlortyIeA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-20 + response: + body: + string: '{"dailySleepDTO": {"id": 1626758400000, "userProfilePK": 2591602, "calendarDate": + "2021-07-20", "sleepTimeSeconds": 25740, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626758400000, "sleepEndTimestampGMT": 1626785940000, "sleepStartTimestampLocal": + 1626740400000, "sleepEndTimestampLocal": 1626767940000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 4440, "lightSleepSeconds": + 18720, "remSleepSeconds": 2580, "awakeSleepSeconds": 1800, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 84, "highestSpO2Value": 100, "averageSpO2HRSleep": 51.0, "averageRespirationValue": + 15.0, "lowestRespirationValue": 8.0, "highestRespirationValue": 18.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-20T05:21:00.0", "sleepMeasurementEndGMT": "2021-07-20T12:56:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 51.0, "lowestSPO2": 84}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d00e988e478e-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:34 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=qtSiA5VrDrG458hymR1BvS6PbA4aF2F7Zp8gLXC14T8J6biYe7%2F4mCla4JfoukylEE5VCzRscZy8mQr4HsyKhfwgOJJHG6AUz2IFkxK67ubouyhHv%2BklbNorsLXmJNd0U%2F2oJlsUyA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-19 + response: + body: + string: '{"dailySleepDTO": {"id": 1626671040000, "userProfilePK": 2591602, "calendarDate": + "2021-07-19", "sleepTimeSeconds": 22560, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626671040000, "sleepEndTimestampGMT": 1626695040000, "sleepStartTimestampLocal": + 1626653040000, "sleepEndTimestampLocal": 1626677040000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 2100, "lightSleepSeconds": + 16260, "remSleepSeconds": 4200, "awakeSleepSeconds": 1440, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 90.0, "lowestSpO2Value": + 83, "highestSpO2Value": 96, "averageSpO2HRSleep": 50.0, "averageRespirationValue": + 15.0, "lowestRespirationValue": 10.0, "highestRespirationValue": 17.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-19T05:05:00.0", "sleepMeasurementEndGMT": "2021-07-19T11:44:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 90.0, "averageSpO2HR": 50.0, "lowestSPO2": 83}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d010fb38475d-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:35 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=eMCF23SNhpZfXvBbLwLcJ9MqtbFnMA33hH1OpHo5ovJI6rdsD3OtmN%2B5b7hyZkJyp5FX0Ds7lKVwYs3Ud%2Fr%2BYE2WrzgB%2FbGmlicEKi9VCJtbosDTBM06mYeypjMcvhmsg4Fr%2BIb42g%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-18 + response: + body: + string: '{"dailySleepDTO": {"id": 1626588480000, "userProfilePK": 2591602, "calendarDate": + "2021-07-18", "sleepTimeSeconds": 26100, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626588480000, "sleepEndTimestampGMT": 1626615420000, "sleepStartTimestampLocal": + 1626570480000, "sleepEndTimestampLocal": 1626597420000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 4800, "lightSleepSeconds": + 15360, "remSleepSeconds": 5940, "awakeSleepSeconds": 840, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 91.0, "lowestSpO2Value": + 84, "highestSpO2Value": 96, "averageSpO2HRSleep": 48.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 6.0, "highestRespirationValue": 16.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-18T06:09:00.0", "sleepMeasurementEndGMT": "2021-07-18T13:36:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 91.0, "averageSpO2HR": 48.0, "lowestSPO2": 84}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d01359034768-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:35 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=TXemOIhT3MxW7TfPvgRX0yMbVWTXPkmn85pRv1GiXohXOs5Avj6jNNkdiQqvBt2PwcowVugQWUAINg3UGxGJAyBkW6%2FxX3%2BL2aW%2BIeeImK9jqnGw6ESTwT6qEbldai7bo%2FYhBP56bg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-17 + response: + body: + string: '{"dailySleepDTO": {"id": 1626500220000, "userProfilePK": 2591602, "calendarDate": + "2021-07-17", "sleepTimeSeconds": 28800, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626500220000, "sleepEndTimestampGMT": 1626530580000, "sleepStartTimestampLocal": + 1626482220000, "sleepEndTimestampLocal": 1626512580000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 5580, "lightSleepSeconds": + 15840, "remSleepSeconds": 7380, "awakeSleepSeconds": 1560, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 90.0, "lowestSpO2Value": + 83, "highestSpO2Value": 98, "averageSpO2HRSleep": 50.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 8.0, "highestRespirationValue": 18.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-17T05:38:00.0", "sleepMeasurementEndGMT": "2021-07-17T14:01:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 90.0, "averageSpO2HR": 50.0, "lowestSPO2": 83}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0159ef14674-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:36 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=pgCdzfoVvNSHnKtFrRCTKSmhU4%2FVIzENX16OwPCShsXegufDPs6hW9OpOIwGlqmP4FyxW7VLkin9TZWyS63O4DmdOWaFTa6etMtM2VNTjPcQOmgmDAF%2Faci1ms5YINMIVZOqBTBf7g%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-16 + response: + body: + string: '{"dailySleepDTO": {"id": 1626411660000, "userProfilePK": 2591602, "calendarDate": + "2021-07-16", "sleepTimeSeconds": 22740, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626411660000, "sleepEndTimestampGMT": 1626435360000, "sleepStartTimestampLocal": + 1626393660000, "sleepEndTimestampLocal": 1626417360000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 4440, "lightSleepSeconds": + 13980, "remSleepSeconds": 4320, "awakeSleepSeconds": 960, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 86, "highestSpO2Value": 100, "averageSpO2HRSleep": 51.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 9.0, "highestRespirationValue": 18.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-16T05:02:00.0", "sleepMeasurementEndGMT": "2021-07-16T11:34:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 51.0, "lowestSPO2": 86}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d017ccd34781-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:36 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=PXKVOL42vgqaWu%2FW6x7DQt2xfGvtmaKmyjWzK0jnNbPqyqaBSDbvQPZBnSZRbCF17pdhhpMq8ddERaKeIqHWpRqiTkbaVfAGAuyiozyYpzYIVA%2BGDq0PDth6ViV6jLYOLQpdMz4Rmw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-15 + response: + body: + string: '{"dailySleepDTO": {"id": 1626327960000, "userProfilePK": 2591602, "calendarDate": + "2021-07-15", "sleepTimeSeconds": 21720, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626327960000, "sleepEndTimestampGMT": 1626350400000, "sleepStartTimestampLocal": + 1626309960000, "sleepEndTimestampLocal": 1626332400000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 3300, "lightSleepSeconds": + 17160, "remSleepSeconds": 1260, "awakeSleepSeconds": 720, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 85, "highestSpO2Value": 100, "averageSpO2HRSleep": 51.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 9.0, "highestRespirationValue": 16.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-15T05:47:00.0", "sleepMeasurementEndGMT": "2021-07-15T12:00:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 51.0, "lowestSPO2": 85}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d01a1b48474f-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:36 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=7pid3UMIAFp8WbajCLUNaip8agbChk73kXWIofcrPjIMGcGwu0q%2FJ%2BFOWWDHRZy9hO4C23PT21nXDuHclg2GxeNQoUn%2FTyJ6mFnRZ4E7TNXWcz%2FE7q%2FaT%2FU7mz1eaqnjNtrEbOiNwg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-14 + response: + body: + string: '{"dailySleepDTO": {"id": 1626238140000, "userProfilePK": 2591602, "calendarDate": + "2021-07-14", "sleepTimeSeconds": 22920, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626238140000, "sleepEndTimestampGMT": 1626262560000, "sleepStartTimestampLocal": + 1626220140000, "sleepEndTimestampLocal": 1626244560000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 4380, "lightSleepSeconds": + 12300, "remSleepSeconds": 6240, "awakeSleepSeconds": 1500, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 83, "highestSpO2Value": 98, "averageSpO2HRSleep": 52.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 7.0, "highestRespirationValue": 17.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-14T04:50:00.0", "sleepMeasurementEndGMT": "2021-07-14T11:36:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 52.0, "lowestSPO2": 83}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d01b9805b6e2-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:37 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=Kyp6FBYtZ7PEJETr2dOApNJqD8zsoYXCD6nit72%2BXd%2BD5ByvfeBC7Js6udY8%2BWbmvD7BIRzuGzKP8qIb2wTZnWrM0cRyE8EBj1OXeBqrhqRhCXezZO5WvVUtx%2FnJPz1RxVKMarAyBw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-13 + response: + body: + string: '{"dailySleepDTO": {"id": 1626148140000, "userProfilePK": 2591602, "calendarDate": + "2021-07-13", "sleepTimeSeconds": 27060, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626148140000, "sleepEndTimestampGMT": 1626175920000, "sleepStartTimestampLocal": + 1626130140000, "sleepEndTimestampLocal": 1626157920000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 2400, "lightSleepSeconds": + 18420, "remSleepSeconds": 6240, "awakeSleepSeconds": 720, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 86, "highestSpO2Value": 98, "averageSpO2HRSleep": 54.0, "averageRespirationValue": + 15.0, "lowestRespirationValue": 10.0, "highestRespirationValue": 16.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-13T03:51:00.0", "sleepMeasurementEndGMT": "2021-07-13T11:32:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 54.0, "lowestSPO2": 86}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d01d0a15b6e7-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:37 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=y4bDuYdVHk6b%2BsQI8TbaQoTcbx51Nw7VwXcB5iGvCMvSLgBfvJh7qTCBNkidlGE%2F4soACLsKxG4PiEXrU2qtwBS%2BJPrTaN3nfWP3gYHPWEfRkHi8utIwFfKHUhvKUz6mUHHaH7QxGA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-12 + response: + body: + string: '{"dailySleepDTO": {"id": 1626066900000, "userProfilePK": 2591602, "calendarDate": + "2021-07-12", "sleepTimeSeconds": 22740, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1626066900000, "sleepEndTimestampGMT": 1626089640000, "sleepStartTimestampLocal": + 1626048900000, "sleepEndTimestampLocal": 1626071640000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 2820, "lightSleepSeconds": + 14640, "remSleepSeconds": 5280, "awakeSleepSeconds": 0, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 85, "highestSpO2Value": 97, "averageSpO2HRSleep": 54.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 9.0, "highestRespirationValue": 16.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-12T05:16:00.0", "sleepMeasurementEndGMT": "2021-07-12T11:34:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 54.0, "lowestSPO2": 85}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d01f7ba3486f-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:37 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=wOEZYLrzX36T%2FP7LxIeWv3eOi1vIUblM%2FgAatvAZazruO53bb5VxxKqNMb5b%2Ff7yjGyC7ptcMwg2Ofv4VkUbgZf6BfNcb4IVTiB9FO9Epgq9SxCi9yoR66qF86NSRCpg28Bf3pMG0g%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-11 + response: + body: + string: '{"dailySleepDTO": {"id": 1625978160000, "userProfilePK": 2591602, "calendarDate": + "2021-07-11", "sleepTimeSeconds": 26040, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625978160000, "sleepEndTimestampGMT": 1626010620000, "sleepStartTimestampLocal": + 1625960160000, "sleepEndTimestampLocal": 1625992620000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 1320, "deepSleepSeconds": 4200, "lightSleepSeconds": + 14100, "remSleepSeconds": 7740, "awakeSleepSeconds": 5100, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 91.0, "lowestSpO2Value": + 78, "highestSpO2Value": 100, "averageSpO2HRSleep": 54.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 9.0, "highestRespirationValue": 18.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-11T04:38:00.0", "sleepMeasurementEndGMT": "2021-07-11T13:36:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 91.0, "averageSpO2HR": 54.0, "lowestSPO2": 78}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0216eee1549-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:37 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=gsvldxh95pVQcbIzp28v%2B00WIXTcbzySNXlBT%2F92sEN77RYrooXBcU8S9v9rBMgG2V57ftUfxVYWnAkJTzJ6wa2CZJcMPcM9%2Bh0ZjLu%2F55iWgwfDvEQayV3F4JKWVVWn%2FjY3JEmcxw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-10 + response: + body: + string: '{"dailySleepDTO": {"id": 1625903640000, "userProfilePK": 2591602, "calendarDate": + "2021-07-10", "sleepTimeSeconds": 20160, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625903640000, "sleepEndTimestampGMT": 1625926500000, "sleepStartTimestampLocal": + 1625885640000, "sleepEndTimestampLocal": 1625908500000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 2520, "lightSleepSeconds": + 14340, "remSleepSeconds": 3300, "awakeSleepSeconds": 2700, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 90.0, "lowestSpO2Value": + 83, "highestSpO2Value": 96, "averageSpO2HRSleep": 56.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 9.0, "highestRespirationValue": 18.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-10T07:55:00.0", "sleepMeasurementEndGMT": "2021-07-10T14:11:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 90.0, "averageSpO2HR": 56.0, "lowestSPO2": 83}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d022b923b6e1-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:38 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=jwsKC6MCMrJ5RC7h9NCaWM8LwMQI3SpxYgNIg3BRnMXEXPTshhGu2SJHrgtz2ZjNePcrnFqVntqx9x2Cfb4j5h2jJfINkVo4nV9vfPpgBMxL2pxQSBlyvUuxYZs%2BnpQe96jRDbXqqg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-09 + response: + body: + string: '{"dailySleepDTO": {"id": 1625809560000, "userProfilePK": 2591602, "calendarDate": + "2021-07-09", "sleepTimeSeconds": 20040, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625809560000, "sleepEndTimestampGMT": 1625832480000, "sleepStartTimestampLocal": + 1625791560000, "sleepEndTimestampLocal": 1625814480000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 720, "lightSleepSeconds": + 17220, "remSleepSeconds": 2100, "awakeSleepSeconds": 2880, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 76, "highestSpO2Value": 100, "averageSpO2HRSleep": 52.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 10.0, "highestRespirationValue": 16.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-09T05:47:00.0", "sleepMeasurementEndGMT": "2021-07-09T12:06:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 52.0, "lowestSPO2": 76}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0252f7a485c-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:38 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=zJ7oFbt70uWJOtt0%2B55RGhnCh0nOCnaB7qloify9Lx9Akj3hgV6D0dtKKNC%2FQIX6NJk0cbokv2wHKdoDEW%2Bt7Ndw5hRotoDOtPV06jAS6zNdlHsxnr5WMZjC%2FvF0FkwbMxBKhOCqgg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-08 + response: + body: + string: '{"dailySleepDTO": {"id": 1625721060000, "userProfilePK": 2591602, "calendarDate": + "2021-07-08", "sleepTimeSeconds": 14460, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625721060000, "sleepEndTimestampGMT": 1625736180000, "sleepStartTimestampLocal": + 1625703060000, "sleepEndTimestampLocal": 1625718180000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 3180, "lightSleepSeconds": + 7080, "remSleepSeconds": 4200, "awakeSleepSeconds": 660, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 85, "highestSpO2Value": 98, "averageSpO2HRSleep": 52.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 12.0, "highestRespirationValue": 17.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-08T05:12:00.0", "sleepMeasurementEndGMT": "2021-07-08T09:23:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 52.0, "lowestSPO2": 85}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d026af141559-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:38 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=iHZXPfdqlhB0eilEpnFUAr3NMskgS%2FSt1zCZBj0L69StSyKWg2e%2BkZ%2FZQ9Gbn3aF0e%2FOTHL0CmzFKHOncpvBcOjQntvUH%2BfiavmAt7aHfn1hLQOw4R9gTtx37%2BsM3Ao0qfsS3Bn8hQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-07 + response: + body: + string: '{"dailySleepDTO": {"id": 1625633700000, "userProfilePK": 2591602, "calendarDate": + "2021-07-07", "sleepTimeSeconds": 23340, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625633700000, "sleepEndTimestampGMT": 1625658420000, "sleepStartTimestampLocal": + 1625615700000, "sleepEndTimestampLocal": 1625640420000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 6060, "lightSleepSeconds": + 15840, "remSleepSeconds": 1440, "awakeSleepSeconds": 1380, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 83, "highestSpO2Value": 100, "averageSpO2HRSleep": 48.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 10.0, "highestRespirationValue": 17.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-07T04:56:00.0", "sleepMeasurementEndGMT": "2021-07-07T11:47:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 48.0, "lowestSPO2": 83}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d027fd801556-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:39 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=ifg072PLpOiN5JuUhMzuqqfl1ndTjmx9TCZJvjoUZCgjUArPdYpQe4alkOSXspvKFXzekP10ke1p37u0XDB2jcVtpQeo3NfeBhyVUgKIwAG5t5EZOqVWD%2B9xsLMqXJihPoRTnuMdRg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-06 + response: + body: + string: '{"dailySleepDTO": {"id": 1625543220000, "userProfilePK": 2591602, "calendarDate": + "2021-07-06", "sleepTimeSeconds": 27660, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625543220000, "sleepEndTimestampGMT": 1625571900000, "sleepStartTimestampLocal": + 1625525220000, "sleepEndTimestampLocal": 1625553900000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 3000, "lightSleepSeconds": + 13980, "remSleepSeconds": 10680, "awakeSleepSeconds": 1020, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 93.0, "lowestSpO2Value": + 87, "highestSpO2Value": 100, "averageSpO2HRSleep": 52.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 10.0, "highestRespirationValue": 16.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-06T03:48:00.0", "sleepMeasurementEndGMT": "2021-07-06T11:45:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 93.0, "averageSpO2HR": 52.0, "lowestSPO2": 87}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d02a7fc2b6e2-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:39 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=sJt1xIs%2BBX85Utg6JZC%2BvLjLKrO%2F2KUG3p4NU3yPZPDZhTP24CkFrQGvhKLElwF4cZ9lLOMZkB3fCIPi71OCE%2B9hibWbSxdUVUoLhcWKSPqGWALrPm2tLAy8v%2FcNtQy0uZ8VW6aqEg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-05 + response: + body: + string: '{"dailySleepDTO": {"id": 1625454360000, "userProfilePK": 2591602, "calendarDate": + "2021-07-05", "sleepTimeSeconds": 26580, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625454360000, "sleepEndTimestampGMT": 1625485260000, "sleepStartTimestampLocal": + 1625436360000, "sleepEndTimestampLocal": 1625467260000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 4500, "lightSleepSeconds": + 17340, "remSleepSeconds": 4740, "awakeSleepSeconds": 4320, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 93.0, "lowestSpO2Value": + 86, "highestSpO2Value": 99, "averageSpO2HRSleep": 49.0, "averageRespirationValue": + 15.0, "lowestRespirationValue": 10.0, "highestRespirationValue": 20.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-05T03:11:00.0", "sleepMeasurementEndGMT": "2021-07-05T11:41:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 93.0, "averageSpO2HR": 49.0, "lowestSPO2": 86}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d02c2b211559-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:39 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=nMs9WRQTY82z8VC93fcCUPrzj%2B%2Fgph7yvVyZmb7YdU48ItUVbvLzI56jo3qT5a2nGser8F7ONUa54J3KOXm%2BmmNwDzStOyGVNNqZULYQow%2BBzf3eazZF%2BjRb3wOxyBmh7dNxswXptw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-04 + response: + body: + string: '{"dailySleepDTO": {"id": 1625377380000, "userProfilePK": 2591602, "calendarDate": + "2021-07-04", "sleepTimeSeconds": 28740, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625377380000, "sleepEndTimestampGMT": 1625408580000, "sleepStartTimestampLocal": + 1625359380000, "sleepEndTimestampLocal": 1625390580000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 960, "lightSleepSeconds": + 20400, "remSleepSeconds": 7380, "awakeSleepSeconds": 2460, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 92.0, "lowestSpO2Value": + 86, "highestSpO2Value": 98, "averageSpO2HRSleep": 46.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 5.0, "highestRespirationValue": 18.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-04T05:44:00.0", "sleepMeasurementEndGMT": "2021-07-04T14:21:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 92.0, "averageSpO2HR": 46.0, "lowestSPO2": 86}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d02d8920b6e5-QRO + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:39 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=OYnt5vplcguEr%2BMWMZrvvk0GYMP69QkpAj3VQB224nl7BED1UgTx6xl4cREfj7qvsK3c5FoCnCxzTUzuiz76EESc1Fzj1A1FzXo50JchiAGhlwo0PzigjF4iFd2TbIqTpkroihax6A%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-03 + response: + body: + string: '{"dailySleepDTO": {"id": 1625287440000, "userProfilePK": 2591602, "calendarDate": + "2021-07-03", "sleepTimeSeconds": 31560, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625287440000, "sleepEndTimestampGMT": 1625324100000, "sleepStartTimestampLocal": + 1625269440000, "sleepEndTimestampLocal": 1625306100000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 1260, "lightSleepSeconds": + 20820, "remSleepSeconds": 9480, "awakeSleepSeconds": 5100, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 94.0, "lowestSpO2Value": + 86, "highestSpO2Value": 100, "averageSpO2HRSleep": 48.0, "averageRespirationValue": + 15.0, "lowestRespirationValue": 9.0, "highestRespirationValue": 19.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-03T04:45:00.0", "sleepMeasurementEndGMT": "2021-07-03T14:51:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 94.0, "averageSpO2HR": 48.0, "lowestSPO2": 86}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d02fdea8479f-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:40 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=2zDoFbPuDLnEVyOygcc2ffTzJmal6bNbuXT5s8sxRx1k9CXheXfQt8pHYnV1FSYeZZNxh5mCMTBxZiTME442zDoAaHyPGcsPLy8UyjKuPFwp1hm1ohIN6yfKB%2F1cQmLBe3FTPxnQKQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-02 + response: + body: + string: '{"dailySleepDTO": {"id": 1625199840000, "userProfilePK": 2591602, "calendarDate": + "2021-07-02", "sleepTimeSeconds": 30600, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625199840000, "sleepEndTimestampGMT": 1625230740000, "sleepStartTimestampLocal": + 1625181840000, "sleepEndTimestampLocal": 1625212740000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 4620, "lightSleepSeconds": + 17040, "remSleepSeconds": 8940, "awakeSleepSeconds": 300, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 93.0, "lowestSpO2Value": + 76, "highestSpO2Value": 100, "averageSpO2HRSleep": 49.0, "averageRespirationValue": + 14.0, "lowestRespirationValue": 12.0, "highestRespirationValue": 17.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-02T04:25:00.0", "sleepMeasurementEndGMT": "2021-07-02T12:56:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 93.0, "averageSpO2HR": 49.0, "lowestSPO2": 76}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0323b94477e-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:40 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=GZsQF5tWMyKsN8SH%2Fm9w1R1dbJa%2BGtdX1pKGeCnk7vedyBCwc1XRmF%2FhhO%2B55KOuwMRMelQdt9ztchI7Oe770%2FxMjmdnEk1tOU0Ut%2FrXqE%2B4%2Bfe8yUp5cOmgNyi2T4ZX4yZZqZZgQQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/wellness/dailySleepData/mtamizi?nonSleepBufferMinutes=60&date=2021-07-01 + response: + body: + string: '{"dailySleepDTO": {"id": 1625121120000, "userProfilePK": 2591602, "calendarDate": + "2021-07-01", "sleepTimeSeconds": 18540, "napTimeSeconds": 0, "sleepWindowConfirmed": + true, "sleepWindowConfirmationType": "enhanced_confirmed_final", "sleepStartTimestampGMT": + 1625121120000, "sleepEndTimestampGMT": 1625139660000, "sleepStartTimestampLocal": + 1625103120000, "sleepEndTimestampLocal": 1625121660000, "autoSleepStartTimestampGMT": + null, "autoSleepEndTimestampGMT": null, "sleepQualityTypePK": null, "sleepResultTypePK": + null, "unmeasurableSleepSeconds": 0, "deepSleepSeconds": 6300, "lightSleepSeconds": + 9960, "remSleepSeconds": 2280, "awakeSleepSeconds": 0, "deviceRemCapable": + true, "retro": false, "sleepFromDevice": true, "averageSpO2Value": 94.0, "lowestSpO2Value": + 89, "highestSpO2Value": 100, "averageSpO2HRSleep": 49.0, "averageRespirationValue": + 15.0, "lowestRespirationValue": 11.0, "highestRespirationValue": 16.0, "sleepVersion": + 1}, "sleepMovement": [], "remSleepData": true, "sleepLevels": [], "wellnessSpO2SleepSummaryDTO": + {"userProfilePk": 2591602, "deviceId": 3329978681, "sleepMeasurementStartGMT": + "2021-07-01T06:33:00.0", "sleepMeasurementEndGMT": "2021-07-01T11:41:00.0", + "alertThresholdValue": null, "numberOfEventsBelowThreshold": null, "durationOfEventsBelowThreshold": + null, "averageSPO2": 94.0, "averageSpO2HR": 49.0, "lowestSPO2": 89}}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d03468604648-DFW + Connection: + - keep-alive + Content-Type: + - application/json;charset=UTF-8 + Date: + - Fri, 04 Aug 2023 00:51:40 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=mt8J8CRV5GtFo8E8D26OaBraXA6evjbJYOOVglh7eOBYQxrZMo8A5evAgOGF7%2BJXYx2OQEw4ewL4vDmEFd7sp8XDG9OgCJjPDmAAtcbpRQrWW%2BYIBZ3gljamEq0T1dDz03YQTb4u%2BQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_weight_data_list.yaml b/garth/tests/data/cassettes/test_weight_data_list.yaml new file mode 100644 index 0000000..07ffb28 --- /dev/null +++ b/garth/tests/data/cassettes/test_weight_data_list.yaml @@ -0,0 +1,97 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://connectapi.garmin.com/weight-service/weight/range/2025-06-01/2025-06-15?includeAll=true + response: + body: + string: '{"dailyWeightSummaries": [{"summaryDate": "2025-06-15", "numOfWeightEntries": + 1, "minWeight": 59720.0, "maxWeight": 59720.0, "latestWeight": {"samplePk": + 1749996902851, "date": 1749975276000, "calendarDate": "2025-06-15", "weight": + 59720.0, "bmi": 22.799999237060547, "bodyFat": 19.3, "bodyWater": 58.9, "boneMass": + 3539, "muscleMass": 26979, "physiqueRating": null, "visceralFat": null, "metabolicAge": + null, "sourceType": "INDEX_SCALE", "timestampGMT": 1749996876000, "weightDelta": + 200.00000000000284}, "allWeightMetrics": [{"samplePk": 1749996902851, "date": + 1749975276000, "calendarDate": "2025-06-15", "weight": 59720.0, "bmi": 22.799999237060547, + "bodyFat": 19.3, "bodyWater": 58.9, "boneMass": 3539, "muscleMass": 26979, + "physiqueRating": null, "visceralFat": null, "metabolicAge": null, "sourceType": + "INDEX_SCALE", "timestampGMT": 1749996876000, "weightDelta": 200.00000000000284}]}, + {"summaryDate": "2025-06-14", "numOfWeightEntries": 2, "minWeight": 59130.0, + "maxWeight": 59500.0, "latestWeight": {"samplePk": 1749948744411, "date": + 1749927125175, "calendarDate": "2025-06-14", "weight": 59500.0, "bmi": null, + "bodyFat": null, "bodyWater": null, "boneMass": null, "muscleMass": null, + "physiqueRating": null, "visceralFat": null, "metabolicAge": null, "sourceType": + "MANUAL", "timestampGMT": 1749948725175, "weightDelta": 299.99999999999716}, + "allWeightMetrics": [{"samplePk": 1749948744411, "date": 1749927125175, "calendarDate": + "2025-06-14", "weight": 59500.0, "bmi": null, "bodyFat": null, "bodyWater": + null, "boneMass": null, "muscleMass": null, "physiqueRating": null, "visceralFat": + null, "metabolicAge": null, "sourceType": "MANUAL", "timestampGMT": 1749948725175, + "weightDelta": 399.9999999999986}, {"samplePk": 1749909217098, "date": 1749887580000, + "calendarDate": "2025-06-14", "weight": 59130.0, "bmi": 22.5, "bodyFat": 20.3, + "bodyWater": 58.2, "boneMass": 3430, "muscleMass": 26840, "physiqueRating": + null, "visceralFat": null, "metabolicAge": null, "sourceType": "INDEX_SCALE", + "timestampGMT": 1749909180000, "weightDelta": -100.00000000000142}]}, {"summaryDate": + "2025-06-07", "numOfWeightEntries": 1, "minWeight": 59189.0, "maxWeight": + 59189.0, "latestWeight": {"samplePk": 1749307692871, "date": 1749286058000, + "calendarDate": "2025-06-07", "weight": 59189.0, "bmi": 22.600000381469727, + "bodyFat": 20.0, "bodyWater": 58.4, "boneMass": 3450, "muscleMass": 26850, + "physiqueRating": null, "visceralFat": null, "metabolicAge": null, "sourceType": + "INDEX_SCALE", "timestampGMT": 1749307658000, "weightDelta": 500.0}, "allWeightMetrics": + [{"samplePk": 1749307692871, "date": 1749286058000, "calendarDate": "2025-06-07", + "weight": 59189.0, "bmi": 22.600000381469727, "bodyFat": 20.0, "bodyWater": + 58.4, "boneMass": 3450, "muscleMass": 26850, "physiqueRating": null, "visceralFat": + null, "metabolicAge": null, "sourceType": "INDEX_SCALE", "timestampGMT": 1749307658000, + "weightDelta": 500.0}]}], "totalAverage": {"from": 1748736000000, "until": + 1750031999999, "weight": 59469.666666666664, "bmi": 22.699999809265137, "bodyFat": + 19.7, "bodyWater": 58.7, "boneMass": 3494, "muscleMass": 26914, "physiqueRating": + null, "visceralFat": null, "metabolicAge": null}, "previousDateWeight": {"samplePk": + 1748709464191, "date": 1748687805000, "calendarDate": "2025-05-31", "weight": + 58700.0, "bmi": 22.399999618530273, "bodyFat": 20.7, "bodyWater": 57.9, "boneMass": + 3369, "muscleMass": 26729, "physiqueRating": null, "visceralFat": null, "metabolicAge": + null, "sourceType": "INDEX_SCALE", "timestampGMT": 1748709405000, "weightDelta": + null}, "nextDateWeight": {"samplePk": null, "date": null, "calendarDate": + null, "weight": null, "bmi": null, "bodyFat": null, "bodyWater": null, "boneMass": + null, "muscleMass": null, "physiqueRating": null, "visceralFat": null, "metabolicAge": + null, "sourceType": null, "timestampGMT": null, "weightDelta": null}}' + headers: + CF-RAY: + - 95064b68690b1f84-QRO + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Mon, 16 Jun 2025 00:47:12 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=9ExXlb7xohhNWV42MyBDMFTW8fcvDW7s7NvGZZsQ7QjtfUyT%2FYq2LTKDwbG1mdwpyUYacYYBjzSOZNw3Tu8MfsrfLBPOgWE4LsgwmirKigo5mVi5%2FJqIfZgyWULExMxPoeX88D%2B6iXcluwUE8dlp4VL2yA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_weight_data_list_empty.yaml b/garth/tests/data/cassettes/test_weight_data_list_empty.yaml new file mode 100644 index 0000000..af14142 --- /dev/null +++ b/garth/tests/data/cassettes/test_weight_data_list_empty.yaml @@ -0,0 +1,61 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://connectapi.garmin.com/weight-service/weight/range/2019-12-18/2020-01-01?includeAll=true + response: + body: + string: '{"dailyWeightSummaries": [], "totalAverage": {"from": 1576627200000, + "until": 1577923199999, "weight": null, "bmi": null, "bodyFat": null, "bodyWater": + null, "boneMass": null, "muscleMass": null, "physiqueRating": null, "visceralFat": + null, "metabolicAge": null}, "previousDateWeight": {"samplePk": null, "date": + null, "calendarDate": null, "weight": null, "bmi": null, "bodyFat": null, + "bodyWater": null, "boneMass": null, "muscleMass": null, "physiqueRating": + null, "visceralFat": null, "metabolicAge": null, "sourceType": null, "timestampGMT": + null, "weightDelta": null}, "nextDateWeight": {"samplePk": null, "date": null, + "calendarDate": null, "weight": null, "bmi": null, "bodyFat": null, "bodyWater": + null, "boneMass": null, "muscleMass": null, "physiqueRating": null, "visceralFat": + null, "metabolicAge": null, "sourceType": null, "timestampGMT": null, "weightDelta": + null}}' + headers: + CF-RAY: + - 95065fe3afea2fde-QRO + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Mon, 16 Jun 2025 01:01:11 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=YZscbyvERqaC8NIT00%2Fv%2FV3X%2BSEXE8LosKNrrmILOYZWBqF906BX31WBG9C5u4NtRh73%2BRPj2OyWX%2FgtYZcd9QricbIkwL8Np9kXdKtPcufnwwAg7odFD4X4JnUeS0d%2BEk1u5Kb2VAIyW4O%2BxfR1FNVErw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/cassettes/test_weight_data_list_single_day.yaml b/garth/tests/data/cassettes/test_weight_data_list_single_day.yaml new file mode 100644 index 0000000..56010ff --- /dev/null +++ b/garth/tests/data/cassettes/test_weight_data_list_single_day.yaml @@ -0,0 +1,77 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://connectapi.garmin.com/weight-service/weight/range/2025-06-14/2025-06-14?includeAll=true + response: + body: + string: '{"dailyWeightSummaries": [{"summaryDate": "2025-06-14", "numOfWeightEntries": + 2, "minWeight": 59130.0, "maxWeight": 59500.0, "latestWeight": {"samplePk": + 1749948744411, "date": 1749927125175, "calendarDate": "2025-06-14", "weight": + 59500.0, "bmi": null, "bodyFat": null, "bodyWater": null, "boneMass": null, + "muscleMass": null, "physiqueRating": null, "visceralFat": null, "metabolicAge": + null, "sourceType": "MANUAL", "timestampGMT": 1749948725175, "weightDelta": + 299.99999999999716}, "allWeightMetrics": [{"samplePk": 1749948744411, "date": + 1749927125175, "calendarDate": "2025-06-14", "weight": 59500.0, "bmi": null, + "bodyFat": null, "bodyWater": null, "boneMass": null, "muscleMass": null, + "physiqueRating": null, "visceralFat": null, "metabolicAge": null, "sourceType": + "MANUAL", "timestampGMT": 1749948725175, "weightDelta": 399.9999999999986}, + {"samplePk": 1749909217098, "date": 1749887580000, "calendarDate": "2025-06-14", + "weight": 59130.0, "bmi": 22.5, "bodyFat": 20.3, "bodyWater": 58.2, "boneMass": + 3430, "muscleMass": 26840, "physiqueRating": null, "visceralFat": null, "metabolicAge": + null, "sourceType": "INDEX_SCALE", "timestampGMT": 1749909180000, "weightDelta": + -100.00000000000142}]}], "totalAverage": {"from": 1749859200000, "until": + 1749945599999, "weight": 59500.0, "bmi": null, "bodyFat": null, "bodyWater": + null, "boneMass": null, "muscleMass": null, "physiqueRating": null, "visceralFat": + null, "metabolicAge": null}, "previousDateWeight": {"samplePk": 1749307692871, + "date": 1749286058000, "calendarDate": "2025-06-07", "weight": 59189.0, "bmi": + 22.600000381469727, "bodyFat": 20.0, "bodyWater": 58.4, "boneMass": 3450, + "muscleMass": 26850, "physiqueRating": null, "visceralFat": null, "metabolicAge": + null, "sourceType": "INDEX_SCALE", "timestampGMT": 1749307658000, "weightDelta": + null}, "nextDateWeight": {"samplePk": 1749996902851, "date": 1749975276000, + "calendarDate": "2025-06-15", "weight": 59720.0, "bmi": 22.799999237060547, + "bodyFat": 19.3, "bodyWater": 58.9, "boneMass": 3539, "muscleMass": 26979, + "physiqueRating": null, "visceralFat": null, "metabolicAge": null, "sourceType": + "INDEX_SCALE", "timestampGMT": 1749996876000, "weightDelta": null}}' + headers: + CF-RAY: + - 9506620b6d30b6e5-QRO + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Mon, 16 Jun 2025 01:02:39 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=TNhpJPozun%2FMkRaaYU%2FYH7B2ZrX%2BfDEbq2rKyeuDmDpxQgshSkQTs0eOWr0XO1i1EwLmf%2F0SYtAecesFwm0eugpiNFopVrsvBlvMj1vk3RaPwL37B46JBHOYvrvm1OhMNzNqTF7QWLHAFYe%2Bk6zeTmTcVQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/data/test_body_battery_data.py b/garth/tests/data/test_body_battery_data.py new file mode 100644 index 0000000..55636c6 --- /dev/null +++ b/garth/tests/data/test_body_battery_data.py @@ -0,0 +1,335 @@ +from datetime import date +from unittest.mock import MagicMock + +import pytest + +from garth import BodyBatteryData, DailyBodyBatteryStress +from garth.http import Client + + +@pytest.mark.vcr +def test_body_battery_data_get(authed_client: Client): + body_battery_data = BodyBatteryData.get("2023-07-20", client=authed_client) + assert isinstance(body_battery_data, list) + + if body_battery_data: + # Check first event if available + event = body_battery_data[0] + assert event is not None + + # Test body battery readings property + readings = event.body_battery_readings + assert isinstance(readings, list) + + if readings: + # Test reading structure + reading = readings[0] + assert hasattr(reading, "timestamp") + assert hasattr(reading, "status") + assert hasattr(reading, "level") + assert hasattr(reading, "version") + + # Test level properties + assert event.current_level is not None and isinstance( + event.current_level, int + ) + assert event.max_level is not None and isinstance( + event.max_level, int + ) + assert event.min_level is not None and isinstance( + event.min_level, int + ) + + +@pytest.mark.vcr +def test_body_battery_data_list(authed_client: Client): + days = 3 + end = date(2023, 7, 20) + body_battery_data = BodyBatteryData.list(end, days, client=authed_client) + assert isinstance(body_battery_data, list) + + # Test that we get data (may be empty if no events) + assert len(body_battery_data) >= 0 + + +@pytest.mark.vcr +def test_daily_body_battery_stress_get(authed_client: Client): + daily_data = DailyBodyBatteryStress.get("2023-07-20", client=authed_client) + + if daily_data: + # Test basic structure + assert daily_data.user_profile_pk + assert daily_data.calendar_date == date(2023, 7, 20) + assert daily_data.start_timestamp_gmt + assert daily_data.end_timestamp_gmt + + # Test stress data + assert isinstance(daily_data.max_stress_level, int) + assert isinstance(daily_data.avg_stress_level, int) + assert isinstance(daily_data.stress_values_array, list) + assert isinstance(daily_data.body_battery_values_array, list) + + # Test stress readings property + stress_readings = daily_data.stress_readings + assert isinstance(stress_readings, list) + + if stress_readings: + stress_reading = stress_readings[0] + assert hasattr(stress_reading, "timestamp") + assert hasattr(stress_reading, "stress_level") + + # Test body battery readings property + bb_readings = daily_data.body_battery_readings + assert isinstance(bb_readings, list) + + if bb_readings: + bb_reading = bb_readings[0] + assert hasattr(bb_reading, "timestamp") + assert hasattr(bb_reading, "status") + assert hasattr(bb_reading, "level") + assert hasattr(bb_reading, "version") + + # Test computed properties + assert daily_data.current_body_battery is not None and isinstance( + daily_data.current_body_battery, int + ) + assert daily_data.max_body_battery is not None and isinstance( + daily_data.max_body_battery, int + ) + assert daily_data.min_body_battery is not None and isinstance( + daily_data.min_body_battery, int + ) + + # Test body battery change + if len(bb_readings) >= 2: + change = daily_data.body_battery_change + assert change is not None + + +@pytest.mark.vcr +def test_daily_body_battery_stress_get_no_data(authed_client: Client): + # Test with a date that likely has no data + daily_data = DailyBodyBatteryStress.get("2020-01-01", client=authed_client) + # Should return None if no data available + assert daily_data is None or isinstance(daily_data, DailyBodyBatteryStress) + + +@pytest.mark.vcr +def test_daily_body_battery_stress_list(authed_client: Client): + days = 3 + end = date(2023, 7, 20) + # Use max_workers=1 to avoid VCR issues with concurrent requests + daily_data_list = DailyBodyBatteryStress.list( + end, days, client=authed_client, max_workers=1 + ) + assert isinstance(daily_data_list, list) + assert ( + len(daily_data_list) <= days + ) # May be less if some days have no data + + # Test that each item is correct type + for daily_data in daily_data_list: + assert isinstance(daily_data, DailyBodyBatteryStress) + assert isinstance(daily_data.calendar_date, date) + assert daily_data.user_profile_pk + + +@pytest.mark.vcr +def test_body_battery_properties_edge_cases(authed_client: Client): + # Test empty data handling + daily_data = DailyBodyBatteryStress.get("2023-07-20", client=authed_client) + + if daily_data: + # Test with potentially empty arrays + if not daily_data.body_battery_values_array: + assert daily_data.body_battery_readings == [] + assert daily_data.current_body_battery is None + assert daily_data.max_body_battery is None + assert daily_data.min_body_battery is None + assert daily_data.body_battery_change is None + + if not daily_data.stress_values_array: + assert daily_data.stress_readings == [] + + +# Error handling tests for BodyBatteryData.get() +def test_body_battery_data_get_api_error(): + """Test handling of API errors.""" + mock_client = MagicMock() + mock_client.connectapi.side_effect = Exception("API Error") + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + assert result == [] + + +def test_body_battery_data_get_invalid_response(): + """Test handling of non-list responses.""" + mock_client = MagicMock() + mock_client.connectapi.return_value = {"error": "Invalid response"} + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + assert result == [] + + +def test_body_battery_data_get_missing_event_data(): + """Test handling of items with missing event data.""" + mock_client = MagicMock() + mock_client.connectapi.return_value = [ + {"activityName": "Test", "averageStress": 25} # Missing "event" key + ] + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + assert len(result) == 1 + assert result[0].event is None + + +def test_body_battery_data_get_missing_event_start_time(): + """Test handling of event data missing eventStartTimeGmt.""" + mock_client = MagicMock() + mock_client.connectapi.return_value = [ + { + "event": {"eventType": "sleep"}, # Missing eventStartTimeGmt + "activityName": "Test", + "averageStress": 25, + } + ] + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + assert result == [] # Should skip invalid items + + +def test_body_battery_data_get_invalid_datetime_format(): + """Test handling of invalid datetime format.""" + mock_client = MagicMock() + mock_client.connectapi.return_value = [ + { + "event": { + "eventType": "sleep", + "eventStartTimeGmt": "invalid-date", + }, + "activityName": "Test", + "averageStress": 25, + } + ] + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + assert result == [] # Should skip invalid items + + +def test_body_battery_data_get_invalid_field_types(): + """Test handling of invalid field types.""" + mock_client = MagicMock() + mock_client.connectapi.return_value = [ + { + "event": { + "eventType": "sleep", + "eventStartTimeGmt": "2023-07-20T10:00:00.000Z", + "timezoneOffset": "invalid", # Should be number + "durationInMilliseconds": "invalid", # Should be number + "bodyBatteryImpact": "invalid", # Should be number + }, + "activityName": "Test", + "averageStress": "invalid", # Should be number + "stressValuesArray": "invalid", # Should be list + "bodyBatteryValuesArray": "invalid", # Should be list + } + ] + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + assert len(result) == 1 + # Should handle invalid types gracefully + + +def test_body_battery_data_get_validation_error(): + """Test handling of validation errors during object creation.""" + mock_client = MagicMock() + mock_client.connectapi.return_value = [ + { + "event": { + "eventType": "sleep", + "eventStartTimeGmt": "2023-07-20T10:00:00.000Z", + # Missing required fields for BodyBatteryEvent + }, + # Missing required fields for BodyBatteryData + } + ] + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + # Should handle validation errors and continue processing + assert isinstance(result, list) + assert len(result) == 1 # Should create object with missing fields as None + assert result[0].event is not None # Event should be created + assert result[0].activity_name is None # Missing fields should be None + + +def test_body_battery_data_get_mixed_valid_invalid(): + """Test processing with mix of valid and invalid items.""" + mock_client = MagicMock() + mock_client.connectapi.return_value = [ + { + "event": { + "eventType": "sleep", + "eventStartTimeGmt": "2023-07-20T10:00:00.000Z", + "timezoneOffset": -25200000, + "durationInMilliseconds": 28800000, + "bodyBatteryImpact": 35, + "feedbackType": "good_sleep", + "shortFeedback": "Good sleep", + }, + "activityName": None, + "activityType": None, + "activityId": None, + "averageStress": 15.5, + "stressValuesArray": [[1689811800000, 12]], + "bodyBatteryValuesArray": [[1689811800000, "charging", 45, 1.0]], + }, + { + # Invalid - missing eventStartTimeGmt + "event": {"eventType": "sleep"}, + "activityName": "Test", + }, + ] + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + # Should process valid items and skip invalid ones + assert len(result) == 1 # Only the valid item should be processed + assert result[0].event is not None + + +def test_body_battery_data_get_unexpected_error(): + """Test handling of unexpected errors during object creation.""" + mock_client = MagicMock() + + # Create a special object that raises an exception when accessed + class ExceptionRaisingDict(dict): + def get(self, key, default=None): + if key == "activityName": + raise RuntimeError("Unexpected error during object creation") + return super().get(key, default) + + # Create mock data with problematic item + mock_response_item = ExceptionRaisingDict( + { + "event": { + "eventType": "sleep", + "eventStartTimeGmt": "2023-07-20T10:00:00.000Z", + "timezoneOffset": -25200000, + "durationInMilliseconds": 28800000, + "bodyBatteryImpact": 35, + "feedbackType": "good_sleep", + "shortFeedback": "Good sleep", + }, + "activityName": None, + "activityType": None, + "activityId": None, + "averageStress": 15.5, + "stressValuesArray": [[1689811800000, 12]], + "bodyBatteryValuesArray": [[1689811800000, "charging", 45, 1.0]], + } + ) + + mock_client.connectapi.return_value = [mock_response_item] + + result = BodyBatteryData.get("2023-07-20", client=mock_client) + # Should handle unexpected errors and return empty list + assert result == [] diff --git a/garth/tests/data/test_hrv_data.py b/garth/tests/data/test_hrv_data.py new file mode 100644 index 0000000..91abd71 --- /dev/null +++ b/garth/tests/data/test_hrv_data.py @@ -0,0 +1,25 @@ +from datetime import date + +import pytest + +from garth import HRVData +from garth.http import Client + + +@pytest.mark.vcr +def test_hrv_data_get(authed_client: Client): + hrv_data = HRVData.get("2023-07-20", client=authed_client) + assert hrv_data + assert hrv_data.user_profile_pk + assert hrv_data.hrv_summary.calendar_date == date(2023, 7, 20) + + assert HRVData.get("2021-07-20", client=authed_client) is None + + +@pytest.mark.vcr +def test_hrv_data_list(authed_client: Client): + days = 2 + end = date(2023, 7, 20) + hrv_data = HRVData.list(end, days, client=authed_client, max_workers=1) + assert len(hrv_data) == days + assert hrv_data[-1].hrv_summary.calendar_date == end diff --git a/garth/tests/data/test_sleep_data.py b/garth/tests/data/test_sleep_data.py new file mode 100644 index 0000000..dfedb57 --- /dev/null +++ b/garth/tests/data/test_sleep_data.py @@ -0,0 +1,24 @@ +from datetime import date + +import pytest + +from garth import SleepData +from garth.http import Client + + +@pytest.mark.vcr +def test_sleep_data_get(authed_client: Client): + sleep_data = SleepData.get("2021-07-20", client=authed_client) + assert sleep_data + assert sleep_data.daily_sleep_dto.calendar_date == date(2021, 7, 20) + assert sleep_data.daily_sleep_dto.sleep_start + assert sleep_data.daily_sleep_dto.sleep_end + + +@pytest.mark.vcr +def test_sleep_data_list(authed_client: Client): + end = date(2021, 7, 20) + days = 20 + sleep_data = SleepData.list(end, days, client=authed_client, max_workers=1) + assert sleep_data[-1].daily_sleep_dto.calendar_date == end + assert len(sleep_data) == days diff --git a/garth/tests/data/test_weight_data.py b/garth/tests/data/test_weight_data.py new file mode 100644 index 0000000..d7848bc --- /dev/null +++ b/garth/tests/data/test_weight_data.py @@ -0,0 +1,74 @@ +from datetime import date, timedelta, timezone + +import pytest + +from garth.data import WeightData +from garth.http import Client + + +@pytest.mark.vcr +def test_get_daily_weight_data(authed_client: Client): + weight_data = WeightData.get(date(2025, 6, 15), client=authed_client) + assert weight_data is not None + assert weight_data.source_type == "INDEX_SCALE" + assert weight_data.weight is not None + assert weight_data.bmi is not None + assert weight_data.body_fat is not None + assert weight_data.body_water is not None + assert weight_data.bone_mass is not None + assert weight_data.muscle_mass is not None + # Timezone should match your account settings, my case is -6 + assert weight_data.datetime_local.tzinfo == timezone(timedelta(hours=-6)) + assert weight_data.datetime_utc.tzinfo == timezone.utc + + +@pytest.mark.vcr +def test_get_manual_weight_data(authed_client: Client): + weight_data = WeightData.get(date(2025, 6, 14), client=authed_client) + assert weight_data is not None + assert weight_data.source_type == "MANUAL" + assert weight_data.weight is not None + assert weight_data.bmi is None + assert weight_data.body_fat is None + assert weight_data.body_water is None + assert weight_data.bone_mass is None + assert weight_data.muscle_mass is None + + +@pytest.mark.vcr +def test_get_nonexistent_weight_data(authed_client: Client): + weight_data = WeightData.get(date(2020, 1, 1), client=authed_client) + assert weight_data is None + + +@pytest.mark.vcr +def test_weight_data_list(authed_client: Client): + end = date(2025, 6, 15) + days = 15 + weight_data = WeightData.list(end, days, client=authed_client) + + # Only 4 weight entries recorded at time of test + assert len(weight_data) == 4 + assert all(isinstance(data, WeightData) for data in weight_data) + assert all( + weight_data[i].datetime_utc <= weight_data[i + 1].datetime_utc + for i in range(len(weight_data) - 1) + ) + + +@pytest.mark.vcr +def test_weight_data_list_single_day(authed_client: Client): + end = date(2025, 6, 14) + weight_data = WeightData.list(end, client=authed_client) + assert len(weight_data) == 2 + assert all(isinstance(data, WeightData) for data in weight_data) + assert weight_data[0].source_type == "INDEX_SCALE" + assert weight_data[1].source_type == "MANUAL" + + +@pytest.mark.vcr +def test_weight_data_list_empty(authed_client: Client): + end = date(2020, 1, 1) + days = 15 + weight_data = WeightData.list(end, days, client=authed_client) + assert len(weight_data) == 0 diff --git a/garth/tests/stats/cassettes/test_daily_hrv.yaml b/garth/tests/stats/cassettes/test_daily_hrv.yaml new file mode 100644 index 0000000..0b18ba9 --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_hrv.yaml @@ -0,0 +1,128 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/daily/2023-07-01/2023-07-20 + response: + body: + string: '{"hrvSummaries": [{"calendarDate": "2023-07-01", "weeklyAvg": 43, "lastNightAvg": + 43, "lastNight5MinHigh": 60, "baseline": {"lowUpper": 35, "balancedLow": 38, + "balancedUpper": 52, "markerValue": 0.42855835}, "status": "BALANCED", "feedbackPhrase": + "HRV_BALANCED_8", "createTimeStamp": "2023-07-01T12:27:14.85"}, {"calendarDate": + "2023-07-02", "weeklyAvg": 43, "lastNightAvg": 44, "lastNight5MinHigh": 63, + "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 51, "markerValue": + 0.44230652}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": + "2023-07-02T11:54:17.128"}, {"calendarDate": "2023-07-03", "weeklyAvg": 43, + "lastNightAvg": 48, "lastNight5MinHigh": 82, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.42855835}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": "2023-07-03T12:41:20.280"}, + {"calendarDate": "2023-07-04", "weeklyAvg": 43, "lastNightAvg": 40, "lastNight5MinHigh": + 80, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.42855835}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": + "2023-07-04T11:41:59.456"}, {"calendarDate": "2023-07-05", "weeklyAvg": 43, + "lastNightAvg": 40, "lastNight5MinHigh": 67, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.42855835}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": "2023-07-05T12:46:25.805"}, + {"calendarDate": "2023-07-06", "weeklyAvg": 43, "lastNightAvg": 46, "lastNight5MinHigh": + 58, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.42855835}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": + "2023-07-06T17:20:46.196"}, {"calendarDate": "2023-07-07", "weeklyAvg": 44, + "lastNightAvg": 44, "lastNight5MinHigh": 85, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.46427917}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": "2023-07-07T12:15:26.744"}, + {"calendarDate": "2023-07-08", "weeklyAvg": 43, "lastNightAvg": 40, "lastNight5MinHigh": + 63, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.42855835}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": + "2023-07-09T01:57:41.693"}, {"calendarDate": "2023-07-09", "weeklyAvg": 43, + "lastNightAvg": 43, "lastNight5MinHigh": 66, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.42855835}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": "2023-07-09T14:15:53.403"}, + {"calendarDate": "2023-07-10", "weeklyAvg": 42, "lastNightAvg": 41, "lastNight5MinHigh": + 62, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.3653717}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": + "2023-07-10T12:43:37.356"}, {"calendarDate": "2023-07-11", "weeklyAvg": 43, + "lastNightAvg": 46, "lastNight5MinHigh": 67, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.4038391}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": "2023-07-11T12:42:55.467"}, + {"calendarDate": "2023-07-12", "weeklyAvg": 42, "lastNightAvg": 38, "lastNight5MinHigh": + 56, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.3653717}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": + "2023-07-12T10:08:55.474"}, {"calendarDate": "2023-07-13", "weeklyAvg": 42, + "lastNightAvg": 41, "lastNight5MinHigh": 66, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.3653717}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": "2023-07-13T12:59:44.753"}, + {"calendarDate": "2023-07-14", "weeklyAvg": 41, "lastNightAvg": 37, "lastNight5MinHigh": + 57, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.32691956}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": + "2023-07-14T12:16:07.618"}, {"calendarDate": "2023-07-15", "weeklyAvg": 40, + "lastNightAvg": 37, "lastNight5MinHigh": 54, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.28845215}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": "2023-07-15T18:18:32.522"}, + {"calendarDate": "2023-07-16", "weeklyAvg": 39, "lastNightAvg": 37, "lastNight5MinHigh": + 64, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.25}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": + "2023-07-17T03:13:54.585"}, {"calendarDate": "2023-07-17", "weeklyAvg": 39, + "lastNightAvg": 41, "lastNight5MinHigh": 65, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.25}, "status": "BALANCED", + "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": "2023-07-17T11:58:26.731"}, + {"calendarDate": "2023-07-18", "weeklyAvg": 39, "lastNightAvg": 40, "lastNight5MinHigh": + 72, "baseline": {"lowUpper": 36, "balancedLow": 40, "balancedUpper": 52, "markerValue": + 0.22801208}, "status": "UNBALANCED", "feedbackPhrase": "HRV_UNBALANCED_12", + "createTimeStamp": "2023-07-18T13:45:54.638"}, {"calendarDate": "2023-07-19", + "weeklyAvg": 39, "lastNightAvg": 43, "lastNight5MinHigh": 60, "baseline": + {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.25}, + "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_4", "createTimeStamp": + "2023-07-19T14:43:16.394"}, {"calendarDate": "2023-07-20", "weeklyAvg": 39, + "lastNightAvg": 42, "lastNight5MinHigh": 66, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.25}, "status": "BALANCED", + "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": "2023-07-20T12:14:11.898"}], + "userProfilePk": 2591602}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12cffb1bf04740-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:31 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=FwXXbkT4TDPL0xwdyj0pemCK5IZtMhJ0cEJStvFh9rhUuwEgA9nPQyW5%2F78guNWU4c0CMB5arBD5aYFCFwrJ0S9cXV%2BHnxbblaMvHkHhr3XZNcHySwLfohsTZBtkWiUT4iZVWVGDgg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_hrv_no_results.yaml b/garth/tests/stats/cassettes/test_daily_hrv_no_results.yaml new file mode 100644 index 0000000..87a2cbb --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_hrv_no_results.yaml @@ -0,0 +1,54 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/daily/1990-06-23/1990-07-20 + response: + body: + string: '' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12cfff895a46e6-DFW + Connection: + - keep-alive + Date: + - Fri, 04 Aug 2023 00:51:32 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=c5M1eFSWXRssBQjJffsEsd2fyEVImSUgt64bWpiVisHYL7YajNn2yfJIhcd6yueOyfUrDXvCDZJiZ9%2BVQfAAHMEaRxu%2B8ZZj7iPBiNff%2Fl9O9KJ6SIX1qHMttNFKtEcxoc5Vl0E5Gw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 204 + message: No Content +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_hrv_paginate.yaml b/garth/tests/stats/cassettes/test_daily_hrv_paginate.yaml new file mode 100644 index 0000000..ac39049 --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_hrv_paginate.yaml @@ -0,0 +1,256 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/daily/2023-06-23/2023-07-20 + response: + body: + string: '{"hrvSummaries": [{"calendarDate": "2023-06-23", "weeklyAvg": 40, "lastNightAvg": + 42, "lastNight5MinHigh": 54, "baseline": {"lowUpper": 35, "balancedLow": 38, + "balancedUpper": 52, "markerValue": 0.3214264}, "status": "BALANCED", "feedbackPhrase": + "HRV_BALANCED_8", "createTimeStamp": "2023-06-25T04:55:32.475"}, {"calendarDate": + "2023-06-24", "weeklyAvg": 41, "lastNightAvg": 43, "lastNight5MinHigh": 69, + "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.35713196}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": + "2023-06-25T04:56:02.128"}, {"calendarDate": "2023-06-25", "weeklyAvg": 41, + "lastNightAvg": 41, "lastNight5MinHigh": 63, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 51, "markerValue": 0.3653717}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": "2023-06-25T12:30:49.823"}, + {"calendarDate": "2023-06-26", "weeklyAvg": 42, "lastNightAvg": 50, "lastNight5MinHigh": + 113, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, + "markerValue": 0.39285278}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", + "createTimeStamp": "2023-06-26T15:16:53.873"}, {"calendarDate": "2023-06-27", + "weeklyAvg": 41, "lastNightAvg": 39, "lastNight5MinHigh": 63, "baseline": + {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.35713196}, + "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": + "2023-06-27T12:38:37.557"}, {"calendarDate": "2023-06-28", "weeklyAvg": 42, + "lastNightAvg": 39, "lastNight5MinHigh": 63, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.39285278}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": "2023-06-28T12:44:11.280"}, + {"calendarDate": "2023-06-29", "weeklyAvg": 43, "lastNightAvg": 47, "lastNight5MinHigh": + 78, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.42855835}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": + "2023-06-29T13:30:15.112"}, {"calendarDate": "2023-06-30", "weeklyAvg": 43, + "lastNightAvg": 40, "lastNight5MinHigh": 65, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.42855835}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": "2023-06-30T14:19:24.203"}, + {"calendarDate": "2023-07-01", "weeklyAvg": 43, "lastNightAvg": 43, "lastNight5MinHigh": + 60, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.42855835}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": + "2023-07-01T12:27:14.85"}, {"calendarDate": "2023-07-02", "weeklyAvg": 43, + "lastNightAvg": 44, "lastNight5MinHigh": 63, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 51, "markerValue": 0.44230652}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": "2023-07-02T11:54:17.128"}, + {"calendarDate": "2023-07-03", "weeklyAvg": 43, "lastNightAvg": 48, "lastNight5MinHigh": + 82, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.42855835}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": + "2023-07-03T12:41:20.280"}, {"calendarDate": "2023-07-04", "weeklyAvg": 43, + "lastNightAvg": 40, "lastNight5MinHigh": 80, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.42855835}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": "2023-07-04T11:41:59.456"}, + {"calendarDate": "2023-07-05", "weeklyAvg": 43, "lastNightAvg": 40, "lastNight5MinHigh": + 67, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.42855835}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": + "2023-07-05T12:46:25.805"}, {"calendarDate": "2023-07-06", "weeklyAvg": 43, + "lastNightAvg": 46, "lastNight5MinHigh": 58, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.42855835}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": "2023-07-06T17:20:46.196"}, + {"calendarDate": "2023-07-07", "weeklyAvg": 44, "lastNightAvg": 44, "lastNight5MinHigh": + 85, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.46427917}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": + "2023-07-07T12:15:26.744"}, {"calendarDate": "2023-07-08", "weeklyAvg": 43, + "lastNightAvg": 40, "lastNight5MinHigh": 63, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.42855835}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": "2023-07-09T01:57:41.693"}, + {"calendarDate": "2023-07-09", "weeklyAvg": 43, "lastNightAvg": 43, "lastNight5MinHigh": + 66, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.42855835}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": + "2023-07-09T14:15:53.403"}, {"calendarDate": "2023-07-10", "weeklyAvg": 42, + "lastNightAvg": 41, "lastNight5MinHigh": 62, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.3653717}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": "2023-07-10T12:43:37.356"}, + {"calendarDate": "2023-07-11", "weeklyAvg": 43, "lastNightAvg": 46, "lastNight5MinHigh": + 67, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.4038391}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": + "2023-07-11T12:42:55.467"}, {"calendarDate": "2023-07-12", "weeklyAvg": 42, + "lastNightAvg": 38, "lastNight5MinHigh": 56, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.3653717}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": "2023-07-12T10:08:55.474"}, + {"calendarDate": "2023-07-13", "weeklyAvg": 42, "lastNightAvg": 41, "lastNight5MinHigh": + 66, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.3653717}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": + "2023-07-13T12:59:44.753"}, {"calendarDate": "2023-07-14", "weeklyAvg": 41, + "lastNightAvg": 37, "lastNight5MinHigh": 57, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.32691956}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": "2023-07-14T12:16:07.618"}, + {"calendarDate": "2023-07-15", "weeklyAvg": 40, "lastNightAvg": 37, "lastNight5MinHigh": + 54, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.28845215}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": + "2023-07-15T18:18:32.522"}, {"calendarDate": "2023-07-16", "weeklyAvg": 39, + "lastNightAvg": 37, "lastNight5MinHigh": 64, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.25}, "status": "BALANCED", + "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": "2023-07-17T03:13:54.585"}, + {"calendarDate": "2023-07-17", "weeklyAvg": 39, "lastNightAvg": 41, "lastNight5MinHigh": + 65, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.25}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": + "2023-07-17T11:58:26.731"}, {"calendarDate": "2023-07-18", "weeklyAvg": 39, + "lastNightAvg": 40, "lastNight5MinHigh": 72, "baseline": {"lowUpper": 36, + "balancedLow": 40, "balancedUpper": 52, "markerValue": 0.22801208}, "status": + "UNBALANCED", "feedbackPhrase": "HRV_UNBALANCED_12", "createTimeStamp": "2023-07-18T13:45:54.638"}, + {"calendarDate": "2023-07-19", "weeklyAvg": 39, "lastNightAvg": 43, "lastNight5MinHigh": + 60, "baseline": {"lowUpper": 36, "balancedLow": 39, "balancedUpper": 52, "markerValue": + 0.25}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_4", "createTimeStamp": + "2023-07-19T14:43:16.394"}, {"calendarDate": "2023-07-20", "weeklyAvg": 39, + "lastNightAvg": 42, "lastNight5MinHigh": 66, "baseline": {"lowUpper": 36, + "balancedLow": 39, "balancedUpper": 52, "markerValue": 0.25}, "status": "BALANCED", + "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": "2023-07-20T12:14:11.898"}], + "userProfilePk": 2591602}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12cffc4ea3b6e1-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:31 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=2qwUnXfm51mWjJY2ho0q0lhgcjKqNZIHMND%2F3pcFJs8BsJFIXzgvLZIVnVro%2Fl1%2BmXxg4txzEdRTUKUbedJs19kiYjjaUqbGOdl%2FA7w3NYWk3hlzD5bzjzJzovpCZi3rG9ckt3TzyQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/daily/2023-06-11/2023-06-22 + response: + body: + string: '{"hrvSummaries": [{"calendarDate": "2023-06-11", "weeklyAvg": 43, "lastNightAvg": + 71, "lastNight5MinHigh": 115, "baseline": {"lowUpper": 35, "balancedLow": + 38, "balancedUpper": 51, "markerValue": 0.44230652}, "status": "BALANCED", + "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": "2023-06-11T14:17:59.319"}, + {"calendarDate": "2023-06-12", "weeklyAvg": 45, "lastNightAvg": 51, "lastNight5MinHigh": + 89, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 51, "markerValue": + 0.5192261}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": + "2023-06-12T12:50:20.861"}, {"calendarDate": "2023-06-13", "weeklyAvg": 45, + "lastNightAvg": 44, "lastNight5MinHigh": 68, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 51, "markerValue": 0.5192261}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": "2023-06-13T13:55:03.624"}, + {"calendarDate": "2023-06-14", "weeklyAvg": 47, "lastNightAvg": 49, "lastNight5MinHigh": + 83, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 51, "markerValue": + 0.59614563}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": + "2023-06-14T13:36:05.184"}, {"calendarDate": "2023-06-15", "weeklyAvg": 46, + "lastNightAvg": 39, "lastNight5MinHigh": 77, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 51, "markerValue": 0.5576782}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": "2023-06-15T11:50:18.949"}, + {"calendarDate": "2023-06-16", "weeklyAvg": 45, "lastNightAvg": 34, "lastNight5MinHigh": + 54, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 51, "markerValue": + 0.5192261}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": + "2023-06-16T12:40:24.953"}, {"calendarDate": "2023-06-17", "weeklyAvg": 46, + "lastNightAvg": 42, "lastNight5MinHigh": 97, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 51, "markerValue": 0.5576782}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_6", "createTimeStamp": "2023-06-17T14:05:55.936"}, + {"calendarDate": "2023-06-18", "weeklyAvg": 42, "lastNightAvg": 39, "lastNight5MinHigh": + 71, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.39285278}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": + "2023-06-18T13:32:40.883"}, {"calendarDate": "2023-06-19", "weeklyAvg": 41, + "lastNightAvg": 40, "lastNight5MinHigh": 66, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.35713196}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_8", "createTimeStamp": "2023-06-19T14:15:45.918"}, + {"calendarDate": "2023-06-20", "weeklyAvg": 41, "lastNightAvg": 45, "lastNight5MinHigh": + 76, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.35713196}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_5", "createTimeStamp": + "2023-06-20T12:57:59.375"}, {"calendarDate": "2023-06-21", "weeklyAvg": 39, + "lastNightAvg": 36, "lastNight5MinHigh": 55, "baseline": {"lowUpper": 35, + "balancedLow": 38, "balancedUpper": 52, "markerValue": 0.28570557}, "status": + "BALANCED", "feedbackPhrase": "HRV_BALANCED_3", "createTimeStamp": "2023-06-21T12:07:13.299"}, + {"calendarDate": "2023-06-22", "weeklyAvg": 39, "lastNightAvg": 40, "lastNight5MinHigh": + 66, "baseline": {"lowUpper": 35, "balancedLow": 38, "balancedUpper": 52, "markerValue": + 0.28570557}, "status": "BALANCED", "feedbackPhrase": "HRV_BALANCED_7", "createTimeStamp": + "2023-06-22T15:07:52.527"}], "userProfilePk": 2591602}' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12cffd58bdb6e1-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:32 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=0NCR775bJt1JRqheSkoCuFTz1b0iStwJxkS5KYP46xKe8WcWO56WI81lN9h62gaiKEiVtpV1Mrlkr4oRqMEm8XwiPMrJ8kF6OFxD8%2F6t%2B7DK0QOI6An3R2EzrBEfW40UaG6qbLitvg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_hrv_paginate_no_results.yaml b/garth/tests/stats/cassettes/test_daily_hrv_paginate_no_results.yaml new file mode 100644 index 0000000..64689ee --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_hrv_paginate_no_results.yaml @@ -0,0 +1,54 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/hrv-service/hrv/daily/1990-06-23/1990-07-20 + response: + body: + string: '' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0009fb71556-QRO + Connection: + - keep-alive + Date: + - Fri, 04 Aug 2023 00:51:32 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=Rtks48zaXzNg0K9c8L5w7UaDVLx4fUwxanI2aMQtUuzIq7%2FEg%2F3tYRlfBLxbkZgQptFoiz3CS%2B8rKHWzqq7ayFvLe0k2kEynQKwSjY5I%2FDlesB7kjUKuXxwh%2B3qW7JMMoW6BK9ybRQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 204 + message: No Content +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_hydration.yaml b/garth/tests/stats/cassettes/test_daily_hydration.yaml new file mode 100644 index 0000000..18b9912 --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_hydration.yaml @@ -0,0 +1,50 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - GCM-iOS-5.7.2.1 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/hydration/daily/2024-06-29/2024-06-29 + response: + body: + string: '[{"calendarDate": "2024-06-29", "valueInML": 1750.0, "goalInML": 2800.0}]' + headers: + CF-RAY: + - 94b18a3ecfb934a7-QRO + Cache-Control: + - no-cache, no-store, private + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Thu, 05 Jun 2025 17:55:17 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v4?s=Fj%2FXgrWJs%2FS1mgUePurhEKyb3GueFKdLEDdkAVqNKT%2ByACTJn5%2Fi%2B2%2FsDOOh95cibWQYcDIAGM40K0XxrSBItFfY5ZW24CwXjHLIg%2FkvAB1JJwMiyAdhLIpXjUfVdyXoQ4tdKQcy0Q%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Set-Cookie: + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cf-cache-status: + - DYNAMIC + pragma: + - no-cache + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_intensity_minutes.yaml b/garth/tests/stats/cassettes/test_daily_intensity_minutes.yaml new file mode 100644 index 0000000..d1f741f --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_intensity_minutes.yaml @@ -0,0 +1,82 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/im/daily/2023-07-01/2023-07-20 + response: + body: + string: '[{"calendarDate": "2023-07-01", "weeklyGoal": 150, "moderateValue": + 0, "vigorousValue": 0}, {"calendarDate": "2023-07-02", "weeklyGoal": 150, + "moderateValue": 55, "vigorousValue": 6}, {"calendarDate": "2023-07-03", "weeklyGoal": + 150, "moderateValue": 13, "vigorousValue": 0}, {"calendarDate": "2023-07-04", + "weeklyGoal": 150, "moderateValue": 9, "vigorousValue": 34}, {"calendarDate": + "2023-07-05", "weeklyGoal": 150, "moderateValue": 23, "vigorousValue": 1}, + {"calendarDate": "2023-07-06", "weeklyGoal": 150, "moderateValue": 0, "vigorousValue": + 0}, {"calendarDate": "2023-07-07", "weeklyGoal": 150, "moderateValue": 88, + "vigorousValue": 8}, {"calendarDate": "2023-07-08", "weeklyGoal": 150, "moderateValue": + 0, "vigorousValue": 0}, {"calendarDate": "2023-07-09", "weeklyGoal": 150, + "moderateValue": 44, "vigorousValue": 5}, {"calendarDate": "2023-07-10", "weeklyGoal": + 150, "moderateValue": 9, "vigorousValue": 0}, {"calendarDate": "2023-07-11", + "weeklyGoal": 150, "moderateValue": 31, "vigorousValue": 23}, {"calendarDate": + "2023-07-12", "weeklyGoal": 150, "moderateValue": 43, "vigorousValue": 3}, + {"calendarDate": "2023-07-13", "weeklyGoal": 150, "moderateValue": 53, "vigorousValue": + 25}, {"calendarDate": "2023-07-14", "weeklyGoal": 150, "moderateValue": 49, + "vigorousValue": 7}, {"calendarDate": "2023-07-15", "weeklyGoal": 150, "moderateValue": + 0, "vigorousValue": 0}, {"calendarDate": "2023-07-16", "weeklyGoal": 150, + "moderateValue": 0, "vigorousValue": 0}, {"calendarDate": "2023-07-17", "weeklyGoal": + 150, "moderateValue": 61, "vigorousValue": 5}, {"calendarDate": "2023-07-18", + "weeklyGoal": 150, "moderateValue": 0, "vigorousValue": 0}, {"calendarDate": + "2023-07-19", "weeklyGoal": 150, "moderateValue": 1, "vigorousValue": 0}, + {"calendarDate": "2023-07-20", "weeklyGoal": 150, "moderateValue": 0, "vigorousValue": + 0}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0031b5247fd-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:33 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=9im50IutY9DBaURoxea2zvLVuniHkDcSgeUppPhyVdmW%2FDSA3THWATEIui7XNQQxyQo08JOtLQ5MRRM1%2F6faiOqzehpRUM3EJ3eDtkXNQwLBUlFZ%2B3ldpbg%2FNfHDN%2BXb3rjJU1YjJg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_sleep.yaml b/garth/tests/stats/cassettes/test_daily_sleep.yaml new file mode 100644 index 0000000..63b996e --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_sleep.yaml @@ -0,0 +1,65 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/wellness-service/stats/daily/sleep/score/2023-07-01/2023-07-20 + response: + body: + string: '[{"calendarDate": "2023-07-01", "value": 60}, {"calendarDate": "2023-07-02", + "value": 70}, {"calendarDate": "2023-07-03", "value": 82}, {"calendarDate": + "2023-07-04", "value": 75}, {"calendarDate": "2023-07-05", "value": 70}, {"calendarDate": + "2023-07-06", "value": 28}, {"calendarDate": "2023-07-07", "value": 79}, {"calendarDate": + "2023-07-08", "value": 70}, {"calendarDate": "2023-07-09", "value": 77}, {"calendarDate": + "2023-07-10", "value": 87}, {"calendarDate": "2023-07-11", "value": 64}, {"calendarDate": + "2023-07-12", "value": 58}, {"calendarDate": "2023-07-13", "value": 71}, {"calendarDate": + "2023-07-14", "value": 80}, {"calendarDate": "2023-07-15", "value": 69}, {"calendarDate": + "2023-07-16", "value": 71}, {"calendarDate": "2023-07-17", "value": 94}, {"calendarDate": + "2023-07-18", "value": 77}, {"calendarDate": "2023-07-19", "value": 80}, {"calendarDate": + "2023-07-20", "value": 68}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d00638244600-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:33 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=RyGEQnxnunkvjbgNO5BmWlIHgK45Gi5ICNxJrWUnFSVIYAOexuuvkkAPYzGQCZKluGJewZGrYLSriEsXOrcOcQ3heU9KlvGhE7UD2gY1xn7AECCOV5wWcGb5WLwgJ8%2FDzFs%2FdL3hGg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_steps.yaml b/garth/tests/stats/cassettes/test_daily_steps.yaml new file mode 100644 index 0000000..71fe581 --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_steps.yaml @@ -0,0 +1,84 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/steps/daily/2023-07-01/2023-07-20 + response: + body: + string: '[{"calendarDate": "2023-07-01", "totalSteps": 12413, "totalDistance": + 10368, "stepGoal": 7950}, {"calendarDate": "2023-07-02", "totalSteps": 5719, + "totalDistance": 5207, "stepGoal": 8400}, {"calendarDate": "2023-07-03", "totalSteps": + 3633, "totalDistance": 3152, "stepGoal": 8140}, {"calendarDate": "2023-07-04", + "totalSteps": 9593, "totalDistance": 8745, "stepGoal": 8140}, {"calendarDate": + "2023-07-05", "totalSteps": 5865, "totalDistance": 5344, "stepGoal": 8290}, + {"calendarDate": "2023-07-06", "totalSteps": 4331, "totalDistance": 3740, + "stepGoal": 8050}, {"calendarDate": "2023-07-07", "totalSteps": 9263, "totalDistance": + 7597, "stepGoal": 7310}, {"calendarDate": "2023-07-08", "totalSteps": 6889, + "totalDistance": 5800, "stepGoal": 7510}, {"calendarDate": "2023-07-09", "totalSteps": + 15403, "totalDistance": 11643, "stepGoal": 7450}, {"calendarDate": "2023-07-10", + "totalSteps": 3409, "totalDistance": 2935, "stepGoal": 8250}, {"calendarDate": + "2023-07-11", "totalSteps": 10746, "totalDistance": 9609, "stepGoal": 8250}, + {"calendarDate": "2023-07-12", "totalSteps": 9849, "totalDistance": 8508, + "stepGoal": 8750}, {"calendarDate": "2023-07-13", "totalSteps": 17556, "totalDistance": + 31572, "stepGoal": 8970}, {"calendarDate": "2023-07-14", "totalSteps": 6919, + "totalDistance": 5527, "stepGoal": 10690}, {"calendarDate": "2023-07-15", + "totalSteps": 10886, "totalDistance": 9048, "stepGoal": 10320}, {"calendarDate": + "2023-07-16", "totalSteps": 3965, "totalDistance": 3442, "stepGoal": 10380}, + {"calendarDate": "2023-07-17", "totalSteps": 6842, "totalDistance": 5439, + "stepGoal": 9740}, {"calendarDate": "2023-07-18", "totalSteps": 3585, "totalDistance": + 3103, "stepGoal": 9160}, {"calendarDate": "2023-07-19", "totalSteps": 3998, + "totalDistance": 3384, "stepGoal": 8050}, {"calendarDate": "2023-07-20", "totalSteps": + 7322, "totalDistance": 6148, "stepGoal": 7240}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0361f51b6ee-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:41 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=bzh%2FUoGEfIajBdQR5MV3QW0RLYZzm5KVdFbwvpMqO9thm%2FwjZKTcc%2FouaGofuuNQmFoGl%2FTksvg%2BtFeTKq3Nt78N%2BaIJVDV3FIetTmEZlwD083NaVOvpEMEwaB80srEQbZuua1khiw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_stress.yaml b/garth/tests/stats/cassettes/test_daily_stress.yaml new file mode 100644 index 0000000..3e971b5 --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_stress.yaml @@ -0,0 +1,107 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/daily/2023-07-01/2023-07-20 + response: + body: + string: '[{"calendarDate": "2023-07-01", "values": {"highStressDuration": 1680, + "lowStressDuration": 21780, "overallStressLevel": 35, "restStressDuration": + 27780, "mediumStressDuration": 12660}}, {"calendarDate": "2023-07-02", "values": + {"highStressDuration": 3600, "lowStressDuration": 11580, "overallStressLevel": + 29, "restStressDuration": 39840, "mediumStressDuration": 7740}}, {"calendarDate": + "2023-07-03", "values": {"highStressDuration": 3060, "lowStressDuration": + 16680, "overallStressLevel": 32, "restStressDuration": 34080, "mediumStressDuration": + 11460}}, {"calendarDate": "2023-07-04", "values": {"highStressDuration": 2640, + "lowStressDuration": 21420, "overallStressLevel": 34, "restStressDuration": + 27600, "mediumStressDuration": 10860}}, {"calendarDate": "2023-07-05", "values": + {"highStressDuration": 2940, "lowStressDuration": 20040, "overallStressLevel": + 37, "restStressDuration": 25200, "mediumStressDuration": 15120}}, {"calendarDate": + "2023-07-06", "values": {"highStressDuration": 6900, "lowStressDuration": + 11400, "overallStressLevel": 49, "restStressDuration": 10440, "mediumStressDuration": + 14520}}, {"calendarDate": "2023-07-07", "values": {"highStressDuration": 3600, + "lowStressDuration": 15600, "overallStressLevel": 33, "restStressDuration": + 29280, "mediumStressDuration": 9000}}, {"calendarDate": "2023-07-08", "values": + {"highStressDuration": 240, "lowStressDuration": 18540, "overallStressLevel": + 27, "restStressDuration": 41340, "mediumStressDuration": 5340}}, {"calendarDate": + "2023-07-09", "values": {"highStressDuration": 3780, "lowStressDuration": + 6600, "overallStressLevel": 27, "restStressDuration": 36420, "mediumStressDuration": + 5820}}, {"calendarDate": "2023-07-10", "values": {"highStressDuration": 2220, + "lowStressDuration": 20880, "overallStressLevel": 31, "restStressDuration": + 39000, "mediumStressDuration": 10080}}, {"calendarDate": "2023-07-11", "values": + {"highStressDuration": 960, "lowStressDuration": 10560, "overallStressLevel": + 26, "restStressDuration": 25380, "mediumStressDuration": 3480}}, {"calendarDate": + "2023-07-12", "values": {"highStressDuration": 2520, "lowStressDuration": + 13560, "overallStressLevel": 38, "restStressDuration": 17940, "mediumStressDuration": + 10920}}, {"calendarDate": "2023-07-13", "values": {"highStressDuration": 2880, + "lowStressDuration": 10140, "overallStressLevel": 33, "restStressDuration": + 30960, "mediumStressDuration": 8760}}, {"calendarDate": "2023-07-14", "values": + {"highStressDuration": 6000, "lowStressDuration": 15660, "overallStressLevel": + 38, "restStressDuration": 27360, "mediumStressDuration": 9480}}, {"calendarDate": + "2023-07-15", "values": {"highStressDuration": 3660, "lowStressDuration": + 18480, "overallStressLevel": 35, "restStressDuration": 26760, "mediumStressDuration": + 8220}}, {"calendarDate": "2023-07-16", "values": {"highStressDuration": 300, + "lowStressDuration": 29280, "overallStressLevel": 30, "restStressDuration": + 34980, "mediumStressDuration": 5760}}, {"calendarDate": "2023-07-17", "values": + {"highStressDuration": 1500, "lowStressDuration": 18780, "overallStressLevel": + 32, "restStressDuration": 27420, "mediumStressDuration": 9300}}, {"calendarDate": + "2023-07-18", "values": {"highStressDuration": 600, "lowStressDuration": 30660, + "overallStressLevel": 31, "restStressDuration": 32820, "mediumStressDuration": + 7260}}, {"calendarDate": "2023-07-19", "values": {"highStressDuration": 3180, + "lowStressDuration": 13680, "overallStressLevel": 34, "restStressDuration": + 32340, "mediumStressDuration": 14100}}, {"calendarDate": "2023-07-20", "values": + {"highStressDuration": 2880, "lowStressDuration": 21780, "overallStressLevel": + 38, "restStressDuration": 26580, "mediumStressDuration": 18240}}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0397ff347ab-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:41 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=T9CAErSSY%2FFeBvVNVWoa%2FYNy0BI%2BhWzwaRSbOHzHpcYcA8u1JRck31Y044IFAjfPbLAdM1LUfY%2Fkt2eOoD4gMvuh%2B9KKGJ0VefqDsQE15iwlyQ%2FlI2YAHnt7eAhdme6nZHe8saWUvQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_daily_stress_pagination.yaml b/garth/tests/stats/cassettes/test_daily_stress_pagination.yaml new file mode 100644 index 0000000..ecdb7df --- /dev/null +++ b/garth/tests/stats/cassettes/test_daily_stress_pagination.yaml @@ -0,0 +1,328 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/daily/2023-06-23/2023-07-20 + response: + body: + string: '[{"calendarDate": "2023-06-23", "values": {"highStressDuration": 9240, + "lowStressDuration": 11280, "overallStressLevel": 43, "restStressDuration": + 25440, "mediumStressDuration": 12000}}, {"calendarDate": "2023-06-24", "values": + {"highStressDuration": 420, "lowStressDuration": 25440, "overallStressLevel": + 31, "restStressDuration": 29640, "mediumStressDuration": 10800}}, {"calendarDate": + "2023-06-25", "values": {"highStressDuration": 180, "lowStressDuration": 27660, + "overallStressLevel": 25, "restStressDuration": 36720, "mediumStressDuration": + 2160}}, {"calendarDate": "2023-06-26", "values": {"highStressDuration": 6420, + "lowStressDuration": 11580, "overallStressLevel": 38, "restStressDuration": + 27840, "mediumStressDuration": 16140}}, {"calendarDate": "2023-06-27", "values": + {"highStressDuration": 1260, "lowStressDuration": 23100, "overallStressLevel": + 31, "restStressDuration": 35100, "mediumStressDuration": 8520}}, {"calendarDate": + "2023-06-28", "values": {"highStressDuration": 780, "lowStressDuration": 18360, + "overallStressLevel": 28, "restStressDuration": 37800, "mediumStressDuration": + 8760}}, {"calendarDate": "2023-06-29", "values": {"highStressDuration": 3660, + "lowStressDuration": 14760, "overallStressLevel": 33, "restStressDuration": + 27420, "mediumStressDuration": 10200}}, {"calendarDate": "2023-06-30", "values": + {"highStressDuration": 10260, "lowStressDuration": 11400, "overallStressLevel": + 45, "restStressDuration": 22980, "mediumStressDuration": 15900}}, {"calendarDate": + "2023-07-01", "values": {"highStressDuration": 1680, "lowStressDuration": + 21780, "overallStressLevel": 35, "restStressDuration": 27780, "mediumStressDuration": + 12660}}, {"calendarDate": "2023-07-02", "values": {"highStressDuration": 3600, + "lowStressDuration": 11580, "overallStressLevel": 29, "restStressDuration": + 39840, "mediumStressDuration": 7740}}, {"calendarDate": "2023-07-03", "values": + {"highStressDuration": 3060, "lowStressDuration": 16680, "overallStressLevel": + 32, "restStressDuration": 34080, "mediumStressDuration": 11460}}, {"calendarDate": + "2023-07-04", "values": {"highStressDuration": 2640, "lowStressDuration": + 21420, "overallStressLevel": 34, "restStressDuration": 27600, "mediumStressDuration": + 10860}}, {"calendarDate": "2023-07-05", "values": {"highStressDuration": 2940, + "lowStressDuration": 20040, "overallStressLevel": 37, "restStressDuration": + 25200, "mediumStressDuration": 15120}}, {"calendarDate": "2023-07-06", "values": + {"highStressDuration": 6900, "lowStressDuration": 11400, "overallStressLevel": + 49, "restStressDuration": 10440, "mediumStressDuration": 14520}}, {"calendarDate": + "2023-07-07", "values": {"highStressDuration": 3600, "lowStressDuration": + 15600, "overallStressLevel": 33, "restStressDuration": 29280, "mediumStressDuration": + 9000}}, {"calendarDate": "2023-07-08", "values": {"highStressDuration": 240, + "lowStressDuration": 18540, "overallStressLevel": 27, "restStressDuration": + 41340, "mediumStressDuration": 5340}}, {"calendarDate": "2023-07-09", "values": + {"highStressDuration": 3780, "lowStressDuration": 6600, "overallStressLevel": + 27, "restStressDuration": 36420, "mediumStressDuration": 5820}}, {"calendarDate": + "2023-07-10", "values": {"highStressDuration": 2220, "lowStressDuration": + 20880, "overallStressLevel": 31, "restStressDuration": 39000, "mediumStressDuration": + 10080}}, {"calendarDate": "2023-07-11", "values": {"highStressDuration": 960, + "lowStressDuration": 10560, "overallStressLevel": 26, "restStressDuration": + 25380, "mediumStressDuration": 3480}}, {"calendarDate": "2023-07-12", "values": + {"highStressDuration": 2520, "lowStressDuration": 13560, "overallStressLevel": + 38, "restStressDuration": 17940, "mediumStressDuration": 10920}}, {"calendarDate": + "2023-07-13", "values": {"highStressDuration": 2880, "lowStressDuration": + 10140, "overallStressLevel": 33, "restStressDuration": 30960, "mediumStressDuration": + 8760}}, {"calendarDate": "2023-07-14", "values": {"highStressDuration": 6000, + "lowStressDuration": 15660, "overallStressLevel": 38, "restStressDuration": + 27360, "mediumStressDuration": 9480}}, {"calendarDate": "2023-07-15", "values": + {"highStressDuration": 3660, "lowStressDuration": 18480, "overallStressLevel": + 35, "restStressDuration": 26760, "mediumStressDuration": 8220}}, {"calendarDate": + "2023-07-16", "values": {"highStressDuration": 300, "lowStressDuration": 29280, + "overallStressLevel": 30, "restStressDuration": 34980, "mediumStressDuration": + 5760}}, {"calendarDate": "2023-07-17", "values": {"highStressDuration": 1500, + "lowStressDuration": 18780, "overallStressLevel": 32, "restStressDuration": + 27420, "mediumStressDuration": 9300}}, {"calendarDate": "2023-07-18", "values": + {"highStressDuration": 600, "lowStressDuration": 30660, "overallStressLevel": + 31, "restStressDuration": 32820, "mediumStressDuration": 7260}}, {"calendarDate": + "2023-07-19", "values": {"highStressDuration": 3180, "lowStressDuration": + 13680, "overallStressLevel": 34, "restStressDuration": 32340, "mediumStressDuration": + 14100}}, {"calendarDate": "2023-07-20", "values": {"highStressDuration": 2880, + "lowStressDuration": 21780, "overallStressLevel": 38, "restStressDuration": + 26580, "mediumStressDuration": 18240}}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d03b8f8e486a-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:42 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=BERTpEHuqB%2BDZLiqEhGk77xxsyqjMxPXrvRbfc2BElLQto%2FDk%2BsTuC%2BFsFZcCfNcogMQohkfFoC034IZwevw%2FJ6v9FuqVZ48RSC7FyzcUoSRTu24U3yR2dX5Pl49uMLKe1cQHM%2B8Zw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/daily/2023-05-26/2023-06-22 + response: + body: + string: '[{"calendarDate": "2023-05-26", "values": {"highStressDuration": 1740, + "lowStressDuration": 21240, "overallStressLevel": 31, "restStressDuration": + 34980, "mediumStressDuration": 9120}}, {"calendarDate": "2023-05-27", "values": + {"highStressDuration": 7020, "lowStressDuration": 9360, "overallStressLevel": + 37, "restStressDuration": 26460, "mediumStressDuration": 8640}}, {"calendarDate": + "2023-05-28", "values": {"highStressDuration": null, "lowStressDuration": + 12780, "overallStressLevel": 21, "restStressDuration": 56220, "mediumStressDuration": + 180}}, {"calendarDate": "2023-05-29", "values": {"highStressDuration": 540, + "lowStressDuration": 21300, "overallStressLevel": 27, "restStressDuration": + 50520, "mediumStressDuration": 5280}}, {"calendarDate": "2023-05-30", "values": + {"highStressDuration": 180, "lowStressDuration": 24360, "overallStressLevel": + 27, "restStressDuration": 39840, "mediumStressDuration": 5340}}, {"calendarDate": + "2023-05-31", "values": {"highStressDuration": 5100, "lowStressDuration": + 12060, "overallStressLevel": 32, "restStressDuration": 36180, "mediumStressDuration": + 5400}}, {"calendarDate": "2023-06-01", "values": {"highStressDuration": 2640, + "lowStressDuration": 18840, "overallStressLevel": 31, "restStressDuration": + 37320, "mediumStressDuration": 9900}}, {"calendarDate": "2023-06-02", "values": + {"highStressDuration": 1500, "lowStressDuration": 9960, "overallStressLevel": + 23, "restStressDuration": 39900, "mediumStressDuration": 2760}}, {"calendarDate": + "2023-06-03", "values": {"highStressDuration": 2160, "lowStressDuration": + 15480, "overallStressLevel": 30, "restStressDuration": 26460, "mediumStressDuration": + 4620}}, {"calendarDate": "2023-06-04", "values": {"highStressDuration": 480, + "lowStressDuration": 10020, "overallStressLevel": 22, "restStressDuration": + 49560, "mediumStressDuration": 1620}}, {"calendarDate": "2023-06-05", "values": + {"highStressDuration": 1440, "lowStressDuration": 8160, "overallStressLevel": + 23, "restStressDuration": 50520, "mediumStressDuration": 2880}}, {"calendarDate": + "2023-06-06", "values": {"highStressDuration": 1620, "lowStressDuration": + 15540, "overallStressLevel": 25, "restStressDuration": 45360, "mediumStressDuration": + 4680}}, {"calendarDate": "2023-06-07", "values": {"highStressDuration": 1560, + "lowStressDuration": 13740, "overallStressLevel": 25, "restStressDuration": + 43740, "mediumStressDuration": 3900}}, {"calendarDate": "2023-06-08", "values": + {"highStressDuration": 360, "lowStressDuration": 10320, "overallStressLevel": + 22, "restStressDuration": 37800, "mediumStressDuration": 4440}}, {"calendarDate": + "2023-06-09", "values": {"highStressDuration": 2100, "lowStressDuration": + 19080, "overallStressLevel": 30, "restStressDuration": 39360, "mediumStressDuration": + 7740}}, {"calendarDate": "2023-06-10", "values": {"highStressDuration": null, + "lowStressDuration": 12120, "overallStressLevel": 20, "restStressDuration": + 51660, "mediumStressDuration": 1260}}, {"calendarDate": "2023-06-11", "values": + {"highStressDuration": 1140, "lowStressDuration": 12780, "overallStressLevel": + 20, "restStressDuration": 44100, "mediumStressDuration": 5040}}, {"calendarDate": + "2023-06-12", "values": {"highStressDuration": 2520, "lowStressDuration": + 18300, "overallStressLevel": 30, "restStressDuration": 38820, "mediumStressDuration": + 10920}}, {"calendarDate": "2023-06-13", "values": {"highStressDuration": 720, + "lowStressDuration": 15780, "overallStressLevel": 26, "restStressDuration": + 42780, "mediumStressDuration": 7080}}, {"calendarDate": "2023-06-14", "values": + {"highStressDuration": 4440, "lowStressDuration": 17700, "overallStressLevel": + 38, "restStressDuration": 27660, "mediumStressDuration": 18600}}, {"calendarDate": + "2023-06-15", "values": {"highStressDuration": 900, "lowStressDuration": 25500, + "overallStressLevel": 33, "restStressDuration": 27780, "mediumStressDuration": + 10440}}, {"calendarDate": "2023-06-16", "values": {"highStressDuration": 3540, + "lowStressDuration": 16860, "overallStressLevel": 31, "restStressDuration": + 41280, "mediumStressDuration": 6780}}, {"calendarDate": "2023-06-17", "values": + {"highStressDuration": 1860, "lowStressDuration": 16140, "overallStressLevel": + 33, "restStressDuration": 35640, "mediumStressDuration": 14700}}, {"calendarDate": + "2023-06-18", "values": {"highStressDuration": 300, "lowStressDuration": 25200, + "overallStressLevel": 29, "restStressDuration": 40020, "mediumStressDuration": + 7620}}, {"calendarDate": "2023-06-19", "values": {"highStressDuration": 6540, + "lowStressDuration": 14640, "overallStressLevel": 33, "restStressDuration": + 32700, "mediumStressDuration": 6780}}, {"calendarDate": "2023-06-20", "values": + {"highStressDuration": 7620, "lowStressDuration": 12360, "overallStressLevel": + 38, "restStressDuration": 24660, "mediumStressDuration": 8400}}, {"calendarDate": + "2023-06-21", "values": {"highStressDuration": 4320, "lowStressDuration": + 22800, "overallStressLevel": 37, "restStressDuration": 25560, "mediumStressDuration": + 10260}}, {"calendarDate": "2023-06-22", "values": {"highStressDuration": 7980, + "lowStressDuration": 9780, "overallStressLevel": 38, "restStressDuration": + 31320, "mediumStressDuration": 9060}}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d03d8e964602-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:42 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=QBphPm99T4N17cU9pbYKHd%2F%2BMXM7nwVEAbMOB4nD6j8Xv3e6LJvtq3FRYMbI57vtXLtKQWS7%2Ba37G1TyRPbCpbId1T1zPYKLsHvjIHLd4raCjlJ4%2B2sMQC7E3X5opXM%2BIB%2Fgx0FASg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/daily/2023-05-22/2023-05-25 + response: + body: + string: '[{"calendarDate": "2023-05-22", "values": {"highStressDuration": 900, + "lowStressDuration": 8880, "overallStressLevel": 21, "restStressDuration": + 38820, "mediumStressDuration": 2520}}, {"calendarDate": "2023-05-23", "values": + {"highStressDuration": 3180, "lowStressDuration": 16500, "overallStressLevel": + 28, "restStressDuration": 35880, "mediumStressDuration": 5520}}, {"calendarDate": + "2023-05-24", "values": {"highStressDuration": 3060, "lowStressDuration": + 15660, "overallStressLevel": 32, "restStressDuration": 37740, "mediumStressDuration": + 10440}}, {"calendarDate": "2023-05-25", "values": {"highStressDuration": 1740, + "lowStressDuration": 12000, "overallStressLevel": 27, "restStressDuration": + 37140, "mediumStressDuration": 4200}}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d03ecf18b6e8-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:42 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=GFvmMbPz3eT7acfhWlyOtjmmkXfG1ZYIF2lJFhEV2xbWSfeeqzCL2WEBHWpADXUSaxE%2F1HpDGCQX%2FJWb2w4jYJ4QkFHvjLH3jHdabz6VnGLBlTYjlEcpsFo%2FsrDbdtw6zkI1TgXVzQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_weekly_intensity_minutes.yaml b/garth/tests/stats/cassettes/test_weekly_intensity_minutes.yaml new file mode 100644 index 0000000..9d3ee95 --- /dev/null +++ b/garth/tests/stats/cassettes/test_weekly_intensity_minutes.yaml @@ -0,0 +1,75 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/im/weekly/2023-05-04/2023-07-20 + response: + body: + string: '[{"calendarDate": "2023-05-01", "weeklyGoal": 150, "moderateValue": + 79, "vigorousValue": 172}, {"calendarDate": "2023-05-08", "weeklyGoal": 150, + "moderateValue": 94, "vigorousValue": 206}, {"calendarDate": "2023-05-15", + "weeklyGoal": 150, "moderateValue": 86, "vigorousValue": 120}, {"calendarDate": + "2023-05-22", "weeklyGoal": 150, "moderateValue": 99, "vigorousValue": 190}, + {"calendarDate": "2023-05-29", "weeklyGoal": 150, "moderateValue": 94, "vigorousValue": + 221}, {"calendarDate": "2023-06-05", "weeklyGoal": 150, "moderateValue": 195, + "vigorousValue": 103}, {"calendarDate": "2023-06-12", "weeklyGoal": 150, "moderateValue": + 40, "vigorousValue": 73}, {"calendarDate": "2023-06-19", "weeklyGoal": 150, + "moderateValue": 216, "vigorousValue": 70}, {"calendarDate": "2023-06-26", + "weeklyGoal": 150, "moderateValue": 158, "vigorousValue": 77}, {"calendarDate": + "2023-07-03", "weeklyGoal": 150, "moderateValue": 177, "vigorousValue": 48}, + {"calendarDate": "2023-07-10", "weeklyGoal": 150, "moderateValue": 185, "vigorousValue": + 58}, {"calendarDate": "2023-07-17", "weeklyGoal": 150, "moderateValue": 103, + "vigorousValue": 9}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0043855b6e5-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:33 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=%2Fd8SWt8jTX1j%2ByBa8lT%2FhYdFgj%2FLL%2Fh%2FHF%2BAAv9naauecx6nX7D0atI97wTq0Te%2FxapUS9%2FsMCkQcHZqXXfkxIlB1RCC5DO4GQjIklHkn%2Bezz4%2FRNqjC0vsX7l7Is8wrpoJDoR9gug%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_weekly_steps.yaml b/garth/tests/stats/cassettes/test_weekly_steps.yaml new file mode 100644 index 0000000..44900c1 --- /dev/null +++ b/garth/tests/stats/cassettes/test_weekly_steps.yaml @@ -0,0 +1,180 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/steps/weekly/2023-07-20/52 + response: + body: + string: '[{"calendarDate": "2022-07-22", "values": {"totalSteps": 55744.0, "averageSteps": + 7963.428571428572, "wellnessDataDaysCount": 7, "averageDistance": 7138.571428571428, + "totalDistance": 49970.0}}, {"calendarDate": "2022-07-29", "values": {"totalSteps": + 94875.0, "averageSteps": 13553.57142857143, "wellnessDataDaysCount": 7, "averageDistance": + 12255.42857142857, "totalDistance": 85788.0}}, {"calendarDate": "2022-08-05", + "values": {"totalSteps": 96469.0, "averageSteps": 13781.285714285714, "wellnessDataDaysCount": + 7, "averageDistance": 12684.285714285714, "totalDistance": 88790.0}}, {"calendarDate": + "2022-08-12", "values": {"totalSteps": 101740.0, "averageSteps": 14534.285714285714, + "wellnessDataDaysCount": 7, "averageDistance": 12921.42857142857, "totalDistance": + 90450.0}}, {"calendarDate": "2022-08-19", "values": {"totalSteps": 94178.0, + "averageSteps": 13454.0, "wellnessDataDaysCount": 7, "averageDistance": 12366.857142857143, + "totalDistance": 86568.0}}, {"calendarDate": "2022-08-26", "values": {"totalSteps": + 73373.0, "averageSteps": 10481.857142857143, "wellnessDataDaysCount": 7, "averageDistance": + 9067.57142857143, "totalDistance": 63473.0}}, {"calendarDate": "2022-09-02", + "values": {"totalSteps": 90386.0, "averageSteps": 12912.285714285714, "wellnessDataDaysCount": + 7, "averageDistance": 12175.42857142857, "totalDistance": 85228.0}}, {"calendarDate": + "2022-09-09", "values": {"totalSteps": 76107.0, "averageSteps": 10872.42857142857, + "wellnessDataDaysCount": 7, "averageDistance": 9251.142857142857, "totalDistance": + 64758.0}}, {"calendarDate": "2022-09-16", "values": {"totalSteps": 96712.0, + "averageSteps": 13816.0, "wellnessDataDaysCount": 7, "averageDistance": 12459.57142857143, + "totalDistance": 87217.0}}, {"calendarDate": "2022-09-23", "values": {"totalSteps": + 104410.0, "averageSteps": 14915.714285714286, "wellnessDataDaysCount": 7, + "averageDistance": 13487.0, "totalDistance": 94409.0}}, {"calendarDate": "2022-09-30", + "values": {"totalSteps": 124758.0, "averageSteps": 17822.571428571428, "wellnessDataDaysCount": + 7, "averageDistance": 16172.285714285714, "totalDistance": 113206.0}}, {"calendarDate": + "2022-10-07", "values": {"totalSteps": 78949.0, "averageSteps": 11278.42857142857, + "wellnessDataDaysCount": 7, "averageDistance": 9671.42857142857, "totalDistance": + 67700.0}}, {"calendarDate": "2022-10-14", "values": {"totalSteps": 95605.0, + "averageSteps": 13657.857142857143, "wellnessDataDaysCount": 7, "averageDistance": + 12018.142857142857, "totalDistance": 84127.0}}, {"calendarDate": "2022-10-21", + "values": {"totalSteps": 106901.0, "averageSteps": 15271.57142857143, "wellnessDataDaysCount": + 7, "averageDistance": 12944.857142857143, "totalDistance": 90614.0}}, {"calendarDate": + "2022-10-28", "values": {"totalSteps": 113999.0, "averageSteps": 16285.57142857143, + "wellnessDataDaysCount": 7, "averageDistance": 13413.57142857143, "totalDistance": + 93895.0}}, {"calendarDate": "2022-11-04", "values": {"totalSteps": 62749.0, + "averageSteps": 8964.142857142857, "wellnessDataDaysCount": 7, "averageDistance": + 7447.0, "totalDistance": 52129.0}}, {"calendarDate": "2022-11-11", "values": + {"totalSteps": 74023.0, "averageSteps": 10574.714285714286, "wellnessDataDaysCount": + 7, "averageDistance": 9399.42857142857, "totalDistance": 65796.0}}, {"calendarDate": + "2022-11-18", "values": {"totalSteps": 89319.0, "averageSteps": 12759.857142857143, + "wellnessDataDaysCount": 7, "averageDistance": 10888.142857142857, "totalDistance": + 76217.0}}, {"calendarDate": "2022-11-25", "values": {"totalSteps": 93055.0, + "averageSteps": 13293.57142857143, "wellnessDataDaysCount": 7, "averageDistance": + 11539.57142857143, "totalDistance": 80777.0}}, {"calendarDate": "2022-12-02", + "values": {"totalSteps": 89611.0, "averageSteps": 12801.57142857143, "wellnessDataDaysCount": + 7, "averageDistance": 11499.142857142857, "totalDistance": 80494.0}}, {"calendarDate": + "2022-12-09", "values": {"totalSteps": 92294.0, "averageSteps": 13184.857142857143, + "wellnessDataDaysCount": 7, "averageDistance": 11573.57142857143, "totalDistance": + 81015.0}}, {"calendarDate": "2022-12-16", "values": {"totalSteps": 56511.0, + "averageSteps": 8073.0, "wellnessDataDaysCount": 7, "averageDistance": 7093.285714285715, + "totalDistance": 49653.0}}, {"calendarDate": "2022-12-23", "values": {"totalSteps": + 61345.0, "averageSteps": 8763.57142857143, "wellnessDataDaysCount": 7, "averageDistance": + 7951.142857142857, "totalDistance": 55658.0}}, {"calendarDate": "2022-12-30", + "values": {"totalSteps": 57291.0, "averageSteps": 8184.428571428572, "wellnessDataDaysCount": + 7, "averageDistance": 7035.285714285715, "totalDistance": 49247.0}}, {"calendarDate": + "2023-01-06", "values": {"totalSteps": 90689.0, "averageSteps": 12955.57142857143, + "wellnessDataDaysCount": 7, "averageDistance": 11743.714285714286, "totalDistance": + 82206.0}}, {"calendarDate": "2023-01-13", "values": {"totalSteps": 74267.0, + "averageSteps": 10609.57142857143, "wellnessDataDaysCount": 7, "averageDistance": + 9200.57142857143, "totalDistance": 64404.0}}, {"calendarDate": "2023-01-20", + "values": {"totalSteps": 76068.0, "averageSteps": 10866.857142857143, "wellnessDataDaysCount": + 7, "averageDistance": 9655.0, "totalDistance": 67585.0}}, {"calendarDate": + "2023-01-27", "values": {"totalSteps": 111426.0, "averageSteps": 15918.0, + "wellnessDataDaysCount": 7, "averageDistance": 14085.57142857143, "totalDistance": + 98599.0}}, {"calendarDate": "2023-02-03", "values": {"totalSteps": 82907.0, + "averageSteps": 11843.857142857143, "wellnessDataDaysCount": 7, "averageDistance": + 10047.0, "totalDistance": 70329.0}}, {"calendarDate": "2023-02-10", "values": + {"totalSteps": 102936.0, "averageSteps": 14705.142857142857, "wellnessDataDaysCount": + 7, "averageDistance": 16319.0, "totalDistance": 114233.0}}, {"calendarDate": + "2023-02-17", "values": {"totalSteps": 105100.0, "averageSteps": 15014.285714285714, + "wellnessDataDaysCount": 7, "averageDistance": 13199.42857142857, "totalDistance": + 92396.0}}, {"calendarDate": "2023-02-24", "values": {"totalSteps": 50555.0, + "averageSteps": 7222.142857142857, "wellnessDataDaysCount": 7, "averageDistance": + 6147.714285714285, "totalDistance": 43034.0}}, {"calendarDate": "2023-03-03", + "values": {"totalSteps": 39897.0, "averageSteps": 5699.571428571428, "wellnessDataDaysCount": + 7, "averageDistance": 4749.142857142857, "totalDistance": 33244.0}}, {"calendarDate": + "2023-03-10", "values": {"totalSteps": 38956.0, "averageSteps": 5565.142857142857, + "wellnessDataDaysCount": 7, "averageDistance": 4789.142857142857, "totalDistance": + 33524.0}}, {"calendarDate": "2023-03-17", "values": {"totalSteps": 67507.0, + "averageSteps": 9643.857142857143, "wellnessDataDaysCount": 7, "averageDistance": + 7943.285714285715, "totalDistance": 55603.0}}, {"calendarDate": "2023-03-24", + "values": {"totalSteps": 69336.0, "averageSteps": 9905.142857142857, "wellnessDataDaysCount": + 7, "averageDistance": 8405.42857142857, "totalDistance": 58838.0}}, {"calendarDate": + "2023-03-31", "values": {"totalSteps": 78022.0, "averageSteps": 11146.0, "wellnessDataDaysCount": + 7, "averageDistance": 9539.42857142857, "totalDistance": 66776.0}}, {"calendarDate": + "2023-04-07", "values": {"totalSteps": 99009.0, "averageSteps": 14144.142857142857, + "wellnessDataDaysCount": 7, "averageDistance": 12221.285714285714, "totalDistance": + 85549.0}}, {"calendarDate": "2023-04-14", "values": {"totalSteps": 80389.0, + "averageSteps": 11484.142857142857, "wellnessDataDaysCount": 7, "averageDistance": + 9664.142857142857, "totalDistance": 67649.0}}, {"calendarDate": "2023-04-21", + "values": {"totalSteps": 65577.0, "averageSteps": 9368.142857142857, "wellnessDataDaysCount": + 7, "averageDistance": 7924.142857142857, "totalDistance": 55469.0}}, {"calendarDate": + "2023-04-28", "values": {"totalSteps": 123412.0, "averageSteps": 17630.285714285714, + "wellnessDataDaysCount": 7, "averageDistance": 15070.57142857143, "totalDistance": + 105494.0}}, {"calendarDate": "2023-05-05", "values": {"totalSteps": 86922.0, + "averageSteps": 12417.42857142857, "wellnessDataDaysCount": 7, "averageDistance": + 10949.857142857143, "totalDistance": 76649.0}}, {"calendarDate": "2023-05-12", + "values": {"totalSteps": 91695.0, "averageSteps": 13099.285714285714, "wellnessDataDaysCount": + 7, "averageDistance": 12020.714285714286, "totalDistance": 84145.0}}, {"calendarDate": + "2023-05-19", "values": {"totalSteps": 85574.0, "averageSteps": 12224.857142857143, + "wellnessDataDaysCount": 7, "averageDistance": 10725.857142857143, "totalDistance": + 75081.0}}, {"calendarDate": "2023-05-26", "values": {"totalSteps": 67963.0, + "averageSteps": 9709.0, "wellnessDataDaysCount": 7, "averageDistance": 8510.57142857143, + "totalDistance": 59574.0}}, {"calendarDate": "2023-06-02", "values": {"totalSteps": + 93534.0, "averageSteps": 13362.0, "wellnessDataDaysCount": 7, "averageDistance": + 11683.42857142857, "totalDistance": 81784.0}}, {"calendarDate": "2023-06-09", + "values": {"totalSteps": 67701.0, "averageSteps": 9671.57142857143, "wellnessDataDaysCount": + 7, "averageDistance": 8122.714285714285, "totalDistance": 56859.0}}, {"calendarDate": + "2023-06-16", "values": {"totalSteps": 52219.0, "averageSteps": 7459.857142857143, + "wellnessDataDaysCount": 7, "averageDistance": 6380.571428571428, "totalDistance": + 44664.0}}, {"calendarDate": "2023-06-23", "values": {"totalSteps": 52441.0, + "averageSteps": 7491.571428571428, "wellnessDataDaysCount": 7, "averageDistance": + 6437.428571428572, "totalDistance": 45062.0}}, {"calendarDate": "2023-06-30", + "values": {"totalSteps": 49029.0, "averageSteps": 7004.142857142857, "wellnessDataDaysCount": + 7, "averageDistance": 6117.285714285715, "totalDistance": 42821.0}}, {"calendarDate": + "2023-07-07", "values": {"totalSteps": 73115.0, "averageSteps": 10445.0, "wellnessDataDaysCount": + 7, "averageDistance": 11094.857142857143, "totalDistance": 77664.0}}, {"calendarDate": + "2023-07-14", "values": {"totalSteps": 43517.0, "averageSteps": 6216.714285714285, + "wellnessDataDaysCount": 7, "averageDistance": 5155.857142857143, "totalDistance": + 36091.0}}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0372c6bb6e8-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:41 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=%2Bl0XlZIluxXu3lx%2F%2Fvhv0VqJ4KvnGO6IAsrscPL0HZHlylqX0y1KAU6diNA2mkaRA%2F20r75szglAnaZoHg8BB36YlL9OY46kV5b7J3%2BPf%2BhJrMp4E1NBhVysMDNWMSomy15E0rLf3w%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_weekly_stress.yaml b/garth/tests/stats/cassettes/test_weekly_stress.yaml new file mode 100644 index 0000000..5529d14 --- /dev/null +++ b/garth/tests/stats/cassettes/test_weekly_stress.yaml @@ -0,0 +1,87 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/weekly/2023-07-20/52 + response: + body: + string: '[{"calendarDate": "2022-07-22", "value": 25}, {"calendarDate": "2022-07-29", + "value": 26}, {"calendarDate": "2022-08-05", "value": 27}, {"calendarDate": + "2022-08-12", "value": 29}, {"calendarDate": "2022-08-19", "value": 28}, {"calendarDate": + "2022-08-26", "value": 25}, {"calendarDate": "2022-09-02", "value": 27}, {"calendarDate": + "2022-09-09", "value": 23}, {"calendarDate": "2022-09-16", "value": 30}, {"calendarDate": + "2022-09-23", "value": 25}, {"calendarDate": "2022-09-30", "value": 23}, {"calendarDate": + "2022-10-07", "value": 22}, {"calendarDate": "2022-10-14", "value": 26}, {"calendarDate": + "2022-10-21", "value": 29}, {"calendarDate": "2022-10-28", "value": 25}, {"calendarDate": + "2022-11-04", "value": 29}, {"calendarDate": "2022-11-11", "value": 31}, {"calendarDate": + "2022-11-18", "value": 26}, {"calendarDate": "2022-11-25", "value": 26}, {"calendarDate": + "2022-12-02", "value": 27}, {"calendarDate": "2022-12-09", "value": 25}, {"calendarDate": + "2022-12-16", "value": 27}, {"calendarDate": "2022-12-23", "value": 30}, {"calendarDate": + "2022-12-30", "value": 30}, {"calendarDate": "2023-01-06", "value": 31}, {"calendarDate": + "2023-01-13", "value": 30}, {"calendarDate": "2023-01-20", "value": 31}, {"calendarDate": + "2023-01-27", "value": 26}, {"calendarDate": "2023-02-03", "value": 26}, {"calendarDate": + "2023-02-10", "value": 29}, {"calendarDate": "2023-02-17", "value": 25}, {"calendarDate": + "2023-02-24", "value": 23}, {"calendarDate": "2023-03-03", "value": 24}, {"calendarDate": + "2023-03-10", "value": 27}, {"calendarDate": "2023-03-17", "value": 35}, {"calendarDate": + "2023-03-24", "value": 35}, {"calendarDate": "2023-03-31", "value": 31}, {"calendarDate": + "2023-04-07", "value": 30}, {"calendarDate": "2023-04-14", "value": 27}, {"calendarDate": + "2023-04-21", "value": 27}, {"calendarDate": "2023-04-28", "value": 30}, {"calendarDate": + "2023-05-05", "value": 29}, {"calendarDate": "2023-05-12", "value": 28}, {"calendarDate": + "2023-05-19", "value": 26}, {"calendarDate": "2023-05-26", "value": 29}, {"calendarDate": + "2023-06-02", "value": 24}, {"calendarDate": "2023-06-09", "value": 28}, {"calendarDate": + "2023-06-16", "value": 34}, {"calendarDate": "2023-06-23", "value": 32}, {"calendarDate": + "2023-06-30", "value": 37}, {"calendarDate": "2023-07-07", "value": 30}, {"calendarDate": + "2023-07-14", "value": 34}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d03ffc58b6eb-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:42 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=c%2Bq23QlhxezPwKLyUBjr6tmWN4AZf%2BwdBFpeaH%2B8ptr8Chz1U7tVP0yr5Iwd3AWLlLKb4%2FU%2FZt9as1Beq5oi7qmkfbZVxerJpLZT5Lgj1AbocbMEZKJMkIuI4iH3JjXtNbisFpZ15A%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_weekly_stress_beyond_data.yaml b/garth/tests/stats/cassettes/test_weekly_stress_beyond_data.yaml new file mode 100644 index 0000000..8e7ff95 --- /dev/null +++ b/garth/tests/stats/cassettes/test_weekly_stress_beyond_data.yaml @@ -0,0 +1,323 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/weekly/2023-07-20/52 + response: + body: + string: '[{"calendarDate": "2022-07-22", "value": 25}, {"calendarDate": "2022-07-29", + "value": 26}, {"calendarDate": "2022-08-05", "value": 27}, {"calendarDate": + "2022-08-12", "value": 29}, {"calendarDate": "2022-08-19", "value": 28}, {"calendarDate": + "2022-08-26", "value": 25}, {"calendarDate": "2022-09-02", "value": 27}, {"calendarDate": + "2022-09-09", "value": 23}, {"calendarDate": "2022-09-16", "value": 30}, {"calendarDate": + "2022-09-23", "value": 25}, {"calendarDate": "2022-09-30", "value": 23}, {"calendarDate": + "2022-10-07", "value": 22}, {"calendarDate": "2022-10-14", "value": 26}, {"calendarDate": + "2022-10-21", "value": 29}, {"calendarDate": "2022-10-28", "value": 25}, {"calendarDate": + "2022-11-04", "value": 29}, {"calendarDate": "2022-11-11", "value": 31}, {"calendarDate": + "2022-11-18", "value": 26}, {"calendarDate": "2022-11-25", "value": 26}, {"calendarDate": + "2022-12-02", "value": 27}, {"calendarDate": "2022-12-09", "value": 25}, {"calendarDate": + "2022-12-16", "value": 27}, {"calendarDate": "2022-12-23", "value": 30}, {"calendarDate": + "2022-12-30", "value": 30}, {"calendarDate": "2023-01-06", "value": 31}, {"calendarDate": + "2023-01-13", "value": 30}, {"calendarDate": "2023-01-20", "value": 31}, {"calendarDate": + "2023-01-27", "value": 26}, {"calendarDate": "2023-02-03", "value": 26}, {"calendarDate": + "2023-02-10", "value": 29}, {"calendarDate": "2023-02-17", "value": 25}, {"calendarDate": + "2023-02-24", "value": 23}, {"calendarDate": "2023-03-03", "value": 24}, {"calendarDate": + "2023-03-10", "value": 27}, {"calendarDate": "2023-03-17", "value": 35}, {"calendarDate": + "2023-03-24", "value": 35}, {"calendarDate": "2023-03-31", "value": 31}, {"calendarDate": + "2023-04-07", "value": 30}, {"calendarDate": "2023-04-14", "value": 27}, {"calendarDate": + "2023-04-21", "value": 27}, {"calendarDate": "2023-04-28", "value": 30}, {"calendarDate": + "2023-05-05", "value": 29}, {"calendarDate": "2023-05-12", "value": 28}, {"calendarDate": + "2023-05-19", "value": 26}, {"calendarDate": "2023-05-26", "value": 29}, {"calendarDate": + "2023-06-02", "value": 24}, {"calendarDate": "2023-06-09", "value": 28}, {"calendarDate": + "2023-06-16", "value": 34}, {"calendarDate": "2023-06-23", "value": 32}, {"calendarDate": + "2023-06-30", "value": 37}, {"calendarDate": "2023-07-07", "value": 30}, {"calendarDate": + "2023-07-14", "value": 34}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0453bdcb6ee-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:43 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=%2Fj7%2FvJ22rfZra5GhmEE5pmlC5Uc5K7RATmiYeptCVaJa1E61Q0f%2BTBQPro8xMN0YITaOvrYVpSdUUbRy7hrfwnTy%2F2zxGhQtGCXOJFwDQahKMB9ZM%2FVdAwbk6%2FzMi7kxx%2BZRJXTUSg%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/weekly/2022-07-21/52 + response: + body: + string: '[{"calendarDate": "2021-07-23", "value": 28}, {"calendarDate": "2021-07-30", + "value": 27}, {"calendarDate": "2021-08-06", "value": 25}, {"calendarDate": + "2021-08-13", "value": 24}, {"calendarDate": "2021-08-20", "value": 28}, {"calendarDate": + "2021-08-27", "value": 24}, {"calendarDate": "2021-09-03", "value": 32}, {"calendarDate": + "2021-09-10", "value": 28}, {"calendarDate": "2021-09-17", "value": 26}, {"calendarDate": + "2021-09-24", "value": 29}, {"calendarDate": "2021-10-01", "value": 25}, {"calendarDate": + "2021-10-08", "value": 23}, {"calendarDate": "2021-10-15", "value": 24}, {"calendarDate": + "2021-10-22", "value": 28}, {"calendarDate": "2021-10-29", "value": 21}, {"calendarDate": + "2021-11-05", "value": 25}, {"calendarDate": "2021-11-12", "value": 25}, {"calendarDate": + "2021-11-19", "value": 27}, {"calendarDate": "2021-11-26", "value": 25}, {"calendarDate": + "2021-12-03", "value": 25}, {"calendarDate": "2021-12-10", "value": 20}, {"calendarDate": + "2021-12-17", "value": 25}, {"calendarDate": "2021-12-24", "value": 27}, {"calendarDate": + "2021-12-31", "value": 26}, {"calendarDate": "2022-01-07", "value": 28}, {"calendarDate": + "2022-01-14", "value": 28}, {"calendarDate": "2022-01-21", "value": 27}, {"calendarDate": + "2022-01-28", "value": 29}, {"calendarDate": "2022-02-04", "value": 31}, {"calendarDate": + "2022-02-11", "value": 26}, {"calendarDate": "2022-02-18", "value": 26}, {"calendarDate": + "2022-02-25", "value": 27}, {"calendarDate": "2022-03-04", "value": 25}, {"calendarDate": + "2022-03-11", "value": 26}, {"calendarDate": "2022-03-18", "value": 23}, {"calendarDate": + "2022-03-25", "value": 23}, {"calendarDate": "2022-04-01", "value": 22}, {"calendarDate": + "2022-04-08", "value": 22}, {"calendarDate": "2022-04-15", "value": 28}, {"calendarDate": + "2022-04-22", "value": 28}, {"calendarDate": "2022-04-29", "value": 30}, {"calendarDate": + "2022-05-06", "value": 25}, {"calendarDate": "2022-05-13", "value": 27}, {"calendarDate": + "2022-05-20", "value": 24}, {"calendarDate": "2022-05-27", "value": 26}, {"calendarDate": + "2022-06-03", "value": 29}, {"calendarDate": "2022-06-10", "value": 24}, {"calendarDate": + "2022-06-17", "value": 27}, {"calendarDate": "2022-06-24", "value": 30}, {"calendarDate": + "2022-07-01", "value": 29}, {"calendarDate": "2022-07-08", "value": 31}, {"calendarDate": + "2022-07-15", "value": 29}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d046b9ab1556-QRO + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:43 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=0dABjcBPpyek7KsjPxN92hSMprS3sX9rPZCzqDi%2FrYpCUHfJ0FfvZyzwuaVQ8o5hu7FCdLq2QjQEkMwXslZq7pu1jw7L90TJsAIYtJlRhYw1LNqP6dokxIDbGFHHZsuUjOCsxaOARw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/weekly/2021-07-22/52 + response: + body: + string: '[{"calendarDate": "2020-11-13", "value": 25}, {"calendarDate": "2020-11-20", + "value": 25}, {"calendarDate": "2020-11-27", "value": 21}, {"calendarDate": + "2020-12-04", "value": 26}, {"calendarDate": "2020-12-11", "value": 28}, {"calendarDate": + "2020-12-18", "value": 21}, {"calendarDate": "2020-12-25", "value": 26}, {"calendarDate": + "2021-01-01", "value": 21}, {"calendarDate": "2021-01-08", "value": 23}, {"calendarDate": + "2021-01-15", "value": 22}, {"calendarDate": "2021-01-22", "value": 24}, {"calendarDate": + "2021-01-29", "value": 23}, {"calendarDate": "2021-02-05", "value": 27}, {"calendarDate": + "2021-02-12", "value": 25}, {"calendarDate": "2021-02-19", "value": 27}, {"calendarDate": + "2021-02-26", "value": 20}, {"calendarDate": "2021-03-05", "value": 24}, {"calendarDate": + "2021-03-12", "value": 23}, {"calendarDate": "2021-03-19", "value": 23}, {"calendarDate": + "2021-03-26", "value": 25}, {"calendarDate": "2021-04-02", "value": 26}, {"calendarDate": + "2021-04-09", "value": 25}, {"calendarDate": "2021-04-16", "value": 22}, {"calendarDate": + "2021-04-23", "value": 24}, {"calendarDate": "2021-04-30", "value": 25}, {"calendarDate": + "2021-05-07", "value": 24}, {"calendarDate": "2021-05-14", "value": 24}, {"calendarDate": + "2021-05-21", "value": 24}, {"calendarDate": "2021-05-28", "value": 23}, {"calendarDate": + "2021-06-04", "value": 24}, {"calendarDate": "2021-06-11", "value": 21}, {"calendarDate": + "2021-06-18", "value": 20}, {"calendarDate": "2021-06-25", "value": 22}, {"calendarDate": + "2021-07-02", "value": 24}, {"calendarDate": "2021-07-09", "value": 28}, {"calendarDate": + "2021-07-16", "value": 22}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d048dfef4773-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:44 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=KB2vAYUsuOIPmTgbNh1mqCxbPxyRAWt4d62WshenVJhz7KjqcN6q387XCXzC2veJ6JaPoC%2B10JQahiQqo5PmFmxgUWSYGeagUmFKB6DX5aXs0AWb8Ru8YrIYDUCD4FWraGQp2bN3jQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/weekly/2020-07-23/52 + response: + body: + string: '[]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d04b0d564770-DFW + Connection: + - keep-alive + Content-Length: + - '2' + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:44 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=kJ32Qw3rO%2FNBbdeJVElUsUXTYMQZNCtoUI4S2JDviH%2F3tXkOg1VmlYy%2BlGAEYt79Mss1E09YGwUZFucY%2F3%2FQpcTFcC%2F0dG3wWK8z9B6%2FkpaFPOnKcUvkGpdu%2FVl1lSXK%2BZxv%2FkneQw%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/cassettes/test_weekly_stress_pagination.yaml b/garth/tests/stats/cassettes/test_weekly_stress_pagination.yaml new file mode 100644 index 0000000..f82006a --- /dev/null +++ b/garth/tests/stats/cassettes/test_weekly_stress_pagination.yaml @@ -0,0 +1,155 @@ +interactions: +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/weekly/2023-07-20/52 + response: + body: + string: '[{"calendarDate": "2022-07-22", "value": 25}, {"calendarDate": "2022-07-29", + "value": 26}, {"calendarDate": "2022-08-05", "value": 27}, {"calendarDate": + "2022-08-12", "value": 29}, {"calendarDate": "2022-08-19", "value": 28}, {"calendarDate": + "2022-08-26", "value": 25}, {"calendarDate": "2022-09-02", "value": 27}, {"calendarDate": + "2022-09-09", "value": 23}, {"calendarDate": "2022-09-16", "value": 30}, {"calendarDate": + "2022-09-23", "value": 25}, {"calendarDate": "2022-09-30", "value": 23}, {"calendarDate": + "2022-10-07", "value": 22}, {"calendarDate": "2022-10-14", "value": 26}, {"calendarDate": + "2022-10-21", "value": 29}, {"calendarDate": "2022-10-28", "value": 25}, {"calendarDate": + "2022-11-04", "value": 29}, {"calendarDate": "2022-11-11", "value": 31}, {"calendarDate": + "2022-11-18", "value": 26}, {"calendarDate": "2022-11-25", "value": 26}, {"calendarDate": + "2022-12-02", "value": 27}, {"calendarDate": "2022-12-09", "value": 25}, {"calendarDate": + "2022-12-16", "value": 27}, {"calendarDate": "2022-12-23", "value": 30}, {"calendarDate": + "2022-12-30", "value": 30}, {"calendarDate": "2023-01-06", "value": 31}, {"calendarDate": + "2023-01-13", "value": 30}, {"calendarDate": "2023-01-20", "value": 31}, {"calendarDate": + "2023-01-27", "value": 26}, {"calendarDate": "2023-02-03", "value": 26}, {"calendarDate": + "2023-02-10", "value": 29}, {"calendarDate": "2023-02-17", "value": 25}, {"calendarDate": + "2023-02-24", "value": 23}, {"calendarDate": "2023-03-03", "value": 24}, {"calendarDate": + "2023-03-10", "value": 27}, {"calendarDate": "2023-03-17", "value": 35}, {"calendarDate": + "2023-03-24", "value": 35}, {"calendarDate": "2023-03-31", "value": 31}, {"calendarDate": + "2023-04-07", "value": 30}, {"calendarDate": "2023-04-14", "value": 27}, {"calendarDate": + "2023-04-21", "value": 27}, {"calendarDate": "2023-04-28", "value": 30}, {"calendarDate": + "2023-05-05", "value": 29}, {"calendarDate": "2023-05-12", "value": 28}, {"calendarDate": + "2023-05-19", "value": 26}, {"calendarDate": "2023-05-26", "value": 29}, {"calendarDate": + "2023-06-02", "value": 24}, {"calendarDate": "2023-06-09", "value": 28}, {"calendarDate": + "2023-06-16", "value": 34}, {"calendarDate": "2023-06-23", "value": 32}, {"calendarDate": + "2023-06-30", "value": 37}, {"calendarDate": "2023-07-07", "value": 30}, {"calendarDate": + "2023-07-14", "value": 34}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d0420f64485e-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:43 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=r7%2F9tPODwjk6XSInj%2F27RVln6GI1GZS1XPdSqgXUtOAYku0XeefqxhEQ4v2%2FG30cFR9hcMVlnk8G2MWb0GtyRlYFZRMZzpzHbOfdZGCiZDWTKsYcavDHB0iFF07x0XxSZy1NOnZPxQ%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - _cfuvid=SANITIZED; path=SANITIZED; domain=SANITIZED; HttpOnly; Secure; SameSite=SANITIZED + status: + code: 200 + message: OK +- request: + body: null + headers: + Accept: + - '*/*' + Accept-Encoding: + - gzip, deflate + Authorization: + - Bearer SANITIZED + Connection: + - keep-alive + Cookie: + - _cfuvid=SANITIZED; ADRUM_BT1=SANITIZED; ADRUM_BTa=SANITIZED; SameSite=SANITIZED + User-Agent: + - Mozilla/5.0 (iPhone; CPU iPhone OS 16_5 like Mac OS X) AppleWebKit/605.1.15 + (KHTML, like Gecko) Mobile/15E148 + method: GET + uri: https://connectapi.garmin.com/usersummary-service/stats/stress/weekly/2022-07-21/8 + response: + body: + string: '[{"calendarDate": "2022-05-27", "value": 26}, {"calendarDate": "2022-06-03", + "value": 29}, {"calendarDate": "2022-06-10", "value": 24}, {"calendarDate": + "2022-06-17", "value": 27}, {"calendarDate": "2022-06-24", "value": 30}, {"calendarDate": + "2022-07-01", "value": 29}, {"calendarDate": "2022-07-08", "value": 31}, {"calendarDate": + "2022-07-15", "value": 29}]' + headers: + CF-Cache-Status: + - DYNAMIC + CF-RAY: + - 7f12d04408c24773-DFW + Connection: + - keep-alive + Content-Type: + - application/json + Date: + - Fri, 04 Aug 2023 00:51:43 GMT + NEL: + - '{"success_fraction":0.01,"report_to":"cf-nel","max_age":604800}' + Report-To: + - '{"endpoints":[{"url":"https:\/\/a.nel.cloudflare.com\/report\/v3?s=KWq8%2Fp%2Bv4Pju9Cm8%2B1sQhAf4zxg%2FWFLsTGqeifi%2FjsbxHnQiNQ9pMu48Hi7MyeVTYTclB%2FmS0nDslvydNk0TYRKNUY53M37xkPBa5K6XynkHSBcj7tYNozBZBqYRMWeJTf4NJuvobA%3D%3D"}],"group":"cf-nel","max_age":604800}' + Server: + - cloudflare + Transfer-Encoding: + - chunked + alt-svc: + - h3=":443"; ma=86400 + cache-control: + - no-cache, no-store, private + pragma: + - no-cache + set-cookie: + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BTa=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - SameSite=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + - ADRUM_BT1=SANITIZED; Max-Age=SANITIZED; Expires=SANITIZED; Path=SANITIZED; + Secure + status: + code: 200 + message: OK +version: 1 diff --git a/garth/tests/stats/test_hrv.py b/garth/tests/stats/test_hrv.py new file mode 100644 index 0000000..98b6167 --- /dev/null +++ b/garth/tests/stats/test_hrv.py @@ -0,0 +1,39 @@ +from datetime import date + +import pytest + +from garth import DailyHRV +from garth.http import Client + + +@pytest.mark.vcr +def test_daily_hrv(authed_client: Client): + end = date(2023, 7, 20) + days = 20 + daily_hrv = DailyHRV.list(end, days, client=authed_client) + assert daily_hrv[-1].calendar_date == end + assert len(daily_hrv) == days + + +@pytest.mark.vcr +def test_daily_hrv_paginate(authed_client: Client): + end = date(2023, 7, 20) + days = 40 + daily_hrv = DailyHRV.list(end, days, client=authed_client) + assert daily_hrv[-1].calendar_date == end + assert len(daily_hrv) == days + + +@pytest.mark.vcr +def test_daily_hrv_no_results(authed_client: Client): + end = date(1990, 7, 20) + daily_hrv = DailyHRV.list(end, client=authed_client) + assert daily_hrv == [] + + +@pytest.mark.vcr +def test_daily_hrv_paginate_no_results(authed_client: Client): + end = date(1990, 7, 20) + days = 40 + daily_hrv = DailyHRV.list(end, days, client=authed_client) + assert daily_hrv == [] diff --git a/garth/tests/stats/test_hydration.py b/garth/tests/stats/test_hydration.py new file mode 100644 index 0000000..896aaee --- /dev/null +++ b/garth/tests/stats/test_hydration.py @@ -0,0 +1,15 @@ +from datetime import date + +import pytest + +from garth import DailyHydration +from garth.http import Client + + +@pytest.mark.vcr +def test_daily_hydration(authed_client: Client): + end = date(2024, 6, 29) + daily_hydration = DailyHydration.list(end, client=authed_client) + assert daily_hydration[-1].calendar_date == end + assert daily_hydration[-1].value_in_ml == 1750.0 + assert daily_hydration[-1].goal_in_ml == 2800.0 diff --git a/garth/tests/stats/test_intensity_minutes.py b/garth/tests/stats/test_intensity_minutes.py new file mode 100644 index 0000000..603146b --- /dev/null +++ b/garth/tests/stats/test_intensity_minutes.py @@ -0,0 +1,29 @@ +from datetime import date + +import pytest + +from garth import DailyIntensityMinutes, WeeklyIntensityMinutes +from garth.http import Client + + +@pytest.mark.vcr +def test_daily_intensity_minutes(authed_client: Client): + end = date(2023, 7, 20) + days = 20 + daily_im = DailyIntensityMinutes.list(end, days, client=authed_client) + assert daily_im[-1].calendar_date == end + assert len(daily_im) == days + + +@pytest.mark.vcr +def test_weekly_intensity_minutes(authed_client: Client): + end = date(2023, 7, 20) + weeks = 12 + weekly_im = WeeklyIntensityMinutes.list(end, weeks, client=authed_client) + assert len(weekly_im) == weeks + assert ( + weekly_im[-1].calendar_date.isocalendar()[ + 1 + ] # in python3.9+ [1] can be .week + == end.isocalendar()[1] + ) diff --git a/garth/tests/stats/test_sleep_stats.py b/garth/tests/stats/test_sleep_stats.py new file mode 100644 index 0000000..d61bd0e --- /dev/null +++ b/garth/tests/stats/test_sleep_stats.py @@ -0,0 +1,15 @@ +from datetime import date + +import pytest + +from garth import DailySleep +from garth.http import Client + + +@pytest.mark.vcr +def test_daily_sleep(authed_client: Client): + end = date(2023, 7, 20) + days = 20 + daily_sleep = DailySleep.list(end, days, client=authed_client) + assert daily_sleep[-1].calendar_date == end + assert len(daily_sleep) == days diff --git a/garth/tests/stats/test_steps.py b/garth/tests/stats/test_steps.py new file mode 100644 index 0000000..4dd289f --- /dev/null +++ b/garth/tests/stats/test_steps.py @@ -0,0 +1,24 @@ +from datetime import date, timedelta + +import pytest + +from garth import DailySteps, WeeklySteps +from garth.http import Client + + +@pytest.mark.vcr +def test_daily_steps(authed_client: Client): + end = date(2023, 7, 20) + days = 20 + daily_steps = DailySteps.list(end, days, client=authed_client) + assert daily_steps[-1].calendar_date == end + assert len(daily_steps) == days + + +@pytest.mark.vcr +def test_weekly_steps(authed_client: Client): + end = date(2023, 7, 20) + weeks = 52 + weekly_steps = WeeklySteps.list(end, weeks, client=authed_client) + assert len(weekly_steps) == weeks + assert weekly_steps[-1].calendar_date == end - timedelta(days=6) diff --git a/garth/tests/stats/test_stress.py b/garth/tests/stats/test_stress.py new file mode 100644 index 0000000..ef1863c --- /dev/null +++ b/garth/tests/stats/test_stress.py @@ -0,0 +1,49 @@ +from datetime import date, timedelta + +import pytest + +from garth import DailyStress, WeeklyStress +from garth.http import Client + + +@pytest.mark.vcr +def test_daily_stress(authed_client: Client): + end = date(2023, 7, 20) + days = 20 + daily_stress = DailyStress.list(end, days, client=authed_client) + assert daily_stress[-1].calendar_date == end + assert len(daily_stress) == days + + +@pytest.mark.vcr +def test_daily_stress_pagination(authed_client: Client): + end = date(2023, 7, 20) + days = 60 + daily_stress = DailyStress.list(end, days, client=authed_client) + assert len(daily_stress) == days + + +@pytest.mark.vcr +def test_weekly_stress(authed_client: Client): + end = date(2023, 7, 20) + weeks = 52 + weekly_stress = WeeklyStress.list(end, weeks, client=authed_client) + assert len(weekly_stress) == weeks + assert weekly_stress[-1].calendar_date == end - timedelta(days=6) + + +@pytest.mark.vcr +def test_weekly_stress_pagination(authed_client: Client): + end = date(2023, 7, 20) + weeks = 60 + weekly_stress = WeeklyStress.list(end, weeks, client=authed_client) + assert len(weekly_stress) == weeks + assert weekly_stress[-1].calendar_date == end - timedelta(days=6) + + +@pytest.mark.vcr +def test_weekly_stress_beyond_data(authed_client: Client): + end = date(2023, 7, 20) + weeks = 1000 + weekly_stress = WeeklyStress.list(end, weeks, client=authed_client) + assert len(weekly_stress) < weeks diff --git a/garth/tests/test_auth_tokens.py b/garth/tests/test_auth_tokens.py new file mode 100644 index 0000000..d5dafb4 --- /dev/null +++ b/garth/tests/test_auth_tokens.py @@ -0,0 +1,17 @@ +import time + +from garth.auth_tokens import OAuth2Token + + +def test_is_expired(oauth2_token: OAuth2Token): + oauth2_token.expires_at = int(time.time() - 1) + assert oauth2_token.expired is True + + +def test_refresh_is_expired(oauth2_token: OAuth2Token): + oauth2_token.refresh_token_expires_at = int(time.time() - 1) + assert oauth2_token.refresh_expired is True + + +def test_str(oauth2_token: OAuth2Token): + assert str(oauth2_token) == "Bearer bar" diff --git a/garth/tests/test_cli.py b/garth/tests/test_cli.py new file mode 100644 index 0000000..8c04454 --- /dev/null +++ b/garth/tests/test_cli.py @@ -0,0 +1,44 @@ +import builtins +import getpass +import sys + +import pytest + +from garth.cli import main + + +def test_help_flag(monkeypatch, capsys): + # -h should print help and exit with code 0 + monkeypatch.setattr(sys, "argv", ["garth", "-h"]) + with pytest.raises(SystemExit) as excinfo: + main() + assert excinfo.value.code == 0 + out, err = capsys.readouterr() + assert "usage:" in out.lower() + + +def test_no_args_prints_help(monkeypatch, capsys): + # No args should print help and not exit + monkeypatch.setattr(sys, "argv", ["garth"]) + main() + out, err = capsys.readouterr() + assert "usage:" in out.lower() + + +@pytest.mark.vcr +def test_login_command(monkeypatch, capsys): + def mock_input(prompt): + match prompt: + case "Email: ": + return "user@example.com" + case "MFA code: ": + code = "023226" + return code + + monkeypatch.setattr(sys, "argv", ["garth", "login"]) + monkeypatch.setattr(builtins, "input", mock_input) + monkeypatch.setattr(getpass, "getpass", lambda _: "correct_password") + main() + out, err = capsys.readouterr() + assert out + assert not err diff --git a/garth/tests/test_http.py b/garth/tests/test_http.py new file mode 100644 index 0000000..520c09e --- /dev/null +++ b/garth/tests/test_http.py @@ -0,0 +1,278 @@ +import tempfile +import time +from typing import Any, cast + +import pytest +from requests.adapters import HTTPAdapter + +from garth.auth_tokens import OAuth1Token, OAuth2Token +from garth.exc import GarthHTTPError +from garth.http import Client + + +def test_dump_and_load(authed_client: Client): + with tempfile.TemporaryDirectory() as tempdir: + authed_client.dump(tempdir) + + new_client = Client() + new_client.load(tempdir) + + assert new_client.oauth1_token == authed_client.oauth1_token + assert new_client.oauth2_token == authed_client.oauth2_token + + +def test_dumps_and_loads(authed_client: Client): + s = authed_client.dumps() + new_client = Client() + new_client.loads(s) + assert new_client.oauth1_token == authed_client.oauth1_token + assert new_client.oauth2_token == authed_client.oauth2_token + + +def test_configure_oauth2_token(client: Client, oauth2_token: OAuth2Token): + assert client.oauth2_token is None + client.configure(oauth2_token=oauth2_token) + assert client.oauth2_token == oauth2_token + + +def test_configure_domain(client: Client): + assert client.domain == "garmin.com" + client.configure(domain="garmin.cn") + assert client.domain == "garmin.cn" + + +def test_configure_proxies(client: Client): + assert client.sess.proxies == {} + proxy = {"https": "http://localhost:8888"} + client.configure(proxies=proxy) + assert client.sess.proxies["https"] == proxy["https"] + + +def test_configure_ssl_verify(client: Client): + assert client.sess.verify is True + client.configure(ssl_verify=False) + assert client.sess.verify is False + + +def test_configure_timeout(client: Client): + assert client.timeout == 10 + client.configure(timeout=99) + assert client.timeout == 99 + + +def test_configure_retry(client: Client): + assert client.retries == 3 + adapter = client.sess.adapters["https://"] + assert isinstance(adapter, HTTPAdapter) + assert adapter.max_retries.total == client.retries + + client.configure(retries=99) + assert client.retries == 99 + adapter = client.sess.adapters["https://"] + assert isinstance(adapter, HTTPAdapter) + assert adapter.max_retries.total == 99 + + +def test_configure_status_forcelist(client: Client): + assert client.status_forcelist == (408, 429, 500, 502, 503, 504) + adapter = client.sess.adapters["https://"] + assert isinstance(adapter, HTTPAdapter) + assert adapter.max_retries.status_forcelist == client.status_forcelist + + client.configure(status_forcelist=(200, 201, 202)) + assert client.status_forcelist == (200, 201, 202) + adapter = client.sess.adapters["https://"] + assert isinstance(adapter, HTTPAdapter) + assert adapter.max_retries.status_forcelist == client.status_forcelist + + +def test_configure_backoff_factor(client: Client): + assert client.backoff_factor == 0.5 + adapter = client.sess.adapters["https://"] + assert isinstance(adapter, HTTPAdapter) + assert adapter.max_retries.backoff_factor == client.backoff_factor + + client.configure(backoff_factor=0.99) + assert client.backoff_factor == 0.99 + adapter = client.sess.adapters["https://"] + assert isinstance(adapter, HTTPAdapter) + assert adapter.max_retries.backoff_factor == client.backoff_factor + + +def test_configure_pool_maxsize(client: Client): + assert client.pool_maxsize == 10 + client.configure(pool_maxsize=99) + assert client.pool_maxsize == 99 + adapter = client.sess.adapters["https://"] + assert isinstance(adapter, HTTPAdapter) + assert adapter.poolmanager.connection_pool_kw["maxsize"] == 99 + + +def test_configure_pool_connections(client: Client): + client.configure(pool_connections=99) + assert client.pool_connections == 99 + adapter = client.sess.adapters["https://"] + assert isinstance(adapter, HTTPAdapter) + assert getattr(adapter, "_pool_connections", None) == 99, ( + "Pool connections not properly configured" + ) + + +@pytest.mark.vcr +def test_client_request(client: Client): + resp = client.request("GET", "connect", "/") + assert resp.ok + + with pytest.raises(GarthHTTPError) as e: + client.request("GET", "connectapi", "/") + assert "404" in str(e.value) + + +@pytest.mark.vcr +def test_login_success_mfa(monkeypatch, client: Client): + def mock_input(_): + return "327751" + + monkeypatch.setattr("builtins.input", mock_input) + + assert client.oauth1_token is None + assert client.oauth2_token is None + client.login("user@example.com", "correct_password") + assert client.oauth1_token + assert client.oauth2_token + + +@pytest.mark.vcr +def test_username(authed_client: Client): + assert authed_client._user_profile is None + assert authed_client.username + assert authed_client._user_profile + + +@pytest.mark.vcr +def test_profile_alias(authed_client: Client): + assert authed_client._user_profile is None + profile = authed_client.profile + assert profile == authed_client.user_profile + assert authed_client._user_profile is not None + + +@pytest.mark.vcr +def test_connectapi(authed_client: Client): + stress = cast( + list[dict[str, Any]], + authed_client.connectapi( + "/usersummary-service/stats/stress/daily/2023-07-21/2023-07-21" + ), + ) + assert stress + assert isinstance(stress, list) + assert len(stress) == 1 + assert stress[0]["calendarDate"] == "2023-07-21" + assert list(stress[0]["values"].keys()) == [ + "highStressDuration", + "lowStressDuration", + "overallStressLevel", + "restStressDuration", + "mediumStressDuration", + ] + + +@pytest.mark.vcr +def test_refresh_oauth2_token(authed_client: Client): + assert authed_client.oauth2_token and isinstance( + authed_client.oauth2_token, OAuth2Token + ) + authed_client.oauth2_token.expires_at = int(time.time()) + assert authed_client.oauth2_token.expired + profile = authed_client.connectapi("/userprofile-service/socialProfile") + assert profile + assert isinstance(profile, dict) + assert profile["userName"] + + +@pytest.mark.vcr +def test_download(authed_client: Client): + downloaded = authed_client.download( + "/download-service/files/activity/11998957007" + ) + assert downloaded + zip_magic_number = b"\x50\x4b\x03\x04" + assert downloaded[:4] == zip_magic_number + + +@pytest.mark.vcr +def test_upload(authed_client: Client): + fpath = "tests/12129115726_ACTIVITY.fit" + with open(fpath, "rb") as f: + uploaded = authed_client.upload(f) + assert uploaded + + +@pytest.mark.vcr +def test_delete(authed_client: Client): + activity_id = "12135235656" + path = f"/activity-service/activity/{activity_id}" + assert authed_client.connectapi(path) + authed_client.delete( + "connectapi", + path, + api=True, + ) + with pytest.raises(GarthHTTPError) as e: + authed_client.connectapi(path) + assert "404" in str(e.value) + + +@pytest.mark.vcr +def test_put(authed_client: Client): + data = [ + { + "changeState": "CHANGED", + "trainingMethod": "HR_RESERVE", + "lactateThresholdHeartRateUsed": 170, + "maxHeartRateUsed": 185, + "restingHrAutoUpdateUsed": False, + "sport": "DEFAULT", + "zone1Floor": 130, + "zone2Floor": 140, + "zone3Floor": 150, + "zone4Floor": 160, + "zone5Floor": 170, + } + ] + path = "/biometric-service/heartRateZones" + authed_client.put( + "connectapi", + path, + api=True, + json=data, + ) + assert authed_client.connectapi(path) + + +@pytest.mark.vcr +def test_resume_login(client: Client): + result = client.login( + "example@example.com", + "correct_password", + return_on_mfa=True, + ) + + assert isinstance(result, tuple) + result_type, client_state = result + + assert isinstance(client_state, dict) + assert result_type == "needs_mfa" + assert "signin_params" in client_state + assert "client" in client_state + + code = "123456" # obtain from custom login + + # test resuming the login + oauth1, oauth2 = client.resume_login(client_state, code) + + assert oauth1 + assert isinstance(oauth1, OAuth1Token) + assert oauth2 + assert isinstance(oauth2, OAuth2Token) diff --git a/garth/tests/test_sso.py b/garth/tests/test_sso.py new file mode 100644 index 0000000..249001f --- /dev/null +++ b/garth/tests/test_sso.py @@ -0,0 +1,185 @@ +import time + +import pytest + +from garth import sso +from garth.auth_tokens import OAuth1Token, OAuth2Token +from garth.exc import GarthException, GarthHTTPError +from garth.http import Client + + +@pytest.mark.vcr +def test_login_email_password_fail(client: Client): + with pytest.raises(GarthHTTPError): + sso.login("user@example.com", "wrong_p@ssword", client=client) + + +@pytest.mark.vcr +def test_login_success(client: Client): + oauth1, oauth2 = sso.login( + "user@example.com", "correct_password", client=client + ) + + assert oauth1 + assert isinstance(oauth1, OAuth1Token) + assert oauth2 + assert isinstance(oauth2, OAuth2Token) + + +@pytest.mark.vcr +def test_login_success_mfa(monkeypatch, client: Client): + def mock_input(_): + return "671091" + + monkeypatch.setattr("builtins.input", mock_input) + oauth1, oauth2 = sso.login( + "user@example.com", "correct_password", client=client + ) + + assert oauth1 + assert isinstance(oauth1, OAuth1Token) + assert oauth2 + assert isinstance(oauth2, OAuth2Token) + + +@pytest.mark.vcr +def test_login_success_mfa_async(monkeypatch, client: Client): + def mock_input(_): + return "031174" + + async def prompt_mfa(): + return input("MFA code: ") + + monkeypatch.setattr("builtins.input", mock_input) + oauth1, oauth2 = sso.login( + "user@example.com", + "correct_password", + client=client, + prompt_mfa=prompt_mfa, + ) + + assert oauth1 + assert isinstance(oauth1, OAuth1Token) + assert oauth2 + assert isinstance(oauth2, OAuth2Token) + + +@pytest.mark.vcr +def test_login_mfa_fail(client: Client): + with pytest.raises(GarthException): + oauth1, oauth2 = sso.login( + "user@example.com", + "correct_password", + client=client, + prompt_mfa=lambda: "123456", + ) + + +@pytest.mark.vcr +def test_login_return_on_mfa(client: Client): + result = sso.login( + "user@example.com", + "correct_password", + client=client, + return_on_mfa=True, + ) + + assert isinstance(result, tuple) + result_type, client_state = result + + assert isinstance(client_state, dict) + assert result_type == "needs_mfa" + assert "signin_params" in client_state + assert "client" in client_state + + code = "123456" # obtain from custom login + + # test resuming the login + oauth1, oauth2 = sso.resume_login(client_state, code) + + assert oauth1 + assert isinstance(oauth1, OAuth1Token) + assert oauth2 + assert isinstance(oauth2, OAuth2Token) + + +def test_set_expirations(oauth2_token_dict: dict): + token = sso.set_expirations(oauth2_token_dict) + assert ( + token["expires_at"] - time.time() - oauth2_token_dict["expires_in"] < 1 + ) + assert ( + token["refresh_token_expires_at"] + - time.time() + - oauth2_token_dict["refresh_token_expires_in"] + < 1 + ) + + +@pytest.mark.vcr +def test_exchange(authed_client: Client): + assert authed_client.oauth1_token and isinstance( + authed_client.oauth1_token, OAuth1Token + ) + oauth1_token = authed_client.oauth1_token + oauth2_token = sso.exchange(oauth1_token, client=authed_client) + assert not oauth2_token.expired + assert not oauth2_token.refresh_expired + assert oauth2_token.token_type.title() == "Bearer" + assert authed_client.oauth2_token != oauth2_token + + +def test_get_csrf_token(): + html = """ + + + + +

Success

+ + + + """ + assert sso.get_csrf_token(html) == "foo" + + +def test_get_csrf_token_fail(): + html = """ + + + + +

Success

+ + + """ + with pytest.raises(GarthException): + sso.get_csrf_token(html) + + +def test_get_title(): + html = """ + + + Success + + +

Success

+ + + """ + assert sso.get_title(html) == "Success" + + +def test_get_title_fail(): + html = """ + + + + +

Success

+ + + """ + with pytest.raises(GarthException): + sso.get_title(html) diff --git a/garth/tests/test_users.py b/garth/tests/test_users.py new file mode 100644 index 0000000..60db1bf --- /dev/null +++ b/garth/tests/test_users.py @@ -0,0 +1,27 @@ +import pytest + +from garth import UserProfile, UserSettings +from garth.http import Client + + +@pytest.mark.vcr +def test_user_profile(authed_client: Client): + profile = UserProfile.get(client=authed_client) + assert profile.user_name + + +@pytest.mark.vcr +def test_user_settings(authed_client: Client): + settings = UserSettings.get(client=authed_client) + assert settings.user_data + + +@pytest.mark.vcr +def test_user_settings_sleep_windows(authed_client: Client): + settings = UserSettings.get(client=authed_client) + assert settings.user_data + assert isinstance(settings.user_sleep_windows, list) + for window in settings.user_sleep_windows: + assert hasattr(window, "sleep_window_frequency") + assert hasattr(window, "start_sleep_time_seconds_from_midnight") + assert hasattr(window, "end_sleep_time_seconds_from_midnight") diff --git a/garth/tests/test_utils.py b/garth/tests/test_utils.py new file mode 100644 index 0000000..8ebc3a2 --- /dev/null +++ b/garth/tests/test_utils.py @@ -0,0 +1,65 @@ +from dataclasses import dataclass +from datetime import date, datetime + +from garth.utils import ( + asdict, + camel_to_snake, + camel_to_snake_dict, + format_end_date, +) + + +def test_camel_to_snake(): + assert camel_to_snake("hiThereHuman") == "hi_there_human" + + +def test_camel_to_snake_dict(): + assert camel_to_snake_dict({"hiThereHuman": "hi"}) == { + "hi_there_human": "hi" + } + + +def test_format_end_date(): + assert format_end_date("2021-01-01") == date(2021, 1, 1) + assert format_end_date(None) == date.today() + assert format_end_date(date(2021, 1, 1)) == date(2021, 1, 1) + + +@dataclass +class AsDictTestClass: + name: str + age: int + birth_date: date + + +def test_asdict(): + # Test for dataclass instance + instance = AsDictTestClass("Test", 20, date.today()) + assert asdict(instance) == { + "name": "Test", + "age": 20, + "birth_date": date.today().isoformat(), + } + + # Test for list of dataclass instances + instances = [ + AsDictTestClass("Test1", 20, date.today()), + AsDictTestClass("Test2", 30, date.today()), + ] + expected_output = [ + {"name": "Test1", "age": 20, "birth_date": date.today().isoformat()}, + {"name": "Test2", "age": 30, "birth_date": date.today().isoformat()}, + ] + assert asdict(instances) == expected_output + + # Test for date instance + assert asdict(date.today()) == date.today().isoformat() + + # Test for datetime instance + now = datetime.now() + assert asdict(now) == now.isoformat() + + # Test for regular types + assert asdict("Test") == "Test" + assert asdict(123) == 123 + assert asdict(None) is None diff --git a/garth/uv.lock b/garth/uv.lock new file mode 100644 index 0000000..00db826 --- /dev/null +++ b/garth/uv.lock @@ -0,0 +1,2129 @@ +version = 1 +revision = 2 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'", + "python_full_version >= '3.12' and platform_python_implementation != 'PyPy'", + "python_full_version == '3.11.*' and platform_python_implementation == 'PyPy'", + "python_full_version == '3.11.*' and platform_python_implementation != 'PyPy'", + "python_full_version < '3.11' and platform_python_implementation != 'PyPy'", + "python_full_version < '3.11' and platform_python_implementation == 'PyPy'", +] + +[[package]] +name = "annotated-types" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" }, +] + +[[package]] +name = "certifi" +version = "2025.4.26" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e8/9e/c05b3920a3b7d20d3d3310465f50348e5b3694f4f88c6daf736eef3024c4/certifi-2025.4.26.tar.gz", hash = "sha256:0a816057ea3cdefcef70270d2c515e4506bbc954f417fa5ade2021213bb8f0c6", size = 160705, upload-time = "2025-04-26T02:12:29.51Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/7e/3db2bd1b1f9e95f7cddca6d6e75e2f2bd9f51b1246e546d88addca0106bd/certifi-2025.4.26-py3-none-any.whl", hash = "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3", size = 159618, upload-time = "2025-04-26T02:12:27.662Z" }, +] + +[[package]] +name = "cffi" +version = "1.17.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191, upload-time = "2024-09-04T20:43:30.027Z" }, + { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592, upload-time = "2024-09-04T20:43:32.108Z" }, + { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024, upload-time = "2024-09-04T20:43:34.186Z" }, + { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188, upload-time = "2024-09-04T20:43:36.286Z" }, + { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571, upload-time = "2024-09-04T20:43:38.586Z" }, + { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687, upload-time = "2024-09-04T20:43:40.084Z" }, + { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211, upload-time = "2024-09-04T20:43:41.526Z" }, + { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325, upload-time = "2024-09-04T20:43:43.117Z" }, + { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784, upload-time = "2024-09-04T20:43:45.256Z" }, + { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564, upload-time = "2024-09-04T20:43:46.779Z" }, + { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804, upload-time = "2024-09-04T20:43:48.186Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299, upload-time = "2024-09-04T20:43:49.812Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264, upload-time = "2024-09-04T20:43:51.124Z" }, + { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651, upload-time = "2024-09-04T20:43:52.872Z" }, + { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259, upload-time = "2024-09-04T20:43:56.123Z" }, + { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200, upload-time = "2024-09-04T20:43:57.891Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235, upload-time = "2024-09-04T20:44:00.18Z" }, + { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721, upload-time = "2024-09-04T20:44:01.585Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242, upload-time = "2024-09-04T20:44:03.467Z" }, + { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999, upload-time = "2024-09-04T20:44:05.023Z" }, + { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242, upload-time = "2024-09-04T20:44:06.444Z" }, + { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604, upload-time = "2024-09-04T20:44:08.206Z" }, + { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727, upload-time = "2024-09-04T20:44:09.481Z" }, + { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400, upload-time = "2024-09-04T20:44:10.873Z" }, + { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload-time = "2024-09-04T20:44:12.232Z" }, + { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload-time = "2024-09-04T20:44:13.739Z" }, + { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload-time = "2024-09-04T20:44:15.231Z" }, + { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload-time = "2024-09-04T20:44:17.188Z" }, + { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload-time = "2024-09-04T20:44:18.688Z" }, + { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload-time = "2024-09-04T20:44:20.248Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload-time = "2024-09-04T20:44:21.673Z" }, + { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload-time = "2024-09-04T20:44:23.245Z" }, + { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload-time = "2024-09-04T20:44:24.757Z" }, + { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" }, + { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" }, + { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989, upload-time = "2024-09-04T20:44:28.956Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802, upload-time = "2024-09-04T20:44:30.289Z" }, + { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792, upload-time = "2024-09-04T20:44:32.01Z" }, + { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893, upload-time = "2024-09-04T20:44:33.606Z" }, + { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810, upload-time = "2024-09-04T20:44:35.191Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200, upload-time = "2024-09-04T20:44:36.743Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447, upload-time = "2024-09-04T20:44:38.492Z" }, + { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358, upload-time = "2024-09-04T20:44:40.046Z" }, + { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469, upload-time = "2024-09-04T20:44:41.616Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload-time = "2024-09-04T20:44:43.733Z" }, + { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload-time = "2024-09-04T20:44:45.309Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367, upload-time = "2025-05-02T08:34:42.01Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/28/9901804da60055b406e1a1c5ba7aac1276fb77f1dde635aabfc7fd84b8ab/charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941", size = 201818, upload-time = "2025-05-02T08:31:46.725Z" }, + { url = "https://files.pythonhosted.org/packages/d9/9b/892a8c8af9110935e5adcbb06d9c6fe741b6bb02608c6513983048ba1a18/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd", size = 144649, upload-time = "2025-05-02T08:31:48.889Z" }, + { url = "https://files.pythonhosted.org/packages/7b/a5/4179abd063ff6414223575e008593861d62abfc22455b5d1a44995b7c101/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6", size = 155045, upload-time = "2025-05-02T08:31:50.757Z" }, + { url = "https://files.pythonhosted.org/packages/3b/95/bc08c7dfeddd26b4be8c8287b9bb055716f31077c8b0ea1cd09553794665/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d", size = 147356, upload-time = "2025-05-02T08:31:52.634Z" }, + { url = "https://files.pythonhosted.org/packages/a8/2d/7a5b635aa65284bf3eab7653e8b4151ab420ecbae918d3e359d1947b4d61/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86", size = 149471, upload-time = "2025-05-02T08:31:56.207Z" }, + { url = "https://files.pythonhosted.org/packages/ae/38/51fc6ac74251fd331a8cfdb7ec57beba8c23fd5493f1050f71c87ef77ed0/charset_normalizer-3.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c", size = 151317, upload-time = "2025-05-02T08:31:57.613Z" }, + { url = "https://files.pythonhosted.org/packages/b7/17/edee1e32215ee6e9e46c3e482645b46575a44a2d72c7dfd49e49f60ce6bf/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0", size = 146368, upload-time = "2025-05-02T08:31:59.468Z" }, + { url = "https://files.pythonhosted.org/packages/26/2c/ea3e66f2b5f21fd00b2825c94cafb8c326ea6240cd80a91eb09e4a285830/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef", size = 154491, upload-time = "2025-05-02T08:32:01.219Z" }, + { url = "https://files.pythonhosted.org/packages/52/47/7be7fa972422ad062e909fd62460d45c3ef4c141805b7078dbab15904ff7/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6", size = 157695, upload-time = "2025-05-02T08:32:03.045Z" }, + { url = "https://files.pythonhosted.org/packages/2f/42/9f02c194da282b2b340f28e5fb60762de1151387a36842a92b533685c61e/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366", size = 154849, upload-time = "2025-05-02T08:32:04.651Z" }, + { url = "https://files.pythonhosted.org/packages/67/44/89cacd6628f31fb0b63201a618049be4be2a7435a31b55b5eb1c3674547a/charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db", size = 150091, upload-time = "2025-05-02T08:32:06.719Z" }, + { url = "https://files.pythonhosted.org/packages/1f/79/4b8da9f712bc079c0f16b6d67b099b0b8d808c2292c937f267d816ec5ecc/charset_normalizer-3.4.2-cp310-cp310-win32.whl", hash = "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a", size = 98445, upload-time = "2025-05-02T08:32:08.66Z" }, + { url = "https://files.pythonhosted.org/packages/7d/d7/96970afb4fb66497a40761cdf7bd4f6fca0fc7bafde3a84f836c1f57a926/charset_normalizer-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509", size = 105782, upload-time = "2025-05-02T08:32:10.46Z" }, + { url = "https://files.pythonhosted.org/packages/05/85/4c40d00dcc6284a1c1ad5de5e0996b06f39d8232f1031cd23c2f5c07ee86/charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2", size = 198794, upload-time = "2025-05-02T08:32:11.945Z" }, + { url = "https://files.pythonhosted.org/packages/41/d9/7a6c0b9db952598e97e93cbdfcb91bacd89b9b88c7c983250a77c008703c/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645", size = 142846, upload-time = "2025-05-02T08:32:13.946Z" }, + { url = "https://files.pythonhosted.org/packages/66/82/a37989cda2ace7e37f36c1a8ed16c58cf48965a79c2142713244bf945c89/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd", size = 153350, upload-time = "2025-05-02T08:32:15.873Z" }, + { url = "https://files.pythonhosted.org/packages/df/68/a576b31b694d07b53807269d05ec3f6f1093e9545e8607121995ba7a8313/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8", size = 145657, upload-time = "2025-05-02T08:32:17.283Z" }, + { url = "https://files.pythonhosted.org/packages/92/9b/ad67f03d74554bed3aefd56fe836e1623a50780f7c998d00ca128924a499/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f", size = 147260, upload-time = "2025-05-02T08:32:18.807Z" }, + { url = "https://files.pythonhosted.org/packages/a6/e6/8aebae25e328160b20e31a7e9929b1578bbdc7f42e66f46595a432f8539e/charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7", size = 149164, upload-time = "2025-05-02T08:32:20.333Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f2/b3c2f07dbcc248805f10e67a0262c93308cfa149a4cd3d1fe01f593e5fd2/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9", size = 144571, upload-time = "2025-05-02T08:32:21.86Z" }, + { url = "https://files.pythonhosted.org/packages/60/5b/c3f3a94bc345bc211622ea59b4bed9ae63c00920e2e8f11824aa5708e8b7/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544", size = 151952, upload-time = "2025-05-02T08:32:23.434Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4d/ff460c8b474122334c2fa394a3f99a04cf11c646da895f81402ae54f5c42/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82", size = 155959, upload-time = "2025-05-02T08:32:24.993Z" }, + { url = "https://files.pythonhosted.org/packages/a2/2b/b964c6a2fda88611a1fe3d4c400d39c66a42d6c169c924818c848f922415/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0", size = 153030, upload-time = "2025-05-02T08:32:26.435Z" }, + { url = "https://files.pythonhosted.org/packages/59/2e/d3b9811db26a5ebf444bc0fa4f4be5aa6d76fc6e1c0fd537b16c14e849b6/charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5", size = 148015, upload-time = "2025-05-02T08:32:28.376Z" }, + { url = "https://files.pythonhosted.org/packages/90/07/c5fd7c11eafd561bb51220d600a788f1c8d77c5eef37ee49454cc5c35575/charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a", size = 98106, upload-time = "2025-05-02T08:32:30.281Z" }, + { url = "https://files.pythonhosted.org/packages/a8/05/5e33dbef7e2f773d672b6d79f10ec633d4a71cd96db6673625838a4fd532/charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28", size = 105402, upload-time = "2025-05-02T08:32:32.191Z" }, + { url = "https://files.pythonhosted.org/packages/d7/a4/37f4d6035c89cac7930395a35cc0f1b872e652eaafb76a6075943754f095/charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7", size = 199936, upload-time = "2025-05-02T08:32:33.712Z" }, + { url = "https://files.pythonhosted.org/packages/ee/8a/1a5e33b73e0d9287274f899d967907cd0bf9c343e651755d9307e0dbf2b3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3", size = 143790, upload-time = "2025-05-02T08:32:35.768Z" }, + { url = "https://files.pythonhosted.org/packages/66/52/59521f1d8e6ab1482164fa21409c5ef44da3e9f653c13ba71becdd98dec3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a", size = 153924, upload-time = "2025-05-02T08:32:37.284Z" }, + { url = "https://files.pythonhosted.org/packages/86/2d/fb55fdf41964ec782febbf33cb64be480a6b8f16ded2dbe8db27a405c09f/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214", size = 146626, upload-time = "2025-05-02T08:32:38.803Z" }, + { url = "https://files.pythonhosted.org/packages/8c/73/6ede2ec59bce19b3edf4209d70004253ec5f4e319f9a2e3f2f15601ed5f7/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a", size = 148567, upload-time = "2025-05-02T08:32:40.251Z" }, + { url = "https://files.pythonhosted.org/packages/09/14/957d03c6dc343c04904530b6bef4e5efae5ec7d7990a7cbb868e4595ee30/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd", size = 150957, upload-time = "2025-05-02T08:32:41.705Z" }, + { url = "https://files.pythonhosted.org/packages/0d/c8/8174d0e5c10ccebdcb1b53cc959591c4c722a3ad92461a273e86b9f5a302/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981", size = 145408, upload-time = "2025-05-02T08:32:43.709Z" }, + { url = "https://files.pythonhosted.org/packages/58/aa/8904b84bc8084ac19dc52feb4f5952c6df03ffb460a887b42615ee1382e8/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c", size = 153399, upload-time = "2025-05-02T08:32:46.197Z" }, + { url = "https://files.pythonhosted.org/packages/c2/26/89ee1f0e264d201cb65cf054aca6038c03b1a0c6b4ae998070392a3ce605/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b", size = 156815, upload-time = "2025-05-02T08:32:48.105Z" }, + { url = "https://files.pythonhosted.org/packages/fd/07/68e95b4b345bad3dbbd3a8681737b4338ff2c9df29856a6d6d23ac4c73cb/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d", size = 154537, upload-time = "2025-05-02T08:32:49.719Z" }, + { url = "https://files.pythonhosted.org/packages/77/1a/5eefc0ce04affb98af07bc05f3bac9094513c0e23b0562d64af46a06aae4/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f", size = 149565, upload-time = "2025-05-02T08:32:51.404Z" }, + { url = "https://files.pythonhosted.org/packages/37/a0/2410e5e6032a174c95e0806b1a6585eb21e12f445ebe239fac441995226a/charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c", size = 98357, upload-time = "2025-05-02T08:32:53.079Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/c02d5c493967af3eda9c771ad4d2bbc8df6f99ddbeb37ceea6e8716a32bc/charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e", size = 105776, upload-time = "2025-05-02T08:32:54.573Z" }, + { url = "https://files.pythonhosted.org/packages/ea/12/a93df3366ed32db1d907d7593a94f1fe6293903e3e92967bebd6950ed12c/charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0", size = 199622, upload-time = "2025-05-02T08:32:56.363Z" }, + { url = "https://files.pythonhosted.org/packages/04/93/bf204e6f344c39d9937d3c13c8cd5bbfc266472e51fc8c07cb7f64fcd2de/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf", size = 143435, upload-time = "2025-05-02T08:32:58.551Z" }, + { url = "https://files.pythonhosted.org/packages/22/2a/ea8a2095b0bafa6c5b5a55ffdc2f924455233ee7b91c69b7edfcc9e02284/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e", size = 153653, upload-time = "2025-05-02T08:33:00.342Z" }, + { url = "https://files.pythonhosted.org/packages/b6/57/1b090ff183d13cef485dfbe272e2fe57622a76694061353c59da52c9a659/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1", size = 146231, upload-time = "2025-05-02T08:33:02.081Z" }, + { url = "https://files.pythonhosted.org/packages/e2/28/ffc026b26f441fc67bd21ab7f03b313ab3fe46714a14b516f931abe1a2d8/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c", size = 148243, upload-time = "2025-05-02T08:33:04.063Z" }, + { url = "https://files.pythonhosted.org/packages/c0/0f/9abe9bd191629c33e69e47c6ef45ef99773320e9ad8e9cb08b8ab4a8d4cb/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691", size = 150442, upload-time = "2025-05-02T08:33:06.418Z" }, + { url = "https://files.pythonhosted.org/packages/67/7c/a123bbcedca91d5916c056407f89a7f5e8fdfce12ba825d7d6b9954a1a3c/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0", size = 145147, upload-time = "2025-05-02T08:33:08.183Z" }, + { url = "https://files.pythonhosted.org/packages/ec/fe/1ac556fa4899d967b83e9893788e86b6af4d83e4726511eaaad035e36595/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b", size = 153057, upload-time = "2025-05-02T08:33:09.986Z" }, + { url = "https://files.pythonhosted.org/packages/2b/ff/acfc0b0a70b19e3e54febdd5301a98b72fa07635e56f24f60502e954c461/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff", size = 156454, upload-time = "2025-05-02T08:33:11.814Z" }, + { url = "https://files.pythonhosted.org/packages/92/08/95b458ce9c740d0645feb0e96cea1f5ec946ea9c580a94adfe0b617f3573/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b", size = 154174, upload-time = "2025-05-02T08:33:13.707Z" }, + { url = "https://files.pythonhosted.org/packages/78/be/8392efc43487ac051eee6c36d5fbd63032d78f7728cb37aebcc98191f1ff/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148", size = 149166, upload-time = "2025-05-02T08:33:15.458Z" }, + { url = "https://files.pythonhosted.org/packages/44/96/392abd49b094d30b91d9fbda6a69519e95802250b777841cf3bda8fe136c/charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7", size = 98064, upload-time = "2025-05-02T08:33:17.06Z" }, + { url = "https://files.pythonhosted.org/packages/e9/b0/0200da600134e001d91851ddc797809e2fe0ea72de90e09bec5a2fbdaccb/charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980", size = 105641, upload-time = "2025-05-02T08:33:18.753Z" }, + { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626, upload-time = "2025-05-02T08:34:40.053Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "comm" +version = "0.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/a8/fb783cb0abe2b5fded9f55e5703015cdf1c9c85b3669087c538dd15a6a86/comm-0.2.2.tar.gz", hash = "sha256:3fd7a84065306e07bea1773df6eb8282de51ba82f77c72f9c85716ab11fe980e", size = 6210, upload-time = "2024-03-12T16:53:41.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/75/49e5bfe642f71f272236b5b2d2691cf915a7283cc0ceda56357b61daa538/comm-0.2.2-py3-none-any.whl", hash = "sha256:e6fb86cb70ff661ee8c9c14e7d36d6de3b4066f1441be4063df9c5009f0a64d3", size = 7180, upload-time = "2024-03-12T16:53:39.226Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" }, + { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" }, + { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" }, + { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" }, + { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" }, + { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" }, + { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" }, + { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" }, + { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" }, + { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload-time = "2025-04-15T17:35:54.473Z" }, + { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload-time = "2025-04-15T17:35:58.283Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload-time = "2025-04-15T17:36:03.235Z" }, + { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload-time = "2025-04-15T17:36:08.275Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload-time = "2025-04-15T17:36:13.29Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload-time = "2025-04-15T17:36:18.329Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload-time = "2025-04-15T17:36:33.878Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload-time = "2025-04-15T17:36:51.295Z" }, + { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload-time = "2025-04-15T17:36:55.002Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload-time = "2025-04-15T17:36:58.576Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/44785876384eff370c251d58fd65f6ad7f39adce4a093c934d4a67a7c6b6/contourpy-1.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4caf2bcd2969402bf77edc4cb6034c7dd7c0803213b3523f111eb7460a51b8d2", size = 271580, upload-time = "2025-04-15T17:37:03.105Z" }, + { url = "https://files.pythonhosted.org/packages/93/3b/0004767622a9826ea3d95f0e9d98cd8729015768075d61f9fea8eeca42a8/contourpy-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:82199cb78276249796419fe36b7386bd8d2cc3f28b3bc19fe2454fe2e26c4c15", size = 255530, upload-time = "2025-04-15T17:37:07.026Z" }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7bd49e1f4fa805772d9fd130e0d375554ebc771ed7172f48dfcd4ca61549/contourpy-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106fab697af11456fcba3e352ad50effe493a90f893fca6c2ca5c033820cea92", size = 307688, upload-time = "2025-04-15T17:37:11.481Z" }, + { url = "https://files.pythonhosted.org/packages/fc/97/e1d5dbbfa170725ef78357a9a0edc996b09ae4af170927ba8ce977e60a5f/contourpy-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d14f12932a8d620e307f715857107b1d1845cc44fdb5da2bc8e850f5ceba9f87", size = 347331, upload-time = "2025-04-15T17:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/6f/66/e69e6e904f5ecf6901be3dd16e7e54d41b6ec6ae3405a535286d4418ffb4/contourpy-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:532fd26e715560721bb0d5fc7610fce279b3699b018600ab999d1be895b09415", size = 318963, upload-time = "2025-04-15T17:37:22.76Z" }, + { url = "https://files.pythonhosted.org/packages/a8/32/b8a1c8965e4f72482ff2d1ac2cd670ce0b542f203c8e1d34e7c3e6925da7/contourpy-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b383144cf2d2c29f01a1e8170f50dacf0eac02d64139dcd709a8ac4eb3cfe", size = 323681, upload-time = "2025-04-15T17:37:33.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/c6/12a7e6811d08757c7162a541ca4c5c6a34c0f4e98ef2b338791093518e40/contourpy-1.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c49f73e61f1f774650a55d221803b101d966ca0c5a2d6d5e4320ec3997489441", size = 1308674, upload-time = "2025-04-15T17:37:48.64Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8a/bebe5a3f68b484d3a2b8ffaf84704b3e343ef1addea528132ef148e22b3b/contourpy-1.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d80b2c0300583228ac98d0a927a1ba6a2ba6b8a742463c564f1d419ee5b211e", size = 1380480, upload-time = "2025-04-15T17:38:06.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/db/fcd325f19b5978fb509a7d55e06d99f5f856294c1991097534360b307cf1/contourpy-1.3.2-cp312-cp312-win32.whl", hash = "sha256:90df94c89a91b7362e1142cbee7568f86514412ab8a2c0d0fca72d7e91b62912", size = 178489, upload-time = "2025-04-15T17:38:10.338Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/fadd0b92ffa7b5eb5949bf340a63a4a496a6930a6c37a7ba0f12acb076d6/contourpy-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c942a01d9163e2e5cfb05cb66110121b8d07ad438a17f9e766317bcb62abf73", size = 223042, upload-time = "2025-04-15T17:38:14.239Z" }, + { url = "https://files.pythonhosted.org/packages/2e/61/5673f7e364b31e4e7ef6f61a4b5121c5f170f941895912f773d95270f3a2/contourpy-1.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:de39db2604ae755316cb5967728f4bea92685884b1e767b7c24e983ef5f771cb", size = 271630, upload-time = "2025-04-15T17:38:19.142Z" }, + { url = "https://files.pythonhosted.org/packages/ff/66/a40badddd1223822c95798c55292844b7e871e50f6bfd9f158cb25e0bd39/contourpy-1.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f9e896f447c5c8618f1edb2bafa9a4030f22a575ec418ad70611450720b5b08", size = 255670, upload-time = "2025-04-15T17:38:23.688Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c7/cf9fdee8200805c9bc3b148f49cb9482a4e3ea2719e772602a425c9b09f8/contourpy-1.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71e2bd4a1c4188f5c2b8d274da78faab884b59df20df63c34f74aa1813c4427c", size = 306694, upload-time = "2025-04-15T17:38:28.238Z" }, + { url = "https://files.pythonhosted.org/packages/dd/e7/ccb9bec80e1ba121efbffad7f38021021cda5be87532ec16fd96533bb2e0/contourpy-1.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de425af81b6cea33101ae95ece1f696af39446db9682a0b56daaa48cfc29f38f", size = 345986, upload-time = "2025-04-15T17:38:33.502Z" }, + { url = "https://files.pythonhosted.org/packages/dc/49/ca13bb2da90391fa4219fdb23b078d6065ada886658ac7818e5441448b78/contourpy-1.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:977e98a0e0480d3fe292246417239d2d45435904afd6d7332d8455981c408b85", size = 318060, upload-time = "2025-04-15T17:38:38.672Z" }, + { url = "https://files.pythonhosted.org/packages/c8/65/5245ce8c548a8422236c13ffcdcdada6a2a812c361e9e0c70548bb40b661/contourpy-1.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:434f0adf84911c924519d2b08fc10491dd282b20bdd3fa8f60fd816ea0b48841", size = 322747, upload-time = "2025-04-15T17:38:43.712Z" }, + { url = "https://files.pythonhosted.org/packages/72/30/669b8eb48e0a01c660ead3752a25b44fdb2e5ebc13a55782f639170772f9/contourpy-1.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c66c4906cdbc50e9cba65978823e6e00b45682eb09adbb78c9775b74eb222422", size = 1308895, upload-time = "2025-04-15T17:39:00.224Z" }, + { url = "https://files.pythonhosted.org/packages/05/5a/b569f4250decee6e8d54498be7bdf29021a4c256e77fe8138c8319ef8eb3/contourpy-1.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8b7fc0cd78ba2f4695fd0a6ad81a19e7e3ab825c31b577f384aa9d7817dc3bef", size = 1379098, upload-time = "2025-04-15T17:43:29.649Z" }, + { url = "https://files.pythonhosted.org/packages/19/ba/b227c3886d120e60e41b28740ac3617b2f2b971b9f601c835661194579f1/contourpy-1.3.2-cp313-cp313-win32.whl", hash = "sha256:15ce6ab60957ca74cff444fe66d9045c1fd3e92c8936894ebd1f3eef2fff075f", size = 178535, upload-time = "2025-04-15T17:44:44.532Z" }, + { url = "https://files.pythonhosted.org/packages/12/6e/2fed56cd47ca739b43e892707ae9a13790a486a3173be063681ca67d2262/contourpy-1.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e1578f7eafce927b168752ed7e22646dad6cd9bca673c60bff55889fa236ebf9", size = 223096, upload-time = "2025-04-15T17:44:48.194Z" }, + { url = "https://files.pythonhosted.org/packages/54/4c/e76fe2a03014a7c767d79ea35c86a747e9325537a8b7627e0e5b3ba266b4/contourpy-1.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0475b1f6604896bc7c53bb070e355e9321e1bc0d381735421a2d2068ec56531f", size = 285090, upload-time = "2025-04-15T17:43:34.084Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e2/5aba47debd55d668e00baf9651b721e7733975dc9fc27264a62b0dd26eb8/contourpy-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c85bb486e9be652314bb5b9e2e3b0d1b2e643d5eec4992c0fbe8ac71775da739", size = 268643, upload-time = "2025-04-15T17:43:38.626Z" }, + { url = "https://files.pythonhosted.org/packages/a1/37/cd45f1f051fe6230f751cc5cdd2728bb3a203f5619510ef11e732109593c/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:745b57db7758f3ffc05a10254edd3182a2a83402a89c00957a8e8a22f5582823", size = 310443, upload-time = "2025-04-15T17:43:44.522Z" }, + { url = "https://files.pythonhosted.org/packages/8b/a2/36ea6140c306c9ff6dd38e3bcec80b3b018474ef4d17eb68ceecd26675f4/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:970e9173dbd7eba9b4e01aab19215a48ee5dd3f43cef736eebde064a171f89a5", size = 349865, upload-time = "2025-04-15T17:43:49.545Z" }, + { url = "https://files.pythonhosted.org/packages/95/b7/2fc76bc539693180488f7b6cc518da7acbbb9e3b931fd9280504128bf956/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6c4639a9c22230276b7bffb6a850dfc8258a2521305e1faefe804d006b2e532", size = 321162, upload-time = "2025-04-15T17:43:54.203Z" }, + { url = "https://files.pythonhosted.org/packages/f4/10/76d4f778458b0aa83f96e59d65ece72a060bacb20cfbee46cf6cd5ceba41/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc829960f34ba36aad4302e78eabf3ef16a3a100863f0d4eeddf30e8a485a03b", size = 327355, upload-time = "2025-04-15T17:44:01.025Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/10cf483ea683f9f8ab096c24bad3cce20e0d1dd9a4baa0e2093c1c962d9d/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d32530b534e986374fc19eaa77fcb87e8a99e5431499949b828312bdcd20ac52", size = 1307935, upload-time = "2025-04-15T17:44:17.322Z" }, + { url = "https://files.pythonhosted.org/packages/78/73/69dd9a024444489e22d86108e7b913f3528f56cfc312b5c5727a44188471/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e298e7e70cf4eb179cc1077be1c725b5fd131ebc81181bf0c03525c8abc297fd", size = 1372168, upload-time = "2025-04-15T17:44:33.43Z" }, + { url = "https://files.pythonhosted.org/packages/0f/1b/96d586ccf1b1a9d2004dd519b25fbf104a11589abfd05484ff12199cca21/contourpy-1.3.2-cp313-cp313t-win32.whl", hash = "sha256:d0e589ae0d55204991450bb5c23f571c64fe43adaa53f93fc902a84c96f52fe1", size = 189550, upload-time = "2025-04-15T17:44:37.092Z" }, + { url = "https://files.pythonhosted.org/packages/b0/e6/6000d0094e8a5e32ad62591c8609e269febb6e4db83a1c75ff8868b42731/contourpy-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:78e9253c3de756b3f6a5174d024c4835acd59eb3f8e2ca13e775dbffe1558f69", size = 238214, upload-time = "2025-04-15T17:44:40.827Z" }, + { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" }, + { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" }, + { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload-time = "2025-04-15T17:45:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload-time = "2025-04-15T17:45:20.166Z" }, + { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload-time = "2025-04-15T17:45:24.794Z" }, +] + +[[package]] +name = "coverage" +version = "7.8.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/07/998afa4a0ecdf9b1981ae05415dad2d4e7716e1b1f00abbd91691ac09ac9/coverage-7.8.2.tar.gz", hash = "sha256:a886d531373a1f6ff9fad2a2ba4a045b68467b779ae729ee0b3b10ac20033b27", size = 812759, upload-time = "2025-05-23T11:39:57.856Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/26/6b/7dd06399a5c0b81007e3a6af0395cd60e6a30f959f8d407d3ee04642e896/coverage-7.8.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bd8ec21e1443fd7a447881332f7ce9d35b8fbd2849e761bb290b584535636b0a", size = 211573, upload-time = "2025-05-23T11:37:47.207Z" }, + { url = "https://files.pythonhosted.org/packages/f0/df/2b24090820a0bac1412955fb1a4dade6bc3b8dcef7b899c277ffaf16916d/coverage-7.8.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:4c26c2396674816deaeae7ded0e2b42c26537280f8fe313335858ffff35019be", size = 212006, upload-time = "2025-05-23T11:37:50.289Z" }, + { url = "https://files.pythonhosted.org/packages/c5/c4/e4e3b998e116625562a872a342419652fa6ca73f464d9faf9f52f1aff427/coverage-7.8.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1aec326ed237e5880bfe69ad41616d333712c7937bcefc1343145e972938f9b3", size = 241128, upload-time = "2025-05-23T11:37:52.229Z" }, + { url = "https://files.pythonhosted.org/packages/b1/67/b28904afea3e87a895da850ba587439a61699bf4b73d04d0dfd99bbd33b4/coverage-7.8.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5e818796f71702d7a13e50c70de2a1924f729228580bcba1607cccf32eea46e6", size = 239026, upload-time = "2025-05-23T11:37:53.846Z" }, + { url = "https://files.pythonhosted.org/packages/8c/0f/47bf7c5630d81bc2cd52b9e13043685dbb7c79372a7f5857279cc442b37c/coverage-7.8.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:546e537d9e24efc765c9c891328f30f826e3e4808e31f5d0f87c4ba12bbd1622", size = 240172, upload-time = "2025-05-23T11:37:55.711Z" }, + { url = "https://files.pythonhosted.org/packages/ba/38/af3eb9d36d85abc881f5aaecf8209383dbe0fa4cac2d804c55d05c51cb04/coverage-7.8.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ab9b09a2349f58e73f8ebc06fac546dd623e23b063e5398343c5270072e3201c", size = 240086, upload-time = "2025-05-23T11:37:57.724Z" }, + { url = "https://files.pythonhosted.org/packages/9e/64/c40c27c2573adeba0fe16faf39a8aa57368a1f2148865d6bb24c67eadb41/coverage-7.8.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:fd51355ab8a372d89fb0e6a31719e825cf8df8b6724bee942fb5b92c3f016ba3", size = 238792, upload-time = "2025-05-23T11:37:59.737Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ab/b7c85146f15457671c1412afca7c25a5696d7625e7158002aa017e2d7e3c/coverage-7.8.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0774df1e093acb6c9e4d58bce7f86656aeed6c132a16e2337692c12786b32404", size = 239096, upload-time = "2025-05-23T11:38:01.693Z" }, + { url = "https://files.pythonhosted.org/packages/d3/50/9446dad1310905fb1dc284d60d4320a5b25d4e3e33f9ea08b8d36e244e23/coverage-7.8.2-cp310-cp310-win32.whl", hash = "sha256:00f2e2f2e37f47e5f54423aeefd6c32a7dbcedc033fcd3928a4f4948e8b96af7", size = 214144, upload-time = "2025-05-23T11:38:03.68Z" }, + { url = "https://files.pythonhosted.org/packages/23/ed/792e66ad7b8b0df757db8d47af0c23659cdb5a65ef7ace8b111cacdbee89/coverage-7.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:145b07bea229821d51811bf15eeab346c236d523838eda395ea969d120d13347", size = 215043, upload-time = "2025-05-23T11:38:05.217Z" }, + { url = "https://files.pythonhosted.org/packages/6a/4d/1ff618ee9f134d0de5cc1661582c21a65e06823f41caf801aadf18811a8e/coverage-7.8.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b99058eef42e6a8dcd135afb068b3d53aff3921ce699e127602efff9956457a9", size = 211692, upload-time = "2025-05-23T11:38:08.485Z" }, + { url = "https://files.pythonhosted.org/packages/96/fa/c3c1b476de96f2bc7a8ca01a9f1fcb51c01c6b60a9d2c3e66194b2bdb4af/coverage-7.8.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5feb7f2c3e6ea94d3b877def0270dff0947b8d8c04cfa34a17be0a4dc1836879", size = 212115, upload-time = "2025-05-23T11:38:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/f7/c2/5414c5a1b286c0f3881ae5adb49be1854ac5b7e99011501f81c8c1453065/coverage-7.8.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:670a13249b957bb9050fab12d86acef7bf8f6a879b9d1a883799276e0d4c674a", size = 244740, upload-time = "2025-05-23T11:38:11.947Z" }, + { url = "https://files.pythonhosted.org/packages/cd/46/1ae01912dfb06a642ef3dd9cf38ed4996fda8fe884dab8952da616f81a2b/coverage-7.8.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0bdc8bf760459a4a4187b452213e04d039990211f98644c7292adf1e471162b5", size = 242429, upload-time = "2025-05-23T11:38:13.955Z" }, + { url = "https://files.pythonhosted.org/packages/06/58/38c676aec594bfe2a87c7683942e5a30224791d8df99bcc8439fde140377/coverage-7.8.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07a989c867986c2a75f158f03fdb413128aad29aca9d4dbce5fc755672d96f11", size = 244218, upload-time = "2025-05-23T11:38:15.631Z" }, + { url = "https://files.pythonhosted.org/packages/80/0c/95b1023e881ce45006d9abc250f76c6cdab7134a1c182d9713878dfefcb2/coverage-7.8.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2db10dedeb619a771ef0e2949ccba7b75e33905de959c2643a4607bef2f3fb3a", size = 243865, upload-time = "2025-05-23T11:38:17.622Z" }, + { url = "https://files.pythonhosted.org/packages/57/37/0ae95989285a39e0839c959fe854a3ae46c06610439350d1ab860bf020ac/coverage-7.8.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e6ea7dba4e92926b7b5f0990634b78ea02f208d04af520c73a7c876d5a8d36cb", size = 242038, upload-time = "2025-05-23T11:38:19.966Z" }, + { url = "https://files.pythonhosted.org/packages/4d/82/40e55f7c0eb5e97cc62cbd9d0746fd24e8caf57be5a408b87529416e0c70/coverage-7.8.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ef2f22795a7aca99fc3c84393a55a53dd18ab8c93fb431004e4d8f0774150f54", size = 242567, upload-time = "2025-05-23T11:38:21.912Z" }, + { url = "https://files.pythonhosted.org/packages/f9/35/66a51adc273433a253989f0d9cc7aa6bcdb4855382cf0858200afe578861/coverage-7.8.2-cp311-cp311-win32.whl", hash = "sha256:641988828bc18a6368fe72355df5f1703e44411adbe49bba5644b941ce6f2e3a", size = 214194, upload-time = "2025-05-23T11:38:23.571Z" }, + { url = "https://files.pythonhosted.org/packages/f6/8f/a543121f9f5f150eae092b08428cb4e6b6d2d134152c3357b77659d2a605/coverage-7.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:8ab4a51cb39dc1933ba627e0875046d150e88478dbe22ce145a68393e9652975", size = 215109, upload-time = "2025-05-23T11:38:25.137Z" }, + { url = "https://files.pythonhosted.org/packages/77/65/6cc84b68d4f35186463cd7ab1da1169e9abb59870c0f6a57ea6aba95f861/coverage-7.8.2-cp311-cp311-win_arm64.whl", hash = "sha256:8966a821e2083c74d88cca5b7dcccc0a3a888a596a04c0b9668a891de3a0cc53", size = 213521, upload-time = "2025-05-23T11:38:27.123Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2a/1da1ada2e3044fcd4a3254fb3576e160b8fe5b36d705c8a31f793423f763/coverage-7.8.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e2f6fe3654468d061942591aef56686131335b7a8325684eda85dacdf311356c", size = 211876, upload-time = "2025-05-23T11:38:29.01Z" }, + { url = "https://files.pythonhosted.org/packages/70/e9/3d715ffd5b6b17a8be80cd14a8917a002530a99943cc1939ad5bb2aa74b9/coverage-7.8.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:76090fab50610798cc05241bf83b603477c40ee87acd358b66196ab0ca44ffa1", size = 212130, upload-time = "2025-05-23T11:38:30.675Z" }, + { url = "https://files.pythonhosted.org/packages/a0/02/fdce62bb3c21649abfd91fbdcf041fb99be0d728ff00f3f9d54d97ed683e/coverage-7.8.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bd0a0a5054be160777a7920b731a0570284db5142abaaf81bcbb282b8d99279", size = 246176, upload-time = "2025-05-23T11:38:32.395Z" }, + { url = "https://files.pythonhosted.org/packages/a7/52/decbbed61e03b6ffe85cd0fea360a5e04a5a98a7423f292aae62423b8557/coverage-7.8.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da23ce9a3d356d0affe9c7036030b5c8f14556bd970c9b224f9c8205505e3b99", size = 243068, upload-time = "2025-05-23T11:38:33.989Z" }, + { url = "https://files.pythonhosted.org/packages/38/6c/d0e9c0cce18faef79a52778219a3c6ee8e336437da8eddd4ab3dbd8fadff/coverage-7.8.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9392773cffeb8d7e042a7b15b82a414011e9d2b5fdbbd3f7e6a6b17d5e21b20", size = 245328, upload-time = "2025-05-23T11:38:35.568Z" }, + { url = "https://files.pythonhosted.org/packages/f0/70/f703b553a2f6b6c70568c7e398ed0789d47f953d67fbba36a327714a7bca/coverage-7.8.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:876cbfd0b09ce09d81585d266c07a32657beb3eaec896f39484b631555be0fe2", size = 245099, upload-time = "2025-05-23T11:38:37.627Z" }, + { url = "https://files.pythonhosted.org/packages/ec/fb/4cbb370dedae78460c3aacbdad9d249e853f3bc4ce5ff0e02b1983d03044/coverage-7.8.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3da9b771c98977a13fbc3830f6caa85cae6c9c83911d24cb2d218e9394259c57", size = 243314, upload-time = "2025-05-23T11:38:39.238Z" }, + { url = "https://files.pythonhosted.org/packages/39/9f/1afbb2cb9c8699b8bc38afdce00a3b4644904e6a38c7bf9005386c9305ec/coverage-7.8.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a990f6510b3292686713bfef26d0049cd63b9c7bb17e0864f133cbfd2e6167f", size = 244489, upload-time = "2025-05-23T11:38:40.845Z" }, + { url = "https://files.pythonhosted.org/packages/79/fa/f3e7ec7d220bff14aba7a4786ae47043770cbdceeea1803083059c878837/coverage-7.8.2-cp312-cp312-win32.whl", hash = "sha256:bf8111cddd0f2b54d34e96613e7fbdd59a673f0cf5574b61134ae75b6f5a33b8", size = 214366, upload-time = "2025-05-23T11:38:43.551Z" }, + { url = "https://files.pythonhosted.org/packages/54/aa/9cbeade19b7e8e853e7ffc261df885d66bf3a782c71cba06c17df271f9e6/coverage-7.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:86a323a275e9e44cdf228af9b71c5030861d4d2610886ab920d9945672a81223", size = 215165, upload-time = "2025-05-23T11:38:45.148Z" }, + { url = "https://files.pythonhosted.org/packages/c4/73/e2528bf1237d2448f882bbebaec5c3500ef07301816c5c63464b9da4d88a/coverage-7.8.2-cp312-cp312-win_arm64.whl", hash = "sha256:820157de3a589e992689ffcda8639fbabb313b323d26388d02e154164c57b07f", size = 213548, upload-time = "2025-05-23T11:38:46.74Z" }, + { url = "https://files.pythonhosted.org/packages/1a/93/eb6400a745ad3b265bac36e8077fdffcf0268bdbbb6c02b7220b624c9b31/coverage-7.8.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ea561010914ec1c26ab4188aef8b1567272ef6de096312716f90e5baa79ef8ca", size = 211898, upload-time = "2025-05-23T11:38:49.066Z" }, + { url = "https://files.pythonhosted.org/packages/1b/7c/bdbf113f92683024406a1cd226a199e4200a2001fc85d6a6e7e299e60253/coverage-7.8.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cb86337a4fcdd0e598ff2caeb513ac604d2f3da6d53df2c8e368e07ee38e277d", size = 212171, upload-time = "2025-05-23T11:38:51.207Z" }, + { url = "https://files.pythonhosted.org/packages/91/22/594513f9541a6b88eb0dba4d5da7d71596dadef6b17a12dc2c0e859818a9/coverage-7.8.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26a4636ddb666971345541b59899e969f3b301143dd86b0ddbb570bd591f1e85", size = 245564, upload-time = "2025-05-23T11:38:52.857Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f4/2860fd6abeebd9f2efcfe0fd376226938f22afc80c1943f363cd3c28421f/coverage-7.8.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5040536cf9b13fb033f76bcb5e1e5cb3b57c4807fef37db9e0ed129c6a094257", size = 242719, upload-time = "2025-05-23T11:38:54.529Z" }, + { url = "https://files.pythonhosted.org/packages/89/60/f5f50f61b6332451520e6cdc2401700c48310c64bc2dd34027a47d6ab4ca/coverage-7.8.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc67994df9bcd7e0150a47ef41278b9e0a0ea187caba72414b71dc590b99a108", size = 244634, upload-time = "2025-05-23T11:38:57.326Z" }, + { url = "https://files.pythonhosted.org/packages/3b/70/7f4e919039ab7d944276c446b603eea84da29ebcf20984fb1fdf6e602028/coverage-7.8.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6e6c86888fd076d9e0fe848af0a2142bf606044dc5ceee0aa9eddb56e26895a0", size = 244824, upload-time = "2025-05-23T11:38:59.421Z" }, + { url = "https://files.pythonhosted.org/packages/26/45/36297a4c0cea4de2b2c442fe32f60c3991056c59cdc3cdd5346fbb995c97/coverage-7.8.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:684ca9f58119b8e26bef860db33524ae0365601492e86ba0b71d513f525e7050", size = 242872, upload-time = "2025-05-23T11:39:01.049Z" }, + { url = "https://files.pythonhosted.org/packages/a4/71/e041f1b9420f7b786b1367fa2a375703889ef376e0d48de9f5723fb35f11/coverage-7.8.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8165584ddedb49204c4e18da083913bdf6a982bfb558632a79bdaadcdafd0d48", size = 244179, upload-time = "2025-05-23T11:39:02.709Z" }, + { url = "https://files.pythonhosted.org/packages/bd/db/3c2bf49bdc9de76acf2491fc03130c4ffc51469ce2f6889d2640eb563d77/coverage-7.8.2-cp313-cp313-win32.whl", hash = "sha256:34759ee2c65362163699cc917bdb2a54114dd06d19bab860725f94ef45a3d9b7", size = 214393, upload-time = "2025-05-23T11:39:05.457Z" }, + { url = "https://files.pythonhosted.org/packages/c6/dc/947e75d47ebbb4b02d8babb1fad4ad381410d5bc9da7cfca80b7565ef401/coverage-7.8.2-cp313-cp313-win_amd64.whl", hash = "sha256:2f9bc608fbafaee40eb60a9a53dbfb90f53cc66d3d32c2849dc27cf5638a21e3", size = 215194, upload-time = "2025-05-23T11:39:07.171Z" }, + { url = "https://files.pythonhosted.org/packages/90/31/a980f7df8a37eaf0dc60f932507fda9656b3a03f0abf188474a0ea188d6d/coverage-7.8.2-cp313-cp313-win_arm64.whl", hash = "sha256:9fe449ee461a3b0c7105690419d0b0aba1232f4ff6d120a9e241e58a556733f7", size = 213580, upload-time = "2025-05-23T11:39:08.862Z" }, + { url = "https://files.pythonhosted.org/packages/8a/6a/25a37dd90f6c95f59355629417ebcb74e1c34e38bb1eddf6ca9b38b0fc53/coverage-7.8.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8369a7c8ef66bded2b6484053749ff220dbf83cba84f3398c84c51a6f748a008", size = 212734, upload-time = "2025-05-23T11:39:11.109Z" }, + { url = "https://files.pythonhosted.org/packages/36/8b/3a728b3118988725f40950931abb09cd7f43b3c740f4640a59f1db60e372/coverage-7.8.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:159b81df53a5fcbc7d45dae3adad554fdbde9829a994e15227b3f9d816d00b36", size = 212959, upload-time = "2025-05-23T11:39:12.751Z" }, + { url = "https://files.pythonhosted.org/packages/53/3c/212d94e6add3a3c3f412d664aee452045ca17a066def8b9421673e9482c4/coverage-7.8.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e6fcbbd35a96192d042c691c9e0c49ef54bd7ed865846a3c9d624c30bb67ce46", size = 257024, upload-time = "2025-05-23T11:39:15.569Z" }, + { url = "https://files.pythonhosted.org/packages/a4/40/afc03f0883b1e51bbe804707aae62e29c4e8c8bbc365c75e3e4ddeee9ead/coverage-7.8.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05364b9cc82f138cc86128dc4e2e1251c2981a2218bfcd556fe6b0fbaa3501be", size = 252867, upload-time = "2025-05-23T11:39:17.64Z" }, + { url = "https://files.pythonhosted.org/packages/18/a2/3699190e927b9439c6ded4998941a3c1d6fa99e14cb28d8536729537e307/coverage-7.8.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46d532db4e5ff3979ce47d18e2fe8ecad283eeb7367726da0e5ef88e4fe64740", size = 255096, upload-time = "2025-05-23T11:39:19.328Z" }, + { url = "https://files.pythonhosted.org/packages/b4/06/16e3598b9466456b718eb3e789457d1a5b8bfb22e23b6e8bbc307df5daf0/coverage-7.8.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4000a31c34932e7e4fa0381a3d6deb43dc0c8f458e3e7ea6502e6238e10be625", size = 256276, upload-time = "2025-05-23T11:39:21.077Z" }, + { url = "https://files.pythonhosted.org/packages/a7/d5/4b5a120d5d0223050a53d2783c049c311eea1709fa9de12d1c358e18b707/coverage-7.8.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:43ff5033d657cd51f83015c3b7a443287250dc14e69910577c3e03bd2e06f27b", size = 254478, upload-time = "2025-05-23T11:39:22.838Z" }, + { url = "https://files.pythonhosted.org/packages/ba/85/f9ecdb910ecdb282b121bfcaa32fa8ee8cbd7699f83330ee13ff9bbf1a85/coverage-7.8.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:94316e13f0981cbbba132c1f9f365cac1d26716aaac130866ca812006f662199", size = 255255, upload-time = "2025-05-23T11:39:24.644Z" }, + { url = "https://files.pythonhosted.org/packages/50/63/2d624ac7d7ccd4ebbd3c6a9eba9d7fc4491a1226071360d59dd84928ccb2/coverage-7.8.2-cp313-cp313t-win32.whl", hash = "sha256:3f5673888d3676d0a745c3d0e16da338c5eea300cb1f4ada9c872981265e76d8", size = 215109, upload-time = "2025-05-23T11:39:26.722Z" }, + { url = "https://files.pythonhosted.org/packages/22/5e/7053b71462e970e869111c1853afd642212568a350eba796deefdfbd0770/coverage-7.8.2-cp313-cp313t-win_amd64.whl", hash = "sha256:2c08b05ee8d7861e45dc5a2cc4195c8c66dca5ac613144eb6ebeaff2d502e73d", size = 216268, upload-time = "2025-05-23T11:39:28.429Z" }, + { url = "https://files.pythonhosted.org/packages/07/69/afa41aa34147655543dbe96994f8a246daf94b361ccf5edfd5df62ce066a/coverage-7.8.2-cp313-cp313t-win_arm64.whl", hash = "sha256:1e1448bb72b387755e1ff3ef1268a06617afd94188164960dba8d0245a46004b", size = 214071, upload-time = "2025-05-23T11:39:30.55Z" }, + { url = "https://files.pythonhosted.org/packages/69/2f/572b29496d8234e4a7773200dd835a0d32d9e171f2d974f3fe04a9dbc271/coverage-7.8.2-pp39.pp310.pp311-none-any.whl", hash = "sha256:ec455eedf3ba0bbdf8f5a570012617eb305c63cb9f03428d39bf544cb2b94837", size = 203636, upload-time = "2025-05-23T11:39:52.002Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1a/0b9c32220ad694d66062f571cc5cedfa9997b64a591e8a500bb63de1bd40/coverage-7.8.2-py3-none-any.whl", hash = "sha256:726f32ee3713f7359696331a18daf0c3b3a70bb0ae71141b9d3c52be7c595e32", size = 203623, upload-time = "2025-05-23T11:39:53.846Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bd/75/087fe07d40f490a78782ff3b0a30e3968936854105487decdb33446d4b0e/debugpy-1.8.14.tar.gz", hash = "sha256:7cd287184318416850aa8b60ac90105837bb1e59531898c07569d197d2ed5322", size = 1641444, upload-time = "2025-04-10T19:46:10.981Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/df/156df75a41aaebd97cee9d3870fe68f8001b6c1c4ca023e221cfce69bece/debugpy-1.8.14-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:93fee753097e85623cab1c0e6a68c76308cd9f13ffdf44127e6fab4fbf024339", size = 2076510, upload-time = "2025-04-10T19:46:13.315Z" }, + { url = "https://files.pythonhosted.org/packages/69/cd/4fc391607bca0996db5f3658762106e3d2427beaef9bfd363fd370a3c054/debugpy-1.8.14-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d937d93ae4fa51cdc94d3e865f535f185d5f9748efb41d0d49e33bf3365bd79", size = 3559614, upload-time = "2025-04-10T19:46:14.647Z" }, + { url = "https://files.pythonhosted.org/packages/1a/42/4e6d2b9d63e002db79edfd0cb5656f1c403958915e0e73ab3e9220012eec/debugpy-1.8.14-cp310-cp310-win32.whl", hash = "sha256:c442f20577b38cc7a9aafecffe1094f78f07fb8423c3dddb384e6b8f49fd2987", size = 5208588, upload-time = "2025-04-10T19:46:16.233Z" }, + { url = "https://files.pythonhosted.org/packages/97/b1/cc9e4e5faadc9d00df1a64a3c2d5c5f4b9df28196c39ada06361c5141f89/debugpy-1.8.14-cp310-cp310-win_amd64.whl", hash = "sha256:f117dedda6d969c5c9483e23f573b38f4e39412845c7bc487b6f2648df30fe84", size = 5241043, upload-time = "2025-04-10T19:46:17.768Z" }, + { url = "https://files.pythonhosted.org/packages/67/e8/57fe0c86915671fd6a3d2d8746e40485fd55e8d9e682388fbb3a3d42b86f/debugpy-1.8.14-cp311-cp311-macosx_14_0_universal2.whl", hash = "sha256:1b2ac8c13b2645e0b1eaf30e816404990fbdb168e193322be8f545e8c01644a9", size = 2175064, upload-time = "2025-04-10T19:46:19.486Z" }, + { url = "https://files.pythonhosted.org/packages/3b/97/2b2fd1b1c9569c6764ccdb650a6f752e4ac31be465049563c9eb127a8487/debugpy-1.8.14-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf431c343a99384ac7eab2f763980724834f933a271e90496944195318c619e2", size = 3132359, upload-time = "2025-04-10T19:46:21.192Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ee/b825c87ed06256ee2a7ed8bab8fb3bb5851293bf9465409fdffc6261c426/debugpy-1.8.14-cp311-cp311-win32.whl", hash = "sha256:c99295c76161ad8d507b413cd33422d7c542889fbb73035889420ac1fad354f2", size = 5133269, upload-time = "2025-04-10T19:46:23.047Z" }, + { url = "https://files.pythonhosted.org/packages/d5/a6/6c70cd15afa43d37839d60f324213843174c1d1e6bb616bd89f7c1341bac/debugpy-1.8.14-cp311-cp311-win_amd64.whl", hash = "sha256:7816acea4a46d7e4e50ad8d09d963a680ecc814ae31cdef3622eb05ccacf7b01", size = 5158156, upload-time = "2025-04-10T19:46:24.521Z" }, + { url = "https://files.pythonhosted.org/packages/d9/2a/ac2df0eda4898f29c46eb6713a5148e6f8b2b389c8ec9e425a4a1d67bf07/debugpy-1.8.14-cp312-cp312-macosx_14_0_universal2.whl", hash = "sha256:8899c17920d089cfa23e6005ad9f22582fd86f144b23acb9feeda59e84405b84", size = 2501268, upload-time = "2025-04-10T19:46:26.044Z" }, + { url = "https://files.pythonhosted.org/packages/10/53/0a0cb5d79dd9f7039169f8bf94a144ad3efa52cc519940b3b7dde23bcb89/debugpy-1.8.14-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6bb5c0dcf80ad5dbc7b7d6eac484e2af34bdacdf81df09b6a3e62792b722826", size = 4221077, upload-time = "2025-04-10T19:46:27.464Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d5/84e01821f362327bf4828728aa31e907a2eca7c78cd7c6ec062780d249f8/debugpy-1.8.14-cp312-cp312-win32.whl", hash = "sha256:281d44d248a0e1791ad0eafdbbd2912ff0de9eec48022a5bfbc332957487ed3f", size = 5255127, upload-time = "2025-04-10T19:46:29.467Z" }, + { url = "https://files.pythonhosted.org/packages/33/16/1ed929d812c758295cac7f9cf3dab5c73439c83d9091f2d91871e648093e/debugpy-1.8.14-cp312-cp312-win_amd64.whl", hash = "sha256:5aa56ef8538893e4502a7d79047fe39b1dae08d9ae257074c6464a7b290b806f", size = 5297249, upload-time = "2025-04-10T19:46:31.538Z" }, + { url = "https://files.pythonhosted.org/packages/4d/e4/395c792b243f2367d84202dc33689aa3d910fb9826a7491ba20fc9e261f5/debugpy-1.8.14-cp313-cp313-macosx_14_0_universal2.whl", hash = "sha256:329a15d0660ee09fec6786acdb6e0443d595f64f5d096fc3e3ccf09a4259033f", size = 2485676, upload-time = "2025-04-10T19:46:32.96Z" }, + { url = "https://files.pythonhosted.org/packages/ba/f1/6f2ee3f991327ad9e4c2f8b82611a467052a0fb0e247390192580e89f7ff/debugpy-1.8.14-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f920c7f9af409d90f5fd26e313e119d908b0dd2952c2393cd3247a462331f15", size = 4217514, upload-time = "2025-04-10T19:46:34.336Z" }, + { url = "https://files.pythonhosted.org/packages/79/28/b9d146f8f2dc535c236ee09ad3e5ac899adb39d7a19b49f03ac95d216beb/debugpy-1.8.14-cp313-cp313-win32.whl", hash = "sha256:3784ec6e8600c66cbdd4ca2726c72d8ca781e94bce2f396cc606d458146f8f4e", size = 5254756, upload-time = "2025-04-10T19:46:36.199Z" }, + { url = "https://files.pythonhosted.org/packages/e0/62/a7b4a57013eac4ccaef6977966e6bec5c63906dd25a86e35f155952e29a1/debugpy-1.8.14-cp313-cp313-win_amd64.whl", hash = "sha256:684eaf43c95a3ec39a96f1f5195a7ff3d4144e4a18d69bb66beeb1a6de605d6e", size = 5297119, upload-time = "2025-04-10T19:46:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/97/1a/481f33c37ee3ac8040d3d51fc4c4e4e7e61cb08b8bc8971d6032acc2279f/debugpy-1.8.14-py2.py3-none-any.whl", hash = "sha256:5cd9a579d553b6cb9759a7908a41988ee6280b961f24f63336835d9418216a20", size = 5256230, upload-time = "2025-04-10T19:46:54.077Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0b/9f/a65090624ecf468cdca03533906e7c69ed7588582240cfe7cc9e770b50eb/exceptiongroup-1.3.0.tar.gz", hash = "sha256:b241f5885f560bc56a59ee63ca4c6a8bfa46ae4ad651af316d4e81817bb9fd88", size = 29749, upload-time = "2025-05-10T17:42:51.123Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/36/f4/c6e662dade71f56cd2f3735141b265c3c79293c109549c1e6933b0651ffc/exceptiongroup-1.3.0-py3-none-any.whl", hash = "sha256:4d111e6e0c13d0644cad6ddaa7ed0261a0b36971f6d23e7ec9b4b9097da78a10", size = 16674, upload-time = "2025-05-10T17:42:49.33Z" }, +] + +[[package]] +name = "executing" +version = "2.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693, upload-time = "2025-01-22T15:41:29.403Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702, upload-time = "2025-01-22T15:41:25.929Z" }, +] + +[[package]] +name = "fonttools" +version = "4.58.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/a9/3319c6ae07fd9dde51064ddc6d82a2b707efad8ed407d700a01091121bbc/fonttools-4.58.2.tar.gz", hash = "sha256:4b491ddbfd50b856e84b0648b5f7941af918f6d32f938f18e62b58426a8d50e2", size = 3524285, upload-time = "2025-06-06T14:50:58.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d3/6f/1f0158cd9d6168258362369fa003c58fc36f2b141a66bc805c76f28f57cc/fonttools-4.58.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4baaf34f07013ba9c2c3d7a95d0c391fcbb30748cb86c36c094fab8f168e49bb", size = 2735491, upload-time = "2025-06-06T14:49:33.45Z" }, + { url = "https://files.pythonhosted.org/packages/3d/94/d9a36a4ae1ed257ed5117c0905635e89327428cbf3521387c13bd85e6de1/fonttools-4.58.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2e26e4a4920d57f04bb2c3b6e9a68b099c7ef2d70881d4fee527896fa4f7b5aa", size = 2307732, upload-time = "2025-06-06T14:49:36.612Z" }, + { url = "https://files.pythonhosted.org/packages/37/57/0f72a9fe7c051ce316779b8721c707413c53ae75ab00f970d74c7876388f/fonttools-4.58.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c0bb956d9d01ea51368415515f664f58abf96557ba3c1aae4e26948ae7c86f29", size = 4718769, upload-time = "2025-06-06T14:49:39.597Z" }, + { url = "https://files.pythonhosted.org/packages/35/dd/8be06b93e24214d7dc52fd8183dbb9e75ab9638940d84d92ced25669f4d8/fonttools-4.58.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d40af8493c80ec17a1133ef429d42f1a97258dd9213b917daae9d8cafa6e0e6c", size = 4751963, upload-time = "2025-06-06T14:49:41.391Z" }, + { url = "https://files.pythonhosted.org/packages/9e/d3/85d60be364cea1b61f47bc8ea82d3e24cd6fb08640ad783fd2494bcaf4e0/fonttools-4.58.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:60b5cde1c76f6ded198da5608dddb1ee197faad7d2f0f6d3348ca0cda0c756c4", size = 4801368, upload-time = "2025-06-06T14:49:44.663Z" }, + { url = "https://files.pythonhosted.org/packages/9f/b9/98abf9c9c1ed67eed263f091fa1bbf0ea32ef65bb8f707c2ee106b877496/fonttools-4.58.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f8df6dc80ecc9033ca25a944ee5db7564fecca28e96383043fd92d9df861a159", size = 4909670, upload-time = "2025-06-06T14:49:46.751Z" }, + { url = "https://files.pythonhosted.org/packages/32/23/d8676da27a1a27cca89549f50b4a22c98e305d9ee4c67357515d9cb25ec4/fonttools-4.58.2-cp310-cp310-win32.whl", hash = "sha256:25728e980f5fbb67f52c5311b90fae4aaec08c3d3b78dce78ab564784df1129c", size = 2191921, upload-time = "2025-06-06T14:49:48.523Z" }, + { url = "https://files.pythonhosted.org/packages/0b/ff/ed6452dde8fd04299ec840a4fb112597a40468106039aed9abc8e35ba7eb/fonttools-4.58.2-cp310-cp310-win_amd64.whl", hash = "sha256:d6997ee7c2909a904802faf44b0d0208797c4d751f7611836011ace165308165", size = 2236374, upload-time = "2025-06-06T14:49:50.759Z" }, + { url = "https://files.pythonhosted.org/packages/63/d0/335d12ee943b8d67847864bba98478fedf3503d8b168eeeefadd8660256a/fonttools-4.58.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:024faaf20811296fd2f83ebdac7682276362e726ed5fea4062480dd36aff2fd9", size = 2755885, upload-time = "2025-06-06T14:49:52.459Z" }, + { url = "https://files.pythonhosted.org/packages/66/c2/d8ceb8b91e3847786a19d4b93749b1d804833482b5f79bee35b68327609e/fonttools-4.58.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2faec6e7f2abd80cd9f2392dfa28c02cfd5b1125be966ea6eddd6ca684deaa40", size = 2317804, upload-time = "2025-06-06T14:49:54.581Z" }, + { url = "https://files.pythonhosted.org/packages/7c/93/865c8d50b3a1f50ebdc02227f28bb81817df88cee75bc6f2652469e754b1/fonttools-4.58.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:520792629a938c14dd7fe185794b156cfc159c609d07b31bbb5f51af8dc7918a", size = 4916900, upload-time = "2025-06-06T14:49:56.366Z" }, + { url = "https://files.pythonhosted.org/packages/60/d1/301aec4f02995958b7af6728f838b2e5cc9296bec7eae350722dec31f685/fonttools-4.58.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:12fbc6e0bf0c75ce475ef170f2c065be6abc9e06ad19a13b56b02ec2acf02427", size = 4937358, upload-time = "2025-06-06T14:49:58.392Z" }, + { url = "https://files.pythonhosted.org/packages/15/22/75dc23a4c7200b8feb90baa82c518684a601a3a03be25f7cc3dde1525e37/fonttools-4.58.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:44a39cf856d52109127d55576c7ec010206a8ba510161a7705021f70d1649831", size = 4980151, upload-time = "2025-06-06T14:50:00.778Z" }, + { url = "https://files.pythonhosted.org/packages/14/51/5d402f65c4b0c89ce0cdbffe86646f3996da209f7bc93f1f4a13a7211ee0/fonttools-4.58.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5390a67c55a835ad5a420da15b3d88b75412cbbd74450cb78c4916b0bd7f0a34", size = 5091255, upload-time = "2025-06-06T14:50:02.588Z" }, + { url = "https://files.pythonhosted.org/packages/c7/5e/dee28700276129db1a0ee8ab0d5574d255a1d72df7f6df58a9d26ddef687/fonttools-4.58.2-cp311-cp311-win32.whl", hash = "sha256:f7e10f4e7160bcf6a240d7560e9e299e8cb585baed96f6a616cef51180bf56cb", size = 2190095, upload-time = "2025-06-06T14:50:04.932Z" }, + { url = "https://files.pythonhosted.org/packages/bd/60/b90fda549942808b68c1c5bada4b369f4f55d4c28a7012f7537670438f82/fonttools-4.58.2-cp311-cp311-win_amd64.whl", hash = "sha256:29bdf52bfafdae362570d3f0d3119a3b10982e1ef8cb3a9d3ebb72da81cb8d5e", size = 2238013, upload-time = "2025-06-06T14:50:06.605Z" }, + { url = "https://files.pythonhosted.org/packages/eb/68/7ec64584dc592faf944d540307c3562cd893256c48bb028c90de489e4750/fonttools-4.58.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:c6eeaed9c54c1d33c1db928eb92b4e180c7cb93b50b1ee3e79b2395cb01f25e9", size = 2741645, upload-time = "2025-06-06T14:50:08.706Z" }, + { url = "https://files.pythonhosted.org/packages/8f/0c/b327838f63baa7ebdd6db3ffdf5aff638e883f9236d928be4f32c692e1bd/fonttools-4.58.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bbe1d9c72b7f981bed5c2a61443d5e3127c1b3aca28ca76386d1ad93268a803f", size = 2311100, upload-time = "2025-06-06T14:50:10.401Z" }, + { url = "https://files.pythonhosted.org/packages/ae/c7/dec024a1c873c79a4db98fe0104755fa62ec2b4518e09d6fda28246c3c9b/fonttools-4.58.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:85babe5b3ce2cbe57fc0d09c0ee92bbd4d594fd7ea46a65eb43510a74a4ce773", size = 4815841, upload-time = "2025-06-06T14:50:12.496Z" }, + { url = "https://files.pythonhosted.org/packages/94/33/57c81abad641d6ec9c8b06c99cd28d687cb4849efb6168625b5c6b8f9fa4/fonttools-4.58.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:918a2854537fcdc662938057ad58b633bc9e0698f04a2f4894258213283a7932", size = 4882659, upload-time = "2025-06-06T14:50:14.361Z" }, + { url = "https://files.pythonhosted.org/packages/a5/37/2f8faa2bf8bd1ba016ea86a94c72a5e8ef8ea1c52ec64dada617191f0515/fonttools-4.58.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b379cf05bf776c336a0205632596b1c7d7ab5f7135e3935f2ca2a0596d2d092", size = 4876128, upload-time = "2025-06-06T14:50:16.653Z" }, + { url = "https://files.pythonhosted.org/packages/a0/ca/f1caac24ae7028a33f2a95e66c640571ff0ce5cb06c4c9ca1f632e98e22c/fonttools-4.58.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99ab3547a15a5d168c265e139e21756bbae1de04782ac9445c9ef61b8c0a32ce", size = 5027843, upload-time = "2025-06-06T14:50:18.582Z" }, + { url = "https://files.pythonhosted.org/packages/52/6e/3200fa2bafeed748a3017e4e6594751fd50cce544270919265451b21b75c/fonttools-4.58.2-cp312-cp312-win32.whl", hash = "sha256:6764e7a3188ce36eea37b477cdeca602ae62e63ae9fc768ebc176518072deb04", size = 2177374, upload-time = "2025-06-06T14:50:20.454Z" }, + { url = "https://files.pythonhosted.org/packages/55/ab/8f3e726f3f3ef3062ce9bbb615727c55beb11eea96d1f443f79cafca93ee/fonttools-4.58.2-cp312-cp312-win_amd64.whl", hash = "sha256:41f02182a1d41b79bae93c1551855146868b04ec3e7f9c57d6fef41a124e6b29", size = 2226685, upload-time = "2025-06-06T14:50:22.087Z" }, + { url = "https://files.pythonhosted.org/packages/ac/01/29f81970a508408af20b434ff5136cd1c7ef92198957eb8ddadfbb9ef177/fonttools-4.58.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:829048ef29dbefec35d95cc6811014720371c95bdc6ceb0afd2f8e407c41697c", size = 2732398, upload-time = "2025-06-06T14:50:23.821Z" }, + { url = "https://files.pythonhosted.org/packages/0c/f1/095f2338359333adb2f1c51b8b2ad94bf9a2fa17e5fcbdf8a7b8e3672d2d/fonttools-4.58.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:64998c5993431e45b474ed5f579f18555f45309dd1cf8008b594d2fe0a94be59", size = 2306390, upload-time = "2025-06-06T14:50:25.942Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d4/9eba134c7666a26668c28945355cd86e5d57828b6b8d952a5489fe45d7e2/fonttools-4.58.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b887a1cf9fbcb920980460ee4a489c8aba7e81341f6cdaeefa08c0ab6529591c", size = 4795100, upload-time = "2025-06-06T14:50:27.653Z" }, + { url = "https://files.pythonhosted.org/packages/2a/34/345f153a24c1340daa62340c3be2d1e5ee6c1ee57e13f6d15613209e688b/fonttools-4.58.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27d74b9f6970cefbcda33609a3bee1618e5e57176c8b972134c4e22461b9c791", size = 4864585, upload-time = "2025-06-06T14:50:29.915Z" }, + { url = "https://files.pythonhosted.org/packages/01/5f/091979a25c9a6c4ba064716cfdfe9431f78ed6ffba4bd05ae01eee3532e9/fonttools-4.58.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec26784610056a770e15a60f9920cee26ae10d44d1e43271ea652dadf4e7a236", size = 4866191, upload-time = "2025-06-06T14:50:32.188Z" }, + { url = "https://files.pythonhosted.org/packages/9d/09/3944d0ece4a39560918cba37c2e0453a5f826b665a6db0b43abbd9dbe7e1/fonttools-4.58.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ed0a71d57dd427c0fb89febd08cac9b925284d2a8888e982a6c04714b82698d7", size = 5003867, upload-time = "2025-06-06T14:50:34.323Z" }, + { url = "https://files.pythonhosted.org/packages/68/97/190b8f9ba22f8b7d07df2faa9fd7087b453776d0705d3cb5b0cbd89b8ef0/fonttools-4.58.2-cp313-cp313-win32.whl", hash = "sha256:994e362b01460aa863ef0cb41a29880bc1a498c546952df465deff7abf75587a", size = 2175688, upload-time = "2025-06-06T14:50:36.211Z" }, + { url = "https://files.pythonhosted.org/packages/94/ea/0e6d4a39528dbb6e0f908c2ad219975be0a506ed440fddf5453b90f76981/fonttools-4.58.2-cp313-cp313-win_amd64.whl", hash = "sha256:f95dec862d7c395f2d4efe0535d9bdaf1e3811e51b86432fa2a77e73f8195756", size = 2226464, upload-time = "2025-06-06T14:50:38.862Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e5/c1cb8ebabb80be76d4d28995da9416816653f8f572920ab5e3d2e3ac8285/fonttools-4.58.2-py3-none-any.whl", hash = "sha256:84f4b0bcfa046254a65ee7117094b4907e22dc98097a220ef108030eb3c15596", size = 1114597, upload-time = "2025-06-06T14:50:56.619Z" }, +] + +[[package]] +name = "garth" +source = { editable = "." } +dependencies = [ + { name = "pydantic" }, + { name = "requests" }, + { name = "requests-oauthlib" }, +] + +[package.dev-dependencies] +dev = [ + { name = "ipdb" }, + { name = "ipykernel" }, + { name = "ipython", version = "8.37.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "matplotlib" }, + { name = "pandas" }, +] +linting = [ + { name = "mypy" }, + { name = "ruff" }, + { name = "types-requests" }, +] +testing = [ + { name = "coverage" }, + { name = "pytest" }, + { name = "pytest-vcr" }, +] + +[package.metadata] +requires-dist = [ + { name = "pydantic", specifier = ">=1.10.12,<3.0.0" }, + { name = "requests", specifier = ">=2.0.0,<3.0.0" }, + { name = "requests-oauthlib", specifier = ">=1.3.1,<3.0.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "ipdb" }, + { name = "ipykernel" }, + { name = "ipython" }, + { name = "matplotlib" }, + { name = "pandas" }, +] +linting = [ + { name = "mypy" }, + { name = "ruff" }, + { name = "types-requests" }, +] +testing = [ + { name = "coverage" }, + { name = "pytest" }, + { name = "pytest-vcr" }, +] + +[[package]] +name = "idna" +version = "3.10" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/97/ebf4da567aa6827c909642694d71c9fcf53e5b504f2d96afea02718862f3/iniconfig-2.1.0.tar.gz", hash = "sha256:3abbd2e30b36733fee78f9c7f7308f2d0050e88f0087fd25c2645f63c773e1c7", size = 4793, upload-time = "2025-03-19T20:09:59.721Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2c/e1/e6716421ea10d38022b952c159d5161ca1193197fb744506875fbb87ea7b/iniconfig-2.1.0-py3-none-any.whl", hash = "sha256:9deba5723312380e77435581c6bf4935c94cbfab9b1ed33ef8d238ea168eb760", size = 6050, upload-time = "2025-03-19T20:10:01.071Z" }, +] + +[[package]] +name = "ipdb" +version = "0.13.13" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "decorator" }, + { name = "ipython", version = "8.37.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3d/1b/7e07e7b752017f7693a0f4d41c13e5ca29ce8cbcfdcc1fd6c4ad8c0a27a0/ipdb-0.13.13.tar.gz", hash = "sha256:e3ac6018ef05126d442af680aad863006ec19d02290561ac88b8b1c0b0cfc726", size = 17042, upload-time = "2023-03-09T15:40:57.487Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/4c/b075da0092003d9a55cf2ecc1cae9384a1ca4f650d51b00fc59875fe76f6/ipdb-0.13.13-py3-none-any.whl", hash = "sha256:45529994741c4ab6d2388bfa5d7b725c2cf7fe9deffabdb8a6113aa5ed449ed4", size = 12130, upload-time = "2023-03-09T15:40:55.021Z" }, +] + +[[package]] +name = "ipykernel" +version = "6.29.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython", version = "8.37.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e9/5c/67594cb0c7055dc50814b21731c22a601101ea3b1b50a9a1b090e11f5d0f/ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215", size = 163367, upload-time = "2024-07-01T14:07:22.543Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/5c/368ae6c01c7628438358e6d337c19b05425727fbb221d2a3c4303c372f42/ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5", size = 117173, upload-time = "2024-07-01T14:07:19.603Z" }, +] + +[[package]] +name = "ipython" +version = "8.37.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_python_implementation != 'PyPy'", + "python_full_version < '3.11' and platform_python_implementation == 'PyPy'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version < '3.11' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version < '3.11'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "jedi", marker = "python_full_version < '3.11'" }, + { name = "matplotlib-inline", marker = "python_full_version < '3.11'" }, + { name = "pexpect", marker = "python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version < '3.11'" }, + { name = "pygments", marker = "python_full_version < '3.11'" }, + { name = "stack-data", marker = "python_full_version < '3.11'" }, + { name = "traitlets", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/85/31/10ac88f3357fc276dc8a64e8880c82e80e7459326ae1d0a211b40abf6665/ipython-8.37.0.tar.gz", hash = "sha256:ca815841e1a41a1e6b73a0b08f3038af9b2252564d01fc405356d34033012216", size = 5606088, upload-time = "2025-05-31T16:39:09.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/d0/274fbf7b0b12643cbbc001ce13e6a5b1607ac4929d1b11c72460152c9fc3/ipython-8.37.0-py3-none-any.whl", hash = "sha256:ed87326596b878932dbcb171e3e698845434d8c61b8d8cd474bf663041a9dcf2", size = 831864, upload-time = "2025-05-31T16:39:06.38Z" }, +] + +[[package]] +name = "ipython" +version = "9.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'", + "python_full_version >= '3.12' and platform_python_implementation != 'PyPy'", + "python_full_version == '3.11.*' and platform_python_implementation == 'PyPy'", + "python_full_version == '3.11.*' and platform_python_implementation != 'PyPy'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version >= '3.11'" }, + { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11'" }, + { name = "jedi", marker = "python_full_version >= '3.11'" }, + { name = "matplotlib-inline", marker = "python_full_version >= '3.11'" }, + { name = "pexpect", marker = "python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version >= '3.11'" }, + { name = "pygments", marker = "python_full_version >= '3.11'" }, + { name = "stack-data", marker = "python_full_version >= '3.11'" }, + { name = "traitlets", marker = "python_full_version >= '3.11'" }, + { name = "typing-extensions", marker = "python_full_version == '3.11.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/dc/09/4c7e06b96fbd203e06567b60fb41b06db606b6a82db6db7b2c85bb72a15c/ipython-9.3.0.tar.gz", hash = "sha256:79eb896f9f23f50ad16c3bc205f686f6e030ad246cc309c6279a242b14afe9d8", size = 4426460, upload-time = "2025-05-31T16:34:55.678Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/99/9ed3d52d00f1846679e3aa12e2326ac7044b5e7f90dc822b60115fa533ca/ipython-9.3.0-py3-none-any.whl", hash = "sha256:1a0b6dd9221a1f5dddf725b57ac0cb6fddc7b5f470576231ae9162b9b3455a04", size = 605320, upload-time = "2025-05-31T16:34:52.154Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments", marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/3a/79a912fbd4d8dd6fbb02bf69afd3bb72cf0c729bb3063c6f4498603db17a/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0", size = 1231287, upload-time = "2024-11-11T01:41:42.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/5a/9cac0c82afec3d09ccd97c8b6502d48f165f9124db81b4bcb90b4af974ee/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9", size = 1572278, upload-time = "2024-11-11T01:41:40.175Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/71/22/bf9f12fdaeae18019a468b68952a60fe6dbab5d67cd2a103cac7659b41ca/jupyter_client-8.6.3.tar.gz", hash = "sha256:35b3a0947c4a6e9d589eb97d7d4cd5e90f910ee73101611f01283732bd6d9419", size = 342019, upload-time = "2024-09-17T10:44:17.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/11/85/b0394e0b6fcccd2c1eeefc230978a6f8cb0c5df1e4cd3e7625735a0d7d1e/jupyter_client-8.6.3-py3-none-any.whl", hash = "sha256:e8a19cc986cc45905ac3362915f410f3af85424b4c0905e94fa5f2cb08e8f23f", size = 106105, upload-time = "2024-09-17T10:44:15.218Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.8.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "pywin32", marker = "platform_python_implementation != 'PyPy' and sys_platform == 'win32'" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/1b/72906d554acfeb588332eaaa6f61577705e9ec752ddb486f302dafa292d9/jupyter_core-5.8.1.tar.gz", hash = "sha256:0a5f9706f70e64786b75acba995988915ebd4601c8a52e534a40b51c95f59941", size = 88923, upload-time = "2025-05-27T07:38:16.655Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/57/6bffd4b20b88da3800c5d691e0337761576ee688eb01299eae865689d2df/jupyter_core-5.8.1-py3-none-any.whl", hash = "sha256:c28d268fc90fb53f1338ded2eb410704c5449a358406e8a948b75706e24863d0", size = 28880, upload-time = "2025-05-27T07:38:15.137Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/82/59/7c91426a8ac292e1cdd53a63b6d9439abd573c875c3f92c146767dd33faf/kiwisolver-1.4.8.tar.gz", hash = "sha256:23d5f023bdc8c7e54eb65f03ca5d5bb25b601eac4d7f1a042888a1f45237987e", size = 97538, upload-time = "2024-12-24T18:30:51.519Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/47/5f/4d8e9e852d98ecd26cdf8eaf7ed8bc33174033bba5e07001b289f07308fd/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:88c6f252f6816a73b1f8c904f7bbe02fd67c09a69f7cb8a0eecdbf5ce78e63db", size = 124623, upload-time = "2024-12-24T18:28:17.687Z" }, + { url = "https://files.pythonhosted.org/packages/1d/70/7f5af2a18a76fe92ea14675f8bd88ce53ee79e37900fa5f1a1d8e0b42998/kiwisolver-1.4.8-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c72941acb7b67138f35b879bbe85be0f6c6a70cab78fe3ef6db9c024d9223e5b", size = 66720, upload-time = "2024-12-24T18:28:19.158Z" }, + { url = "https://files.pythonhosted.org/packages/c6/13/e15f804a142353aefd089fadc8f1d985561a15358c97aca27b0979cb0785/kiwisolver-1.4.8-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce2cf1e5688edcb727fdf7cd1bbd0b6416758996826a8be1d958f91880d0809d", size = 65413, upload-time = "2024-12-24T18:28:20.064Z" }, + { url = "https://files.pythonhosted.org/packages/ce/6d/67d36c4d2054e83fb875c6b59d0809d5c530de8148846b1370475eeeece9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:c8bf637892dc6e6aad2bc6d4d69d08764166e5e3f69d469e55427b6ac001b19d", size = 1650826, upload-time = "2024-12-24T18:28:21.203Z" }, + { url = "https://files.pythonhosted.org/packages/de/c6/7b9bb8044e150d4d1558423a1568e4f227193662a02231064e3824f37e0a/kiwisolver-1.4.8-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:034d2c891f76bd3edbdb3ea11140d8510dca675443da7304205a2eaa45d8334c", size = 1628231, upload-time = "2024-12-24T18:28:23.851Z" }, + { url = "https://files.pythonhosted.org/packages/b6/38/ad10d437563063eaaedbe2c3540a71101fc7fb07a7e71f855e93ea4de605/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d47b28d1dfe0793d5e96bce90835e17edf9a499b53969b03c6c47ea5985844c3", size = 1408938, upload-time = "2024-12-24T18:28:26.687Z" }, + { url = "https://files.pythonhosted.org/packages/52/ce/c0106b3bd7f9e665c5f5bc1e07cc95b5dabd4e08e3dad42dbe2faad467e7/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eb158fe28ca0c29f2260cca8c43005329ad58452c36f0edf298204de32a9a3ed", size = 1422799, upload-time = "2024-12-24T18:28:30.538Z" }, + { url = "https://files.pythonhosted.org/packages/d0/87/efb704b1d75dc9758087ba374c0f23d3254505edaedd09cf9d247f7878b9/kiwisolver-1.4.8-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5536185fce131780ebd809f8e623bf4030ce1b161353166c49a3c74c287897f", size = 1354362, upload-time = "2024-12-24T18:28:32.943Z" }, + { url = "https://files.pythonhosted.org/packages/eb/b3/fd760dc214ec9a8f208b99e42e8f0130ff4b384eca8b29dd0efc62052176/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:369b75d40abedc1da2c1f4de13f3482cb99e3237b38726710f4a793432b1c5ff", size = 2222695, upload-time = "2024-12-24T18:28:35.641Z" }, + { url = "https://files.pythonhosted.org/packages/a2/09/a27fb36cca3fc01700687cc45dae7a6a5f8eeb5f657b9f710f788748e10d/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:641f2ddf9358c80faa22e22eb4c9f54bd3f0e442e038728f500e3b978d00aa7d", size = 2370802, upload-time = "2024-12-24T18:28:38.357Z" }, + { url = "https://files.pythonhosted.org/packages/3d/c3/ba0a0346db35fe4dc1f2f2cf8b99362fbb922d7562e5f911f7ce7a7b60fa/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d561d2d8883e0819445cfe58d7ddd673e4015c3c57261d7bdcd3710d0d14005c", size = 2334646, upload-time = "2024-12-24T18:28:40.941Z" }, + { url = "https://files.pythonhosted.org/packages/41/52/942cf69e562f5ed253ac67d5c92a693745f0bed3c81f49fc0cbebe4d6b00/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:1732e065704b47c9afca7ffa272f845300a4eb959276bf6970dc07265e73b605", size = 2467260, upload-time = "2024-12-24T18:28:42.273Z" }, + { url = "https://files.pythonhosted.org/packages/32/26/2d9668f30d8a494b0411d4d7d4ea1345ba12deb6a75274d58dd6ea01e951/kiwisolver-1.4.8-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:bcb1ebc3547619c3b58a39e2448af089ea2ef44b37988caf432447374941574e", size = 2288633, upload-time = "2024-12-24T18:28:44.87Z" }, + { url = "https://files.pythonhosted.org/packages/98/99/0dd05071654aa44fe5d5e350729961e7bb535372935a45ac89a8924316e6/kiwisolver-1.4.8-cp310-cp310-win_amd64.whl", hash = "sha256:89c107041f7b27844179ea9c85d6da275aa55ecf28413e87624d033cf1f6b751", size = 71885, upload-time = "2024-12-24T18:28:47.346Z" }, + { url = "https://files.pythonhosted.org/packages/6c/fc/822e532262a97442989335394d441cd1d0448c2e46d26d3e04efca84df22/kiwisolver-1.4.8-cp310-cp310-win_arm64.whl", hash = "sha256:b5773efa2be9eb9fcf5415ea3ab70fc785d598729fd6057bea38d539ead28271", size = 65175, upload-time = "2024-12-24T18:28:49.651Z" }, + { url = "https://files.pythonhosted.org/packages/da/ed/c913ee28936c371418cb167b128066ffb20bbf37771eecc2c97edf8a6e4c/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a4d3601908c560bdf880f07d94f31d734afd1bb71e96585cace0e38ef44c6d84", size = 124635, upload-time = "2024-12-24T18:28:51.826Z" }, + { url = "https://files.pythonhosted.org/packages/4c/45/4a7f896f7467aaf5f56ef093d1f329346f3b594e77c6a3c327b2d415f521/kiwisolver-1.4.8-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:856b269c4d28a5c0d5e6c1955ec36ebfd1651ac00e1ce0afa3e28da95293b561", size = 66717, upload-time = "2024-12-24T18:28:54.256Z" }, + { url = "https://files.pythonhosted.org/packages/5f/b4/c12b3ac0852a3a68f94598d4c8d569f55361beef6159dce4e7b624160da2/kiwisolver-1.4.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c2b9a96e0f326205af81a15718a9073328df1173a2619a68553decb7097fd5d7", size = 65413, upload-time = "2024-12-24T18:28:55.184Z" }, + { url = "https://files.pythonhosted.org/packages/a9/98/1df4089b1ed23d83d410adfdc5947245c753bddfbe06541c4aae330e9e70/kiwisolver-1.4.8-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5020c83e8553f770cb3b5fc13faac40f17e0b205bd237aebd21d53d733adb03", size = 1343994, upload-time = "2024-12-24T18:28:57.493Z" }, + { url = "https://files.pythonhosted.org/packages/8d/bf/b4b169b050c8421a7c53ea1ea74e4ef9c335ee9013216c558a047f162d20/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dace81d28c787956bfbfbbfd72fdcef014f37d9b48830829e488fdb32b49d954", size = 1434804, upload-time = "2024-12-24T18:29:00.077Z" }, + { url = "https://files.pythonhosted.org/packages/66/5a/e13bd341fbcf73325ea60fdc8af752addf75c5079867af2e04cc41f34434/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11e1022b524bd48ae56c9b4f9296bce77e15a2e42a502cceba602f804b32bb79", size = 1450690, upload-time = "2024-12-24T18:29:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/9b/4f/5955dcb376ba4a830384cc6fab7d7547bd6759fe75a09564910e9e3bb8ea/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b9b4d2892fefc886f30301cdd80debd8bb01ecdf165a449eb6e78f79f0fabd6", size = 1376839, upload-time = "2024-12-24T18:29:02.685Z" }, + { url = "https://files.pythonhosted.org/packages/3a/97/5edbed69a9d0caa2e4aa616ae7df8127e10f6586940aa683a496c2c280b9/kiwisolver-1.4.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3a96c0e790ee875d65e340ab383700e2b4891677b7fcd30a699146f9384a2bb0", size = 1435109, upload-time = "2024-12-24T18:29:04.113Z" }, + { url = "https://files.pythonhosted.org/packages/13/fc/e756382cb64e556af6c1809a1bbb22c141bbc2445049f2da06b420fe52bf/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:23454ff084b07ac54ca8be535f4174170c1094a4cff78fbae4f73a4bcc0d4dab", size = 2245269, upload-time = "2024-12-24T18:29:05.488Z" }, + { url = "https://files.pythonhosted.org/packages/76/15/e59e45829d7f41c776d138245cabae6515cb4eb44b418f6d4109c478b481/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:87b287251ad6488e95b4f0b4a79a6d04d3ea35fde6340eb38fbd1ca9cd35bbbc", size = 2393468, upload-time = "2024-12-24T18:29:06.79Z" }, + { url = "https://files.pythonhosted.org/packages/e9/39/483558c2a913ab8384d6e4b66a932406f87c95a6080112433da5ed668559/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b21dbe165081142b1232a240fc6383fd32cdd877ca6cc89eab93e5f5883e1c25", size = 2355394, upload-time = "2024-12-24T18:29:08.24Z" }, + { url = "https://files.pythonhosted.org/packages/01/aa/efad1fbca6570a161d29224f14b082960c7e08268a133fe5dc0f6906820e/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:768cade2c2df13db52475bd28d3a3fac8c9eff04b0e9e2fda0f3760f20b3f7fc", size = 2490901, upload-time = "2024-12-24T18:29:09.653Z" }, + { url = "https://files.pythonhosted.org/packages/c9/4f/15988966ba46bcd5ab9d0c8296914436720dd67fca689ae1a75b4ec1c72f/kiwisolver-1.4.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d47cfb2650f0e103d4bf68b0b5804c68da97272c84bb12850d877a95c056bd67", size = 2312306, upload-time = "2024-12-24T18:29:12.644Z" }, + { url = "https://files.pythonhosted.org/packages/2d/27/bdf1c769c83f74d98cbc34483a972f221440703054894a37d174fba8aa68/kiwisolver-1.4.8-cp311-cp311-win_amd64.whl", hash = "sha256:ed33ca2002a779a2e20eeb06aea7721b6e47f2d4b8a8ece979d8ba9e2a167e34", size = 71966, upload-time = "2024-12-24T18:29:14.089Z" }, + { url = "https://files.pythonhosted.org/packages/4a/c9/9642ea855604aeb2968a8e145fc662edf61db7632ad2e4fb92424be6b6c0/kiwisolver-1.4.8-cp311-cp311-win_arm64.whl", hash = "sha256:16523b40aab60426ffdebe33ac374457cf62863e330a90a0383639ce14bf44b2", size = 65311, upload-time = "2024-12-24T18:29:15.892Z" }, + { url = "https://files.pythonhosted.org/packages/fc/aa/cea685c4ab647f349c3bc92d2daf7ae34c8e8cf405a6dcd3a497f58a2ac3/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d6af5e8815fd02997cb6ad9bbed0ee1e60014438ee1a5c2444c96f87b8843502", size = 124152, upload-time = "2024-12-24T18:29:16.85Z" }, + { url = "https://files.pythonhosted.org/packages/c5/0b/8db6d2e2452d60d5ebc4ce4b204feeb16176a851fd42462f66ade6808084/kiwisolver-1.4.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bade438f86e21d91e0cf5dd7c0ed00cda0f77c8c1616bd83f9fc157fa6760d31", size = 66555, upload-time = "2024-12-24T18:29:19.146Z" }, + { url = "https://files.pythonhosted.org/packages/60/26/d6a0db6785dd35d3ba5bf2b2df0aedc5af089962c6eb2cbf67a15b81369e/kiwisolver-1.4.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b83dc6769ddbc57613280118fb4ce3cd08899cc3369f7d0e0fab518a7cf37fdb", size = 65067, upload-time = "2024-12-24T18:29:20.096Z" }, + { url = "https://files.pythonhosted.org/packages/c9/ed/1d97f7e3561e09757a196231edccc1bcf59d55ddccefa2afc9c615abd8e0/kiwisolver-1.4.8-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111793b232842991be367ed828076b03d96202c19221b5ebab421ce8bcad016f", size = 1378443, upload-time = "2024-12-24T18:29:22.843Z" }, + { url = "https://files.pythonhosted.org/packages/29/61/39d30b99954e6b46f760e6289c12fede2ab96a254c443639052d1b573fbc/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:257af1622860e51b1a9d0ce387bf5c2c4f36a90594cb9514f55b074bcc787cfc", size = 1472728, upload-time = "2024-12-24T18:29:24.463Z" }, + { url = "https://files.pythonhosted.org/packages/0c/3e/804163b932f7603ef256e4a715e5843a9600802bb23a68b4e08c8c0ff61d/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69b5637c3f316cab1ec1c9a12b8c5f4750a4c4b71af9157645bf32830e39c03a", size = 1478388, upload-time = "2024-12-24T18:29:25.776Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9e/60eaa75169a154700be74f875a4d9961b11ba048bef315fbe89cb6999056/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:782bb86f245ec18009890e7cb8d13a5ef54dcf2ebe18ed65f795e635a96a1c6a", size = 1413849, upload-time = "2024-12-24T18:29:27.202Z" }, + { url = "https://files.pythonhosted.org/packages/bc/b3/9458adb9472e61a998c8c4d95cfdfec91c73c53a375b30b1428310f923e4/kiwisolver-1.4.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc978a80a0db3a66d25767b03688f1147a69e6237175c0f4ffffaaedf744055a", size = 1475533, upload-time = "2024-12-24T18:29:28.638Z" }, + { url = "https://files.pythonhosted.org/packages/e4/7a/0a42d9571e35798de80aef4bb43a9b672aa7f8e58643d7bd1950398ffb0a/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:36dbbfd34838500a31f52c9786990d00150860e46cd5041386f217101350f0d3", size = 2268898, upload-time = "2024-12-24T18:29:30.368Z" }, + { url = "https://files.pythonhosted.org/packages/d9/07/1255dc8d80271400126ed8db35a1795b1a2c098ac3a72645075d06fe5c5d/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:eaa973f1e05131de5ff3569bbba7f5fd07ea0595d3870ed4a526d486fe57fa1b", size = 2425605, upload-time = "2024-12-24T18:29:33.151Z" }, + { url = "https://files.pythonhosted.org/packages/84/df/5a3b4cf13780ef6f6942df67b138b03b7e79e9f1f08f57c49957d5867f6e/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a66f60f8d0c87ab7f59b6fb80e642ebb29fec354a4dfad687ca4092ae69d04f4", size = 2375801, upload-time = "2024-12-24T18:29:34.584Z" }, + { url = "https://files.pythonhosted.org/packages/8f/10/2348d068e8b0f635c8c86892788dac7a6b5c0cb12356620ab575775aad89/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858416b7fb777a53f0c59ca08190ce24e9abbd3cffa18886a5781b8e3e26f65d", size = 2520077, upload-time = "2024-12-24T18:29:36.138Z" }, + { url = "https://files.pythonhosted.org/packages/32/d8/014b89fee5d4dce157d814303b0fce4d31385a2af4c41fed194b173b81ac/kiwisolver-1.4.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:085940635c62697391baafaaeabdf3dd7a6c3643577dde337f4d66eba021b2b8", size = 2338410, upload-time = "2024-12-24T18:29:39.991Z" }, + { url = "https://files.pythonhosted.org/packages/bd/72/dfff0cc97f2a0776e1c9eb5bef1ddfd45f46246c6533b0191887a427bca5/kiwisolver-1.4.8-cp312-cp312-win_amd64.whl", hash = "sha256:01c3d31902c7db5fb6182832713d3b4122ad9317c2c5877d0539227d96bb2e50", size = 71853, upload-time = "2024-12-24T18:29:42.006Z" }, + { url = "https://files.pythonhosted.org/packages/dc/85/220d13d914485c0948a00f0b9eb419efaf6da81b7d72e88ce2391f7aed8d/kiwisolver-1.4.8-cp312-cp312-win_arm64.whl", hash = "sha256:a3c44cb68861de93f0c4a8175fbaa691f0aa22550c331fefef02b618a9dcb476", size = 65424, upload-time = "2024-12-24T18:29:44.38Z" }, + { url = "https://files.pythonhosted.org/packages/79/b3/e62464a652f4f8cd9006e13d07abad844a47df1e6537f73ddfbf1bc997ec/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:1c8ceb754339793c24aee1c9fb2485b5b1f5bb1c2c214ff13368431e51fc9a09", size = 124156, upload-time = "2024-12-24T18:29:45.368Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2d/f13d06998b546a2ad4f48607a146e045bbe48030774de29f90bdc573df15/kiwisolver-1.4.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:54a62808ac74b5e55a04a408cda6156f986cefbcf0ada13572696b507cc92fa1", size = 66555, upload-time = "2024-12-24T18:29:46.37Z" }, + { url = "https://files.pythonhosted.org/packages/59/e3/b8bd14b0a54998a9fd1e8da591c60998dc003618cb19a3f94cb233ec1511/kiwisolver-1.4.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:68269e60ee4929893aad82666821aaacbd455284124817af45c11e50a4b42e3c", size = 65071, upload-time = "2024-12-24T18:29:47.333Z" }, + { url = "https://files.pythonhosted.org/packages/f0/1c/6c86f6d85ffe4d0ce04228d976f00674f1df5dc893bf2dd4f1928748f187/kiwisolver-1.4.8-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34d142fba9c464bc3bbfeff15c96eab0e7310343d6aefb62a79d51421fcc5f1b", size = 1378053, upload-time = "2024-12-24T18:29:49.636Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b9/1c6e9f6dcb103ac5cf87cb695845f5fa71379021500153566d8a8a9fc291/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc373e0eef45b59197de815b1b28ef89ae3955e7722cc9710fb91cd77b7f47", size = 1472278, upload-time = "2024-12-24T18:29:51.164Z" }, + { url = "https://files.pythonhosted.org/packages/ee/81/aca1eb176de671f8bda479b11acdc42c132b61a2ac861c883907dde6debb/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:77e6f57a20b9bd4e1e2cedda4d0b986ebd0216236f0106e55c28aea3d3d69b16", size = 1478139, upload-time = "2024-12-24T18:29:52.594Z" }, + { url = "https://files.pythonhosted.org/packages/49/f4/e081522473671c97b2687d380e9e4c26f748a86363ce5af48b4a28e48d06/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:08e77738ed7538f036cd1170cbed942ef749137b1311fa2bbe2a7fda2f6bf3cc", size = 1413517, upload-time = "2024-12-24T18:29:53.941Z" }, + { url = "https://files.pythonhosted.org/packages/8f/e9/6a7d025d8da8c4931522922cd706105aa32b3291d1add8c5427cdcd66e63/kiwisolver-1.4.8-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5ce1e481a74b44dd5e92ff03ea0cb371ae7a0268318e202be06c8f04f4f1246", size = 1474952, upload-time = "2024-12-24T18:29:56.523Z" }, + { url = "https://files.pythonhosted.org/packages/82/13/13fa685ae167bee5d94b415991c4fc7bb0a1b6ebea6e753a87044b209678/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fc2ace710ba7c1dfd1a3b42530b62b9ceed115f19a1656adefce7b1782a37794", size = 2269132, upload-time = "2024-12-24T18:29:57.989Z" }, + { url = "https://files.pythonhosted.org/packages/ef/92/bb7c9395489b99a6cb41d502d3686bac692586db2045adc19e45ee64ed23/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3452046c37c7692bd52b0e752b87954ef86ee2224e624ef7ce6cb21e8c41cc1b", size = 2425997, upload-time = "2024-12-24T18:29:59.393Z" }, + { url = "https://files.pythonhosted.org/packages/ed/12/87f0e9271e2b63d35d0d8524954145837dd1a6c15b62a2d8c1ebe0f182b4/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7e9a60b50fe8b2ec6f448fe8d81b07e40141bfced7f896309df271a0b92f80f3", size = 2376060, upload-time = "2024-12-24T18:30:01.338Z" }, + { url = "https://files.pythonhosted.org/packages/02/6e/c8af39288edbce8bf0fa35dee427b082758a4b71e9c91ef18fa667782138/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:918139571133f366e8362fa4a297aeba86c7816b7ecf0bc79168080e2bd79957", size = 2520471, upload-time = "2024-12-24T18:30:04.574Z" }, + { url = "https://files.pythonhosted.org/packages/13/78/df381bc7b26e535c91469f77f16adcd073beb3e2dd25042efd064af82323/kiwisolver-1.4.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e063ef9f89885a1d68dd8b2e18f5ead48653176d10a0e324e3b0030e3a69adeb", size = 2338793, upload-time = "2024-12-24T18:30:06.25Z" }, + { url = "https://files.pythonhosted.org/packages/d0/dc/c1abe38c37c071d0fc71c9a474fd0b9ede05d42f5a458d584619cfd2371a/kiwisolver-1.4.8-cp313-cp313-win_amd64.whl", hash = "sha256:a17b7c4f5b2c51bb68ed379defd608a03954a1845dfed7cc0117f1cc8a9b7fd2", size = 71855, upload-time = "2024-12-24T18:30:07.535Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b6/21529d595b126ac298fdd90b705d87d4c5693de60023e0efcb4f387ed99e/kiwisolver-1.4.8-cp313-cp313-win_arm64.whl", hash = "sha256:3cd3bc628b25f74aedc6d374d5babf0166a92ff1317f46267f12d2ed54bc1d30", size = 65430, upload-time = "2024-12-24T18:30:08.504Z" }, + { url = "https://files.pythonhosted.org/packages/34/bd/b89380b7298e3af9b39f49334e3e2a4af0e04819789f04b43d560516c0c8/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:370fd2df41660ed4e26b8c9d6bbcad668fbe2560462cba151a721d49e5b6628c", size = 126294, upload-time = "2024-12-24T18:30:09.508Z" }, + { url = "https://files.pythonhosted.org/packages/83/41/5857dc72e5e4148eaac5aa76e0703e594e4465f8ab7ec0fc60e3a9bb8fea/kiwisolver-1.4.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:84a2f830d42707de1d191b9490ac186bf7997a9495d4e9072210a1296345f7dc", size = 67736, upload-time = "2024-12-24T18:30:11.039Z" }, + { url = "https://files.pythonhosted.org/packages/e1/d1/be059b8db56ac270489fb0b3297fd1e53d195ba76e9bbb30e5401fa6b759/kiwisolver-1.4.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7a3ad337add5148cf51ce0b55642dc551c0b9d6248458a757f98796ca7348712", size = 66194, upload-time = "2024-12-24T18:30:14.886Z" }, + { url = "https://files.pythonhosted.org/packages/e1/83/4b73975f149819eb7dcf9299ed467eba068ecb16439a98990dcb12e63fdd/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7506488470f41169b86d8c9aeff587293f530a23a23a49d6bc64dab66bedc71e", size = 1465942, upload-time = "2024-12-24T18:30:18.927Z" }, + { url = "https://files.pythonhosted.org/packages/c7/2c/30a5cdde5102958e602c07466bce058b9d7cb48734aa7a4327261ac8e002/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f0121b07b356a22fb0414cec4666bbe36fd6d0d759db3d37228f496ed67c880", size = 1595341, upload-time = "2024-12-24T18:30:22.102Z" }, + { url = "https://files.pythonhosted.org/packages/ff/9b/1e71db1c000385aa069704f5990574b8244cce854ecd83119c19e83c9586/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6d6bd87df62c27d4185de7c511c6248040afae67028a8a22012b010bc7ad062", size = 1598455, upload-time = "2024-12-24T18:30:24.947Z" }, + { url = "https://files.pythonhosted.org/packages/85/92/c8fec52ddf06231b31cbb779af77e99b8253cd96bd135250b9498144c78b/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:291331973c64bb9cce50bbe871fb2e675c4331dab4f31abe89f175ad7679a4d7", size = 1522138, upload-time = "2024-12-24T18:30:26.286Z" }, + { url = "https://files.pythonhosted.org/packages/0b/51/9eb7e2cd07a15d8bdd976f6190c0164f92ce1904e5c0c79198c4972926b7/kiwisolver-1.4.8-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:893f5525bb92d3d735878ec00f781b2de998333659507d29ea4466208df37bed", size = 1582857, upload-time = "2024-12-24T18:30:28.86Z" }, + { url = "https://files.pythonhosted.org/packages/0f/95/c5a00387a5405e68ba32cc64af65ce881a39b98d73cc394b24143bebc5b8/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b47a465040146981dc9db8647981b8cb96366fbc8d452b031e4f8fdffec3f26d", size = 2293129, upload-time = "2024-12-24T18:30:30.34Z" }, + { url = "https://files.pythonhosted.org/packages/44/83/eeb7af7d706b8347548313fa3a3a15931f404533cc54fe01f39e830dd231/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:99cea8b9dd34ff80c521aef46a1dddb0dcc0283cf18bde6d756f1e6f31772165", size = 2421538, upload-time = "2024-12-24T18:30:33.334Z" }, + { url = "https://files.pythonhosted.org/packages/05/f9/27e94c1b3eb29e6933b6986ffc5fa1177d2cd1f0c8efc5f02c91c9ac61de/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:151dffc4865e5fe6dafce5480fab84f950d14566c480c08a53c663a0020504b6", size = 2390661, upload-time = "2024-12-24T18:30:34.939Z" }, + { url = "https://files.pythonhosted.org/packages/d9/d4/3c9735faa36ac591a4afcc2980d2691000506050b7a7e80bcfe44048daa7/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:577facaa411c10421314598b50413aa1ebcf5126f704f1e5d72d7e4e9f020d90", size = 2546710, upload-time = "2024-12-24T18:30:37.281Z" }, + { url = "https://files.pythonhosted.org/packages/4c/fa/be89a49c640930180657482a74970cdcf6f7072c8d2471e1babe17a222dc/kiwisolver-1.4.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:be4816dc51c8a471749d664161b434912eee82f2ea66bd7628bd14583a833e85", size = 2349213, upload-time = "2024-12-24T18:30:40.019Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f9/ae81c47a43e33b93b0a9819cac6723257f5da2a5a60daf46aa5c7226ea85/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e7a019419b7b510f0f7c9dceff8c5eae2392037eae483a7f9162625233802b0a", size = 60403, upload-time = "2024-12-24T18:30:41.372Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/f92b5cb6f4ce0c1ebfcfe3e2e42b96917e16f7090e45b21102941924f18f/kiwisolver-1.4.8-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:286b18e86682fd2217a48fc6be6b0f20c1d0ed10958d8dc53453ad58d7be0bf8", size = 58657, upload-time = "2024-12-24T18:30:42.392Z" }, + { url = "https://files.pythonhosted.org/packages/80/28/ae0240f732f0484d3a4dc885d055653c47144bdf59b670aae0ec3c65a7c8/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4191ee8dfd0be1c3666ccbac178c5a05d5f8d689bbe3fc92f3c4abec817f8fe0", size = 84948, upload-time = "2024-12-24T18:30:44.703Z" }, + { url = "https://files.pythonhosted.org/packages/5d/eb/78d50346c51db22c7203c1611f9b513075f35c4e0e4877c5dde378d66043/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cd2785b9391f2873ad46088ed7599a6a71e762e1ea33e87514b1a441ed1da1c", size = 81186, upload-time = "2024-12-24T18:30:45.654Z" }, + { url = "https://files.pythonhosted.org/packages/43/f8/7259f18c77adca88d5f64f9a522792e178b2691f3748817a8750c2d216ef/kiwisolver-1.4.8-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c07b29089b7ba090b6f1a669f1411f27221c3662b3a1b7010e67b59bb5a6f10b", size = 80279, upload-time = "2024-12-24T18:30:47.951Z" }, + { url = "https://files.pythonhosted.org/packages/3a/1d/50ad811d1c5dae091e4cf046beba925bcae0a610e79ae4c538f996f63ed5/kiwisolver-1.4.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:65ea09a5a3faadd59c2ce96dc7bf0f364986a315949dc6374f04396b0d60e09b", size = 71762, upload-time = "2024-12-24T18:30:48.903Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/26/91/d49359a21893183ed2a5b6c76bec40e0b1dcbf8ca148f864d134897cfc75/matplotlib-3.10.3.tar.gz", hash = "sha256:2f82d2c5bb7ae93aaaa4cd42aca65d76ce6376f83304fa3a630b569aca274df0", size = 34799811, upload-time = "2025-05-08T19:10:54.39Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/ea/2bba25d289d389c7451f331ecd593944b3705f06ddf593fa7be75037d308/matplotlib-3.10.3-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:213fadd6348d106ca7db99e113f1bea1e65e383c3ba76e8556ba4a3054b65ae7", size = 8167862, upload-time = "2025-05-08T19:09:39.563Z" }, + { url = "https://files.pythonhosted.org/packages/41/81/cc70b5138c926604e8c9ed810ed4c79e8116ba72e02230852f5c12c87ba2/matplotlib-3.10.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3bec61cb8221f0ca6313889308326e7bb303d0d302c5cc9e523b2f2e6c73deb", size = 8042149, upload-time = "2025-05-08T19:09:42.413Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9a/0ff45b6bfa42bb16de597e6058edf2361c298ad5ef93b327728145161bbf/matplotlib-3.10.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c21ae75651c0231b3ba014b6d5e08fb969c40cdb5a011e33e99ed0c9ea86ecb", size = 8453719, upload-time = "2025-05-08T19:09:44.901Z" }, + { url = "https://files.pythonhosted.org/packages/85/c7/1866e972fed6d71ef136efbc980d4d1854ab7ef1ea8152bbd995ca231c81/matplotlib-3.10.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a49e39755580b08e30e3620efc659330eac5d6534ab7eae50fa5e31f53ee4e30", size = 8590801, upload-time = "2025-05-08T19:09:47.404Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b9/748f6626d534ab7e255bdc39dc22634d337cf3ce200f261b5d65742044a1/matplotlib-3.10.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cf4636203e1190871d3a73664dea03d26fb019b66692cbfd642faafdad6208e8", size = 9402111, upload-time = "2025-05-08T19:09:49.474Z" }, + { url = "https://files.pythonhosted.org/packages/1f/78/8bf07bd8fb67ea5665a6af188e70b57fcb2ab67057daa06b85a08e59160a/matplotlib-3.10.3-cp310-cp310-win_amd64.whl", hash = "sha256:fd5641a9bb9d55f4dd2afe897a53b537c834b9012684c8444cc105895c8c16fd", size = 8057213, upload-time = "2025-05-08T19:09:51.489Z" }, + { url = "https://files.pythonhosted.org/packages/f5/bd/af9f655456f60fe1d575f54fb14704ee299b16e999704817a7645dfce6b0/matplotlib-3.10.3-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:0ef061f74cd488586f552d0c336b2f078d43bc00dc473d2c3e7bfee2272f3fa8", size = 8178873, upload-time = "2025-05-08T19:09:53.857Z" }, + { url = "https://files.pythonhosted.org/packages/c2/86/e1c86690610661cd716eda5f9d0b35eaf606ae6c9b6736687cfc8f2d0cd8/matplotlib-3.10.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d96985d14dc5f4a736bbea4b9de9afaa735f8a0fc2ca75be2fa9e96b2097369d", size = 8052205, upload-time = "2025-05-08T19:09:55.684Z" }, + { url = "https://files.pythonhosted.org/packages/54/51/a9f8e49af3883dacddb2da1af5fca1f7468677f1188936452dd9aaaeb9ed/matplotlib-3.10.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7c5f0283da91e9522bdba4d6583ed9d5521566f63729ffb68334f86d0bb98049", size = 8465823, upload-time = "2025-05-08T19:09:57.442Z" }, + { url = "https://files.pythonhosted.org/packages/e7/e3/c82963a3b86d6e6d5874cbeaa390166458a7f1961bab9feb14d3d1a10f02/matplotlib-3.10.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdfa07c0ec58035242bc8b2c8aae37037c9a886370eef6850703d7583e19964b", size = 8606464, upload-time = "2025-05-08T19:09:59.471Z" }, + { url = "https://files.pythonhosted.org/packages/0e/34/24da1027e7fcdd9e82da3194c470143c551852757a4b473a09a012f5b945/matplotlib-3.10.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c0b9849a17bce080a16ebcb80a7b714b5677d0ec32161a2cc0a8e5a6030ae220", size = 9413103, upload-time = "2025-05-08T19:10:03.208Z" }, + { url = "https://files.pythonhosted.org/packages/a6/da/948a017c3ea13fd4a97afad5fdebe2f5bbc4d28c0654510ce6fd6b06b7bd/matplotlib-3.10.3-cp311-cp311-win_amd64.whl", hash = "sha256:eef6ed6c03717083bc6d69c2d7ee8624205c29a8e6ea5a31cd3492ecdbaee1e1", size = 8065492, upload-time = "2025-05-08T19:10:05.271Z" }, + { url = "https://files.pythonhosted.org/packages/eb/43/6b80eb47d1071f234ef0c96ca370c2ca621f91c12045f1401b5c9b28a639/matplotlib-3.10.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0ab1affc11d1f495ab9e6362b8174a25afc19c081ba5b0775ef00533a4236eea", size = 8179689, upload-time = "2025-05-08T19:10:07.602Z" }, + { url = "https://files.pythonhosted.org/packages/0f/70/d61a591958325c357204870b5e7b164f93f2a8cca1dc6ce940f563909a13/matplotlib-3.10.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2a818d8bdcafa7ed2eed74487fdb071c09c1ae24152d403952adad11fa3c65b4", size = 8050466, upload-time = "2025-05-08T19:10:09.383Z" }, + { url = "https://files.pythonhosted.org/packages/e7/75/70c9d2306203148cc7902a961240c5927dd8728afedf35e6a77e105a2985/matplotlib-3.10.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:748ebc3470c253e770b17d8b0557f0aa85cf8c63fd52f1a61af5b27ec0b7ffee", size = 8456252, upload-time = "2025-05-08T19:10:11.958Z" }, + { url = "https://files.pythonhosted.org/packages/c4/91/ba0ae1ff4b3f30972ad01cd4a8029e70a0ec3b8ea5be04764b128b66f763/matplotlib-3.10.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed70453fd99733293ace1aec568255bc51c6361cb0da94fa5ebf0649fdb2150a", size = 8601321, upload-time = "2025-05-08T19:10:14.47Z" }, + { url = "https://files.pythonhosted.org/packages/d2/88/d636041eb54a84b889e11872d91f7cbf036b3b0e194a70fa064eb8b04f7a/matplotlib-3.10.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dbed9917b44070e55640bd13419de83b4c918e52d97561544814ba463811cbc7", size = 9406972, upload-time = "2025-05-08T19:10:16.569Z" }, + { url = "https://files.pythonhosted.org/packages/b1/79/0d1c165eac44405a86478082e225fce87874f7198300bbebc55faaf6d28d/matplotlib-3.10.3-cp312-cp312-win_amd64.whl", hash = "sha256:cf37d8c6ef1a48829443e8ba5227b44236d7fcaf7647caa3178a4ff9f7a5be05", size = 8067954, upload-time = "2025-05-08T19:10:18.663Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c1/23cfb566a74c696a3b338d8955c549900d18fe2b898b6e94d682ca21e7c2/matplotlib-3.10.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9f2efccc8dcf2b86fc4ee849eea5dcaecedd0773b30f47980dc0cbeabf26ec84", size = 8180318, upload-time = "2025-05-08T19:10:20.426Z" }, + { url = "https://files.pythonhosted.org/packages/6c/0c/02f1c3b66b30da9ee343c343acbb6251bef5b01d34fad732446eaadcd108/matplotlib-3.10.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3ddbba06a6c126e3301c3d272a99dcbe7f6c24c14024e80307ff03791a5f294e", size = 8051132, upload-time = "2025-05-08T19:10:22.569Z" }, + { url = "https://files.pythonhosted.org/packages/b4/ab/8db1a5ac9b3a7352fb914133001dae889f9fcecb3146541be46bed41339c/matplotlib-3.10.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:748302b33ae9326995b238f606e9ed840bf5886ebafcb233775d946aa8107a15", size = 8457633, upload-time = "2025-05-08T19:10:24.749Z" }, + { url = "https://files.pythonhosted.org/packages/f5/64/41c4367bcaecbc03ef0d2a3ecee58a7065d0a36ae1aa817fe573a2da66d4/matplotlib-3.10.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a80fcccbef63302c0efd78042ea3c2436104c5b1a4d3ae20f864593696364ac7", size = 8601031, upload-time = "2025-05-08T19:10:27.03Z" }, + { url = "https://files.pythonhosted.org/packages/12/6f/6cc79e9e5ab89d13ed64da28898e40fe5b105a9ab9c98f83abd24e46d7d7/matplotlib-3.10.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:55e46cbfe1f8586adb34f7587c3e4f7dedc59d5226719faf6cb54fc24f2fd52d", size = 9406988, upload-time = "2025-05-08T19:10:29.056Z" }, + { url = "https://files.pythonhosted.org/packages/b1/0f/eed564407bd4d935ffabf561ed31099ed609e19287409a27b6d336848653/matplotlib-3.10.3-cp313-cp313-win_amd64.whl", hash = "sha256:151d89cb8d33cb23345cd12490c76fd5d18a56581a16d950b48c6ff19bb2ab93", size = 8068034, upload-time = "2025-05-08T19:10:31.221Z" }, + { url = "https://files.pythonhosted.org/packages/3e/e5/2f14791ff69b12b09e9975e1d116d9578ac684460860ce542c2588cb7a1c/matplotlib-3.10.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:c26dd9834e74d164d06433dc7be5d75a1e9890b926b3e57e74fa446e1a62c3e2", size = 8218223, upload-time = "2025-05-08T19:10:33.114Z" }, + { url = "https://files.pythonhosted.org/packages/5c/08/30a94afd828b6e02d0a52cae4a29d6e9ccfcf4c8b56cc28b021d3588873e/matplotlib-3.10.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:24853dad5b8c84c8c2390fc31ce4858b6df504156893292ce8092d190ef8151d", size = 8094985, upload-time = "2025-05-08T19:10:35.337Z" }, + { url = "https://files.pythonhosted.org/packages/89/44/f3bc6b53066c889d7a1a3ea8094c13af6a667c5ca6220ec60ecceec2dabe/matplotlib-3.10.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68f7878214d369d7d4215e2a9075fef743be38fa401d32e6020bab2dfabaa566", size = 8483109, upload-time = "2025-05-08T19:10:37.611Z" }, + { url = "https://files.pythonhosted.org/packages/ba/c7/473bc559beec08ebee9f86ca77a844b65747e1a6c2691e8c92e40b9f42a8/matplotlib-3.10.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6929fc618cb6db9cb75086f73b3219bbb25920cb24cee2ea7a12b04971a4158", size = 8618082, upload-time = "2025-05-08T19:10:39.892Z" }, + { url = "https://files.pythonhosted.org/packages/d8/e9/6ce8edd264c8819e37bbed8172e0ccdc7107fe86999b76ab5752276357a4/matplotlib-3.10.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6c7818292a5cc372a2dc4c795e5c356942eb8350b98ef913f7fda51fe175ac5d", size = 9413699, upload-time = "2025-05-08T19:10:42.376Z" }, + { url = "https://files.pythonhosted.org/packages/1b/92/9a45c91089c3cf690b5badd4be81e392ff086ccca8a1d4e3a08463d8a966/matplotlib-3.10.3-cp313-cp313t-win_amd64.whl", hash = "sha256:4f23ffe95c5667ef8a2b56eea9b53db7f43910fa4a2d5472ae0f72b64deab4d5", size = 8139044, upload-time = "2025-05-08T19:10:44.551Z" }, + { url = "https://files.pythonhosted.org/packages/3d/d1/f54d43e95384b312ffa4a74a4326c722f3b8187aaaa12e9a84cdf3037131/matplotlib-3.10.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:86ab63d66bbc83fdb6733471d3bff40897c1e9921cba112accd748eee4bce5e4", size = 8162896, upload-time = "2025-05-08T19:10:46.432Z" }, + { url = "https://files.pythonhosted.org/packages/24/a4/fbfc00c2346177c95b353dcf9b5a004106abe8730a62cb6f27e79df0a698/matplotlib-3.10.3-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:a48f9c08bf7444b5d2391a83e75edb464ccda3c380384b36532a0962593a1751", size = 8039702, upload-time = "2025-05-08T19:10:49.634Z" }, + { url = "https://files.pythonhosted.org/packages/6a/b9/59e120d24a2ec5fc2d30646adb2efb4621aab3c6d83d66fb2a7a182db032/matplotlib-3.10.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb73d8aa75a237457988f9765e4dfe1c0d2453c5ca4eabc897d4309672c8e014", size = 8594298, upload-time = "2025-05-08T19:10:51.738Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.1.7" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/99/5b/a36a337438a14116b16480db471ad061c36c3694df7c2084a0da7ba538b7/matplotlib_inline-0.1.7.tar.gz", hash = "sha256:8423b23ec666be3d16e16b60bdd8ac4e86e840ebd1dd11a30b9f117f2fa0ab90", size = 8159, upload-time = "2024-04-15T13:44:44.803Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8f/8e/9ad090d3553c280a8060fbf6e24dc1c0c29704ee7d1c372f0c174aa59285/matplotlib_inline-0.1.7-py3-none-any.whl", hash = "sha256:df192d39a4ff8f21b1895d72e6a13f5fcc5099f00fa84384e0ea28c2cc0653ca", size = 9899, upload-time = "2024-04-15T13:44:43.265Z" }, +] + +[[package]] +name = "multidict" +version = "6.4.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/91/2f/a3470242707058fe856fe59241eee5635d79087100b7042a867368863a27/multidict-6.4.4.tar.gz", hash = "sha256:69ee9e6ba214b5245031b76233dd95408a0fd57fdb019ddcc1ead4790932a8e8", size = 90183, upload-time = "2025-05-19T14:16:37.381Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1f/92/0926a5baafa164b5d0ade3cd7932be39310375d7e25c9d7ceca05cb26a45/multidict-6.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8adee3ac041145ffe4488ea73fa0a622b464cc25340d98be76924d0cda8545ff", size = 66052, upload-time = "2025-05-19T14:13:49.944Z" }, + { url = "https://files.pythonhosted.org/packages/b2/54/8a857ae4f8f643ec444d91f419fdd49cc7a90a2ca0e42d86482b604b63bd/multidict-6.4.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b61e98c3e2a861035aaccd207da585bdcacef65fe01d7a0d07478efac005e028", size = 38867, upload-time = "2025-05-19T14:13:51.92Z" }, + { url = "https://files.pythonhosted.org/packages/9e/5f/63add9069f945c19bc8b217ea6b0f8a1ad9382eab374bb44fae4354b3baf/multidict-6.4.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:75493f28dbadecdbb59130e74fe935288813301a8554dc32f0c631b6bdcdf8b0", size = 38138, upload-time = "2025-05-19T14:13:53.778Z" }, + { url = "https://files.pythonhosted.org/packages/97/8b/fbd9c0fc13966efdb4a47f5bcffff67a4f2a3189fbeead5766eaa4250b20/multidict-6.4.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4ffc3c6a37e048b5395ee235e4a2a0d639c2349dffa32d9367a42fc20d399772", size = 220433, upload-time = "2025-05-19T14:13:55.346Z" }, + { url = "https://files.pythonhosted.org/packages/a9/c4/5132b2d75b3ea2daedb14d10f91028f09f74f5b4d373b242c1b8eec47571/multidict-6.4.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:87cb72263946b301570b0f63855569a24ee8758aaae2cd182aae7d95fbc92ca7", size = 218059, upload-time = "2025-05-19T14:13:56.993Z" }, + { url = "https://files.pythonhosted.org/packages/1a/70/f1e818c7a29b908e2d7b4fafb1d7939a41c64868e79de2982eea0a13193f/multidict-6.4.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9bbf7bd39822fd07e3609b6b4467af4c404dd2b88ee314837ad1830a7f4a8299", size = 231120, upload-time = "2025-05-19T14:13:58.333Z" }, + { url = "https://files.pythonhosted.org/packages/b4/7e/95a194d85f27d5ef9cbe48dff9ded722fc6d12fedf641ec6e1e680890be7/multidict-6.4.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d1f7cbd4f1f44ddf5fd86a8675b7679176eae770f2fc88115d6dddb6cefb59bc", size = 227457, upload-time = "2025-05-19T14:13:59.663Z" }, + { url = "https://files.pythonhosted.org/packages/25/2b/590ad220968d1babb42f265debe7be5c5c616df6c5688c995a06d8a9b025/multidict-6.4.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb5ac9e5bfce0e6282e7f59ff7b7b9a74aa8e5c60d38186a4637f5aa764046ad", size = 219111, upload-time = "2025-05-19T14:14:01.019Z" }, + { url = "https://files.pythonhosted.org/packages/e0/f0/b07682b995d3fb5313f339b59d7de02db19ba0c02d1f77c27bdf8212d17c/multidict-6.4.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4efc31dfef8c4eeb95b6b17d799eedad88c4902daba39ce637e23a17ea078915", size = 213012, upload-time = "2025-05-19T14:14:02.396Z" }, + { url = "https://files.pythonhosted.org/packages/24/56/c77b5f36feef2ec92f1119756e468ac9c3eebc35aa8a4c9e51df664cbbc9/multidict-6.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9fcad2945b1b91c29ef2b4050f590bfcb68d8ac8e0995a74e659aa57e8d78e01", size = 225408, upload-time = "2025-05-19T14:14:04.826Z" }, + { url = "https://files.pythonhosted.org/packages/cc/b3/e8189b82af9b198b47bc637766208fc917189eea91d674bad417e657bbdf/multidict-6.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d877447e7368c7320832acb7159557e49b21ea10ffeb135c1077dbbc0816b598", size = 214396, upload-time = "2025-05-19T14:14:06.187Z" }, + { url = "https://files.pythonhosted.org/packages/20/e0/200d14c84e35ae13ee99fd65dc106e1a1acb87a301f15e906fc7d5b30c17/multidict-6.4.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:33a12ebac9f380714c298cbfd3e5b9c0c4e89c75fe612ae496512ee51028915f", size = 222237, upload-time = "2025-05-19T14:14:07.778Z" }, + { url = "https://files.pythonhosted.org/packages/13/f3/bb3df40045ca8262694a3245298732ff431dc781414a89a6a364ebac6840/multidict-6.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0f14ea68d29b43a9bf37953881b1e3eb75b2739e896ba4a6aa4ad4c5b9ffa145", size = 231425, upload-time = "2025-05-19T14:14:09.516Z" }, + { url = "https://files.pythonhosted.org/packages/85/3b/538563dc18514384dac169bcba938753ad9ab4d4c8d49b55d6ae49fb2579/multidict-6.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:0327ad2c747a6600e4797d115d3c38a220fdb28e54983abe8964fd17e95ae83c", size = 226251, upload-time = "2025-05-19T14:14:10.82Z" }, + { url = "https://files.pythonhosted.org/packages/56/79/77e1a65513f09142358f1beb1d4cbc06898590b34a7de2e47023e3c5a3a2/multidict-6.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d1a20707492db9719a05fc62ee215fd2c29b22b47c1b1ba347f9abc831e26683", size = 220363, upload-time = "2025-05-19T14:14:12.638Z" }, + { url = "https://files.pythonhosted.org/packages/16/57/67b0516c3e348f8daaa79c369b3de4359a19918320ab82e2e586a1c624ef/multidict-6.4.4-cp310-cp310-win32.whl", hash = "sha256:d83f18315b9fca5db2452d1881ef20f79593c4aa824095b62cb280019ef7aa3d", size = 35175, upload-time = "2025-05-19T14:14:14.805Z" }, + { url = "https://files.pythonhosted.org/packages/86/5a/4ed8fec642d113fa653777cda30ef67aa5c8a38303c091e24c521278a6c6/multidict-6.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:9c17341ee04545fd962ae07330cb5a39977294c883485c8d74634669b1f7fe04", size = 38678, upload-time = "2025-05-19T14:14:16.949Z" }, + { url = "https://files.pythonhosted.org/packages/19/1b/4c6e638195851524a63972c5773c7737bea7e47b1ba402186a37773acee2/multidict-6.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4f5f29794ac0e73d2a06ac03fd18870adc0135a9d384f4a306a951188ed02f95", size = 65515, upload-time = "2025-05-19T14:14:19.767Z" }, + { url = "https://files.pythonhosted.org/packages/25/d5/10e6bca9a44b8af3c7f920743e5fc0c2bcf8c11bf7a295d4cfe00b08fb46/multidict-6.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c04157266344158ebd57b7120d9b0b35812285d26d0e78193e17ef57bfe2979a", size = 38609, upload-time = "2025-05-19T14:14:21.538Z" }, + { url = "https://files.pythonhosted.org/packages/26/b4/91fead447ccff56247edc7f0535fbf140733ae25187a33621771ee598a18/multidict-6.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bb61ffd3ab8310d93427e460f565322c44ef12769f51f77277b4abad7b6f7223", size = 37871, upload-time = "2025-05-19T14:14:22.666Z" }, + { url = "https://files.pythonhosted.org/packages/3b/37/cbc977cae59277e99d15bbda84cc53b5e0c4929ffd91d958347200a42ad0/multidict-6.4.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5e0ba18a9afd495f17c351d08ebbc4284e9c9f7971d715f196b79636a4d0de44", size = 226661, upload-time = "2025-05-19T14:14:24.124Z" }, + { url = "https://files.pythonhosted.org/packages/15/cd/7e0b57fbd4dc2fc105169c4ecce5be1a63970f23bb4ec8c721b67e11953d/multidict-6.4.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9faf1b1dcaadf9f900d23a0e6d6c8eadd6a95795a0e57fcca73acce0eb912065", size = 223422, upload-time = "2025-05-19T14:14:25.437Z" }, + { url = "https://files.pythonhosted.org/packages/f1/01/1de268da121bac9f93242e30cd3286f6a819e5f0b8896511162d6ed4bf8d/multidict-6.4.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a4d1cb1327c6082c4fce4e2a438483390964c02213bc6b8d782cf782c9b1471f", size = 235447, upload-time = "2025-05-19T14:14:26.793Z" }, + { url = "https://files.pythonhosted.org/packages/d2/8c/8b9a5e4aaaf4f2de14e86181a3a3d7b105077f668b6a06f043ec794f684c/multidict-6.4.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:941f1bec2f5dbd51feeb40aea654c2747f811ab01bdd3422a48a4e4576b7d76a", size = 231455, upload-time = "2025-05-19T14:14:28.149Z" }, + { url = "https://files.pythonhosted.org/packages/35/db/e1817dcbaa10b319c412769cf999b1016890849245d38905b73e9c286862/multidict-6.4.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5f8a146184da7ea12910a4cec51ef85e44f6268467fb489c3caf0cd512f29c2", size = 223666, upload-time = "2025-05-19T14:14:29.584Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e1/66e8579290ade8a00e0126b3d9a93029033ffd84f0e697d457ed1814d0fc/multidict-6.4.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:232b7237e57ec3c09be97206bfb83a0aa1c5d7d377faa019c68a210fa35831f1", size = 217392, upload-time = "2025-05-19T14:14:30.961Z" }, + { url = "https://files.pythonhosted.org/packages/7b/6f/f8639326069c24a48c7747c2a5485d37847e142a3f741ff3340c88060a9a/multidict-6.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:55ae0721c1513e5e3210bca4fc98456b980b0c2c016679d3d723119b6b202c42", size = 228969, upload-time = "2025-05-19T14:14:32.672Z" }, + { url = "https://files.pythonhosted.org/packages/d2/c3/3d58182f76b960eeade51c89fcdce450f93379340457a328e132e2f8f9ed/multidict-6.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:51d662c072579f63137919d7bb8fc250655ce79f00c82ecf11cab678f335062e", size = 217433, upload-time = "2025-05-19T14:14:34.016Z" }, + { url = "https://files.pythonhosted.org/packages/e1/4b/f31a562906f3bd375f3d0e83ce314e4a660c01b16c2923e8229b53fba5d7/multidict-6.4.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0e05c39962baa0bb19a6b210e9b1422c35c093b651d64246b6c2e1a7e242d9fd", size = 225418, upload-time = "2025-05-19T14:14:35.376Z" }, + { url = "https://files.pythonhosted.org/packages/99/89/78bb95c89c496d64b5798434a3deee21996114d4d2c28dd65850bf3a691e/multidict-6.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d5b1cc3ab8c31d9ebf0faa6e3540fb91257590da330ffe6d2393d4208e638925", size = 235042, upload-time = "2025-05-19T14:14:36.723Z" }, + { url = "https://files.pythonhosted.org/packages/74/91/8780a6e5885a8770442a8f80db86a0887c4becca0e5a2282ba2cae702bc4/multidict-6.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:93ec84488a384cd7b8a29c2c7f467137d8a73f6fe38bb810ecf29d1ade011a7c", size = 230280, upload-time = "2025-05-19T14:14:38.194Z" }, + { url = "https://files.pythonhosted.org/packages/68/c1/fcf69cabd542eb6f4b892469e033567ee6991d361d77abdc55e3a0f48349/multidict-6.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b308402608493638763abc95f9dc0030bbd6ac6aff784512e8ac3da73a88af08", size = 223322, upload-time = "2025-05-19T14:14:40.015Z" }, + { url = "https://files.pythonhosted.org/packages/b8/85/5b80bf4b83d8141bd763e1d99142a9cdfd0db83f0739b4797172a4508014/multidict-6.4.4-cp311-cp311-win32.whl", hash = "sha256:343892a27d1a04d6ae455ecece12904d242d299ada01633d94c4f431d68a8c49", size = 35070, upload-time = "2025-05-19T14:14:41.904Z" }, + { url = "https://files.pythonhosted.org/packages/09/66/0bed198ffd590ab86e001f7fa46b740d58cf8ff98c2f254e4a36bf8861ad/multidict-6.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:73484a94f55359780c0f458bbd3c39cb9cf9c182552177d2136e828269dee529", size = 38667, upload-time = "2025-05-19T14:14:43.534Z" }, + { url = "https://files.pythonhosted.org/packages/d2/b5/5675377da23d60875fe7dae6be841787755878e315e2f517235f22f59e18/multidict-6.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:dc388f75a1c00000824bf28b7633e40854f4127ede80512b44c3cfeeea1839a2", size = 64293, upload-time = "2025-05-19T14:14:44.724Z" }, + { url = "https://files.pythonhosted.org/packages/34/a7/be384a482754bb8c95d2bbe91717bf7ccce6dc38c18569997a11f95aa554/multidict-6.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:98af87593a666f739d9dba5d0ae86e01b0e1a9cfcd2e30d2d361fbbbd1a9162d", size = 38096, upload-time = "2025-05-19T14:14:45.95Z" }, + { url = "https://files.pythonhosted.org/packages/66/6d/d59854bb4352306145bdfd1704d210731c1bb2c890bfee31fb7bbc1c4c7f/multidict-6.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aff4cafea2d120327d55eadd6b7f1136a8e5a0ecf6fb3b6863e8aca32cd8e50a", size = 37214, upload-time = "2025-05-19T14:14:47.158Z" }, + { url = "https://files.pythonhosted.org/packages/99/e0/c29d9d462d7cfc5fc8f9bf24f9c6843b40e953c0b55e04eba2ad2cf54fba/multidict-6.4.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:169c4ba7858176b797fe551d6e99040c531c775d2d57b31bcf4de6d7a669847f", size = 224686, upload-time = "2025-05-19T14:14:48.366Z" }, + { url = "https://files.pythonhosted.org/packages/dc/4a/da99398d7fd8210d9de068f9a1b5f96dfaf67d51e3f2521f17cba4ee1012/multidict-6.4.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b9eb4c59c54421a32b3273d4239865cb14ead53a606db066d7130ac80cc8ec93", size = 231061, upload-time = "2025-05-19T14:14:49.952Z" }, + { url = "https://files.pythonhosted.org/packages/21/f5/ac11add39a0f447ac89353e6ca46666847051103649831c08a2800a14455/multidict-6.4.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7cf3bd54c56aa16fdb40028d545eaa8d051402b61533c21e84046e05513d5780", size = 232412, upload-time = "2025-05-19T14:14:51.812Z" }, + { url = "https://files.pythonhosted.org/packages/d9/11/4b551e2110cded705a3c13a1d4b6a11f73891eb5a1c449f1b2b6259e58a6/multidict-6.4.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f682c42003c7264134bfe886376299db4cc0c6cd06a3295b41b347044bcb5482", size = 231563, upload-time = "2025-05-19T14:14:53.262Z" }, + { url = "https://files.pythonhosted.org/packages/4c/02/751530c19e78fe73b24c3da66618eda0aa0d7f6e7aa512e46483de6be210/multidict-6.4.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a920f9cf2abdf6e493c519492d892c362007f113c94da4c239ae88429835bad1", size = 223811, upload-time = "2025-05-19T14:14:55.232Z" }, + { url = "https://files.pythonhosted.org/packages/c7/cb/2be8a214643056289e51ca356026c7b2ce7225373e7a1f8c8715efee8988/multidict-6.4.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:530d86827a2df6504526106b4c104ba19044594f8722d3e87714e847c74a0275", size = 216524, upload-time = "2025-05-19T14:14:57.226Z" }, + { url = "https://files.pythonhosted.org/packages/19/f3/6d5011ec375c09081f5250af58de85f172bfcaafebff286d8089243c4bd4/multidict-6.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ecde56ea2439b96ed8a8d826b50c57364612ddac0438c39e473fafad7ae1c23b", size = 229012, upload-time = "2025-05-19T14:14:58.597Z" }, + { url = "https://files.pythonhosted.org/packages/67/9c/ca510785df5cf0eaf5b2a8132d7d04c1ce058dcf2c16233e596ce37a7f8e/multidict-6.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:dc8c9736d8574b560634775ac0def6bdc1661fc63fa27ffdfc7264c565bcb4f2", size = 226765, upload-time = "2025-05-19T14:15:00.048Z" }, + { url = "https://files.pythonhosted.org/packages/36/c8/ca86019994e92a0f11e642bda31265854e6ea7b235642f0477e8c2e25c1f/multidict-6.4.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7f3d3b3c34867579ea47cbd6c1f2ce23fbfd20a273b6f9e3177e256584f1eacc", size = 222888, upload-time = "2025-05-19T14:15:01.568Z" }, + { url = "https://files.pythonhosted.org/packages/c6/67/bc25a8e8bd522935379066950ec4e2277f9b236162a73548a2576d4b9587/multidict-6.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:87a728af265e08f96b6318ebe3c0f68b9335131f461efab2fc64cc84a44aa6ed", size = 234041, upload-time = "2025-05-19T14:15:03.759Z" }, + { url = "https://files.pythonhosted.org/packages/f1/a0/70c4c2d12857fccbe607b334b7ee28b6b5326c322ca8f73ee54e70d76484/multidict-6.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9f193eeda1857f8e8d3079a4abd258f42ef4a4bc87388452ed1e1c4d2b0c8740", size = 231046, upload-time = "2025-05-19T14:15:05.698Z" }, + { url = "https://files.pythonhosted.org/packages/c1/0f/52954601d02d39742aab01d6b92f53c1dd38b2392248154c50797b4df7f1/multidict-6.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be06e73c06415199200e9a2324a11252a3d62030319919cde5e6950ffeccf72e", size = 227106, upload-time = "2025-05-19T14:15:07.124Z" }, + { url = "https://files.pythonhosted.org/packages/af/24/679d83ec4379402d28721790dce818e5d6b9f94ce1323a556fb17fa9996c/multidict-6.4.4-cp312-cp312-win32.whl", hash = "sha256:622f26ea6a7e19b7c48dd9228071f571b2fbbd57a8cd71c061e848f281550e6b", size = 35351, upload-time = "2025-05-19T14:15:08.556Z" }, + { url = "https://files.pythonhosted.org/packages/52/ef/40d98bc5f986f61565f9b345f102409534e29da86a6454eb6b7c00225a13/multidict-6.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:5e2bcda30d5009996ff439e02a9f2b5c3d64a20151d34898c000a6281faa3781", size = 38791, upload-time = "2025-05-19T14:15:09.825Z" }, + { url = "https://files.pythonhosted.org/packages/df/2a/e166d2ffbf4b10131b2d5b0e458f7cee7d986661caceae0de8753042d4b2/multidict-6.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:82ffabefc8d84c2742ad19c37f02cde5ec2a1ee172d19944d380f920a340e4b9", size = 64123, upload-time = "2025-05-19T14:15:11.044Z" }, + { url = "https://files.pythonhosted.org/packages/8c/96/e200e379ae5b6f95cbae472e0199ea98913f03d8c9a709f42612a432932c/multidict-6.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6a2f58a66fe2c22615ad26156354005391e26a2f3721c3621504cd87c1ea87bf", size = 38049, upload-time = "2025-05-19T14:15:12.902Z" }, + { url = "https://files.pythonhosted.org/packages/75/fb/47afd17b83f6a8c7fa863c6d23ac5ba6a0e6145ed8a6bcc8da20b2b2c1d2/multidict-6.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5883d6ee0fd9d8a48e9174df47540b7545909841ac82354c7ae4cbe9952603bd", size = 37078, upload-time = "2025-05-19T14:15:14.282Z" }, + { url = "https://files.pythonhosted.org/packages/fa/70/1af3143000eddfb19fd5ca5e78393985ed988ac493bb859800fe0914041f/multidict-6.4.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9abcf56a9511653fa1d052bfc55fbe53dbee8f34e68bd6a5a038731b0ca42d15", size = 224097, upload-time = "2025-05-19T14:15:15.566Z" }, + { url = "https://files.pythonhosted.org/packages/b1/39/d570c62b53d4fba844e0378ffbcd02ac25ca423d3235047013ba2f6f60f8/multidict-6.4.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6ed5ae5605d4ad5a049fad2a28bb7193400700ce2f4ae484ab702d1e3749c3f9", size = 230768, upload-time = "2025-05-19T14:15:17.308Z" }, + { url = "https://files.pythonhosted.org/packages/fd/f8/ed88f2c4d06f752b015933055eb291d9bc184936903752c66f68fb3c95a7/multidict-6.4.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbfcb60396f9bcfa63e017a180c3105b8c123a63e9d1428a36544e7d37ca9e20", size = 231331, upload-time = "2025-05-19T14:15:18.73Z" }, + { url = "https://files.pythonhosted.org/packages/9c/6f/8e07cffa32f483ab887b0d56bbd8747ac2c1acd00dc0af6fcf265f4a121e/multidict-6.4.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b0f1987787f5f1e2076b59692352ab29a955b09ccc433c1f6b8e8e18666f608b", size = 230169, upload-time = "2025-05-19T14:15:20.179Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2b/5dcf173be15e42f330110875a2668ddfc208afc4229097312212dc9c1236/multidict-6.4.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1d0121ccce8c812047d8d43d691a1ad7641f72c4f730474878a5aeae1b8ead8c", size = 222947, upload-time = "2025-05-19T14:15:21.714Z" }, + { url = "https://files.pythonhosted.org/packages/39/75/4ddcbcebe5ebcd6faa770b629260d15840a5fc07ce8ad295a32e14993726/multidict-6.4.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:83ec4967114295b8afd120a8eec579920c882831a3e4c3331d591a8e5bfbbc0f", size = 215761, upload-time = "2025-05-19T14:15:23.242Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c9/55e998ae45ff15c5608e384206aa71a11e1b7f48b64d166db400b14a3433/multidict-6.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:995f985e2e268deaf17867801b859a282e0448633f1310e3704b30616d269d69", size = 227605, upload-time = "2025-05-19T14:15:24.763Z" }, + { url = "https://files.pythonhosted.org/packages/04/49/c2404eac74497503c77071bd2e6f88c7e94092b8a07601536b8dbe99be50/multidict-6.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d832c608f94b9f92a0ec8b7e949be7792a642b6e535fcf32f3e28fab69eeb046", size = 226144, upload-time = "2025-05-19T14:15:26.249Z" }, + { url = "https://files.pythonhosted.org/packages/62/c5/0cd0c3c6f18864c40846aa2252cd69d308699cb163e1c0d989ca301684da/multidict-6.4.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d21c1212171cf7da703c5b0b7a0e85be23b720818aef502ad187d627316d5645", size = 221100, upload-time = "2025-05-19T14:15:28.303Z" }, + { url = "https://files.pythonhosted.org/packages/71/7b/f2f3887bea71739a046d601ef10e689528d4f911d84da873b6be9194ffea/multidict-6.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:cbebaa076aaecad3d4bb4c008ecc73b09274c952cf6a1b78ccfd689e51f5a5b0", size = 232731, upload-time = "2025-05-19T14:15:30.263Z" }, + { url = "https://files.pythonhosted.org/packages/e5/b3/d9de808349df97fa75ec1372758701b5800ebad3c46ae377ad63058fbcc6/multidict-6.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:c93a6fb06cc8e5d3628b2b5fda215a5db01e8f08fc15fadd65662d9b857acbe4", size = 229637, upload-time = "2025-05-19T14:15:33.337Z" }, + { url = "https://files.pythonhosted.org/packages/5e/57/13207c16b615eb4f1745b44806a96026ef8e1b694008a58226c2d8f5f0a5/multidict-6.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8cd8f81f1310182362fb0c7898145ea9c9b08a71081c5963b40ee3e3cac589b1", size = 225594, upload-time = "2025-05-19T14:15:34.832Z" }, + { url = "https://files.pythonhosted.org/packages/3a/e4/d23bec2f70221604f5565000632c305fc8f25ba953e8ce2d8a18842b9841/multidict-6.4.4-cp313-cp313-win32.whl", hash = "sha256:3e9f1cd61a0ab857154205fb0b1f3d3ace88d27ebd1409ab7af5096e409614cd", size = 35359, upload-time = "2025-05-19T14:15:36.246Z" }, + { url = "https://files.pythonhosted.org/packages/a7/7a/cfe1a47632be861b627f46f642c1d031704cc1c0f5c0efbde2ad44aa34bd/multidict-6.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:8ffb40b74400e4455785c2fa37eba434269149ec525fc8329858c862e4b35373", size = 38903, upload-time = "2025-05-19T14:15:37.507Z" }, + { url = "https://files.pythonhosted.org/packages/68/7b/15c259b0ab49938a0a1c8f3188572802704a779ddb294edc1b2a72252e7c/multidict-6.4.4-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:6a602151dbf177be2450ef38966f4be3467d41a86c6a845070d12e17c858a156", size = 68895, upload-time = "2025-05-19T14:15:38.856Z" }, + { url = "https://files.pythonhosted.org/packages/f1/7d/168b5b822bccd88142e0a3ce985858fea612404edd228698f5af691020c9/multidict-6.4.4-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0d2b9712211b860d123815a80b859075d86a4d54787e247d7fbee9db6832cf1c", size = 40183, upload-time = "2025-05-19T14:15:40.197Z" }, + { url = "https://files.pythonhosted.org/packages/e0/b7/d4b8d98eb850ef28a4922ba508c31d90715fd9b9da3801a30cea2967130b/multidict-6.4.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d2fa86af59f8fc1972e121ade052145f6da22758f6996a197d69bb52f8204e7e", size = 39592, upload-time = "2025-05-19T14:15:41.508Z" }, + { url = "https://files.pythonhosted.org/packages/18/28/a554678898a19583548e742080cf55d169733baf57efc48c2f0273a08583/multidict-6.4.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50855d03e9e4d66eab6947ba688ffb714616f985838077bc4b490e769e48da51", size = 226071, upload-time = "2025-05-19T14:15:42.877Z" }, + { url = "https://files.pythonhosted.org/packages/ee/dc/7ba6c789d05c310e294f85329efac1bf5b450338d2542498db1491a264df/multidict-6.4.4-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5bce06b83be23225be1905dcdb6b789064fae92499fbc458f59a8c0e68718601", size = 222597, upload-time = "2025-05-19T14:15:44.412Z" }, + { url = "https://files.pythonhosted.org/packages/24/4f/34eadbbf401b03768dba439be0fb94b0d187facae9142821a3d5599ccb3b/multidict-6.4.4-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:66ed0731f8e5dfd8369a883b6e564aca085fb9289aacabd9decd70568b9a30de", size = 228253, upload-time = "2025-05-19T14:15:46.474Z" }, + { url = "https://files.pythonhosted.org/packages/c0/e6/493225a3cdb0d8d80d43a94503fc313536a07dae54a3f030d279e629a2bc/multidict-6.4.4-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:329ae97fc2f56f44d91bc47fe0972b1f52d21c4b7a2ac97040da02577e2daca2", size = 226146, upload-time = "2025-05-19T14:15:48.003Z" }, + { url = "https://files.pythonhosted.org/packages/2f/70/e411a7254dc3bff6f7e6e004303b1b0591358e9f0b7c08639941e0de8bd6/multidict-6.4.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c27e5dcf520923d6474d98b96749e6805f7677e93aaaf62656005b8643f907ab", size = 220585, upload-time = "2025-05-19T14:15:49.546Z" }, + { url = "https://files.pythonhosted.org/packages/08/8f/beb3ae7406a619100d2b1fb0022c3bb55a8225ab53c5663648ba50dfcd56/multidict-6.4.4-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:058cc59b9e9b143cc56715e59e22941a5d868c322242278d28123a5d09cdf6b0", size = 212080, upload-time = "2025-05-19T14:15:51.151Z" }, + { url = "https://files.pythonhosted.org/packages/9c/ec/355124e9d3d01cf8edb072fd14947220f357e1c5bc79c88dff89297e9342/multidict-6.4.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:69133376bc9a03f8c47343d33f91f74a99c339e8b58cea90433d8e24bb298031", size = 226558, upload-time = "2025-05-19T14:15:52.665Z" }, + { url = "https://files.pythonhosted.org/packages/fd/22/d2b95cbebbc2ada3be3812ea9287dcc9712d7f1a012fad041770afddb2ad/multidict-6.4.4-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:d6b15c55721b1b115c5ba178c77104123745b1417527ad9641a4c5e2047450f0", size = 212168, upload-time = "2025-05-19T14:15:55.279Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c5/62bfc0b2f9ce88326dbe7179f9824a939c6c7775b23b95de777267b9725c/multidict-6.4.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:a887b77f51d3d41e6e1a63cf3bc7ddf24de5939d9ff69441387dfefa58ac2e26", size = 217970, upload-time = "2025-05-19T14:15:56.806Z" }, + { url = "https://files.pythonhosted.org/packages/79/74/977cea1aadc43ff1c75d23bd5bc4768a8fac98c14e5878d6ee8d6bab743c/multidict-6.4.4-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:632a3bf8f1787f7ef7d3c2f68a7bde5be2f702906f8b5842ad6da9d974d0aab3", size = 226980, upload-time = "2025-05-19T14:15:58.313Z" }, + { url = "https://files.pythonhosted.org/packages/48/fc/cc4a1a2049df2eb84006607dc428ff237af38e0fcecfdb8a29ca47b1566c/multidict-6.4.4-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a145c550900deb7540973c5cdb183b0d24bed6b80bf7bddf33ed8f569082535e", size = 220641, upload-time = "2025-05-19T14:15:59.866Z" }, + { url = "https://files.pythonhosted.org/packages/3b/6a/a7444d113ab918701988d4abdde373dbdfd2def7bd647207e2bf645c7eac/multidict-6.4.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cc5d83c6619ca5c9672cb78b39ed8542f1975a803dee2cda114ff73cbb076edd", size = 221728, upload-time = "2025-05-19T14:16:01.535Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b0/fdf4c73ad1c55e0f4dbbf2aa59dd37037334091f9a4961646d2b7ac91a86/multidict-6.4.4-cp313-cp313t-win32.whl", hash = "sha256:3312f63261b9df49be9d57aaa6abf53a6ad96d93b24f9cc16cf979956355ce6e", size = 41913, upload-time = "2025-05-19T14:16:03.199Z" }, + { url = "https://files.pythonhosted.org/packages/8e/92/27989ecca97e542c0d01d05a98a5ae12198a243a9ee12563a0313291511f/multidict-6.4.4-cp313-cp313t-win_amd64.whl", hash = "sha256:ba852168d814b2c73333073e1c7116d9395bea69575a01b0b3c89d2d5a87c8fb", size = 46112, upload-time = "2025-05-19T14:16:04.909Z" }, + { url = "https://files.pythonhosted.org/packages/84/5d/e17845bb0fa76334477d5de38654d27946d5b5d3695443987a094a71b440/multidict-6.4.4-py3-none-any.whl", hash = "sha256:bd4557071b561a8b3b6075c3ce93cf9bfb6182cb241805c3d66ced3b75eff4ac", size = 10481, upload-time = "2025-05-19T14:16:36.024Z" }, +] + +[[package]] +name = "mypy" +version = "1.16.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d4/38/13c2f1abae94d5ea0354e146b95a1be9b2137a0d506728e0da037c4276f6/mypy-1.16.0.tar.gz", hash = "sha256:84b94283f817e2aa6350a14b4a8fb2a35a53c286f97c9d30f53b63620e7af8ab", size = 3323139, upload-time = "2025-05-29T13:46:12.532Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/64/5e/a0485f0608a3d67029d3d73cec209278b025e3493a3acfda3ef3a88540fd/mypy-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7909541fef256527e5ee9c0a7e2aeed78b6cda72ba44298d1334fe7881b05c5c", size = 10967416, upload-time = "2025-05-29T13:34:17.783Z" }, + { url = "https://files.pythonhosted.org/packages/4b/53/5837c221f74c0d53a4bfc3003296f8179c3a2a7f336d7de7bbafbe96b688/mypy-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e71d6f0090c2256c713ed3d52711d01859c82608b5d68d4fa01a3fe30df95571", size = 10087654, upload-time = "2025-05-29T13:32:37.878Z" }, + { url = "https://files.pythonhosted.org/packages/29/59/5fd2400352c3093bed4c09017fe671d26bc5bb7e6ef2d4bf85f2a2488104/mypy-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:936ccfdd749af4766be824268bfe22d1db9eb2f34a3ea1d00ffbe5b5265f5491", size = 11875192, upload-time = "2025-05-29T13:34:54.281Z" }, + { url = "https://files.pythonhosted.org/packages/ad/3e/4bfec74663a64c2012f3e278dbc29ffe82b121bc551758590d1b6449ec0c/mypy-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4086883a73166631307fdd330c4a9080ce24913d4f4c5ec596c601b3a4bdd777", size = 12612939, upload-time = "2025-05-29T13:33:14.766Z" }, + { url = "https://files.pythonhosted.org/packages/88/1f/fecbe3dcba4bf2ca34c26ca016383a9676711907f8db4da8354925cbb08f/mypy-1.16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:feec38097f71797da0231997e0de3a58108c51845399669ebc532c815f93866b", size = 12874719, upload-time = "2025-05-29T13:21:52.09Z" }, + { url = "https://files.pythonhosted.org/packages/f3/51/c2d280601cd816c43dfa512a759270d5a5ef638d7ac9bea9134c8305a12f/mypy-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:09a8da6a0ee9a9770b8ff61b39c0bb07971cda90e7297f4213741b48a0cc8d93", size = 9487053, upload-time = "2025-05-29T13:33:29.797Z" }, + { url = "https://files.pythonhosted.org/packages/24/c4/ff2f79db7075c274fe85b5fff8797d29c6b61b8854c39e3b7feb556aa377/mypy-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9f826aaa7ff8443bac6a494cf743f591488ea940dd360e7dd330e30dd772a5ab", size = 10884498, upload-time = "2025-05-29T13:18:54.066Z" }, + { url = "https://files.pythonhosted.org/packages/02/07/12198e83006235f10f6a7808917376b5d6240a2fd5dce740fe5d2ebf3247/mypy-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82d056e6faa508501af333a6af192c700b33e15865bda49611e3d7d8358ebea2", size = 10011755, upload-time = "2025-05-29T13:34:00.851Z" }, + { url = "https://files.pythonhosted.org/packages/f1/9b/5fd5801a72b5d6fb6ec0105ea1d0e01ab2d4971893076e558d4b6d6b5f80/mypy-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:089bedc02307c2548eb51f426e085546db1fa7dd87fbb7c9fa561575cf6eb1ff", size = 11800138, upload-time = "2025-05-29T13:32:55.082Z" }, + { url = "https://files.pythonhosted.org/packages/2e/81/a117441ea5dfc3746431e51d78a4aca569c677aa225bca2cc05a7c239b61/mypy-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a2322896003ba66bbd1318c10d3afdfe24e78ef12ea10e2acd985e9d684a666", size = 12533156, upload-time = "2025-05-29T13:19:12.963Z" }, + { url = "https://files.pythonhosted.org/packages/3f/38/88ec57c6c86014d3f06251e00f397b5a7daa6888884d0abf187e4f5f587f/mypy-1.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:021a68568082c5b36e977d54e8f1de978baf401a33884ffcea09bd8e88a98f4c", size = 12742426, upload-time = "2025-05-29T13:20:22.72Z" }, + { url = "https://files.pythonhosted.org/packages/bd/53/7e9d528433d56e6f6f77ccf24af6ce570986c2d98a5839e4c2009ef47283/mypy-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:54066fed302d83bf5128632d05b4ec68412e1f03ef2c300434057d66866cea4b", size = 9478319, upload-time = "2025-05-29T13:21:17.582Z" }, + { url = "https://files.pythonhosted.org/packages/70/cf/158e5055e60ca2be23aec54a3010f89dcffd788732634b344fc9cb1e85a0/mypy-1.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5436d11e89a3ad16ce8afe752f0f373ae9620841c50883dc96f8b8805620b13", size = 11062927, upload-time = "2025-05-29T13:35:52.328Z" }, + { url = "https://files.pythonhosted.org/packages/94/34/cfff7a56be1609f5d10ef386342ce3494158e4d506516890142007e6472c/mypy-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f2622af30bf01d8fc36466231bdd203d120d7a599a6d88fb22bdcb9dbff84090", size = 10083082, upload-time = "2025-05-29T13:35:33.378Z" }, + { url = "https://files.pythonhosted.org/packages/b3/7f/7242062ec6288c33d8ad89574df87c3903d394870e5e6ba1699317a65075/mypy-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d045d33c284e10a038f5e29faca055b90eee87da3fc63b8889085744ebabb5a1", size = 11828306, upload-time = "2025-05-29T13:21:02.164Z" }, + { url = "https://files.pythonhosted.org/packages/6f/5f/b392f7b4f659f5b619ce5994c5c43caab3d80df2296ae54fa888b3d17f5a/mypy-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4968f14f44c62e2ec4a038c8797a87315be8df7740dc3ee8d3bfe1c6bf5dba8", size = 12702764, upload-time = "2025-05-29T13:20:42.826Z" }, + { url = "https://files.pythonhosted.org/packages/9b/c0/7646ef3a00fa39ac9bc0938626d9ff29d19d733011be929cfea59d82d136/mypy-1.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eb14a4a871bb8efb1e4a50360d4e3c8d6c601e7a31028a2c79f9bb659b63d730", size = 12896233, upload-time = "2025-05-29T13:18:37.446Z" }, + { url = "https://files.pythonhosted.org/packages/6d/38/52f4b808b3fef7f0ef840ee8ff6ce5b5d77381e65425758d515cdd4f5bb5/mypy-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:bd4e1ebe126152a7bbaa4daedd781c90c8f9643c79b9748caa270ad542f12bec", size = 9565547, upload-time = "2025-05-29T13:20:02.836Z" }, + { url = "https://files.pythonhosted.org/packages/97/9c/ca03bdbefbaa03b264b9318a98950a9c683e06472226b55472f96ebbc53d/mypy-1.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a9e056237c89f1587a3be1a3a70a06a698d25e2479b9a2f57325ddaaffc3567b", size = 11059753, upload-time = "2025-05-29T13:18:18.167Z" }, + { url = "https://files.pythonhosted.org/packages/36/92/79a969b8302cfe316027c88f7dc6fee70129490a370b3f6eb11d777749d0/mypy-1.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0b07e107affb9ee6ce1f342c07f51552d126c32cd62955f59a7db94a51ad12c0", size = 10073338, upload-time = "2025-05-29T13:19:48.079Z" }, + { url = "https://files.pythonhosted.org/packages/14/9b/a943f09319167da0552d5cd722104096a9c99270719b1afeea60d11610aa/mypy-1.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6fb60cbd85dc65d4d63d37cb5c86f4e3a301ec605f606ae3a9173e5cf34997b", size = 11827764, upload-time = "2025-05-29T13:46:04.47Z" }, + { url = "https://files.pythonhosted.org/packages/ec/64/ff75e71c65a0cb6ee737287c7913ea155845a556c64144c65b811afdb9c7/mypy-1.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7e32297a437cc915599e0578fa6bc68ae6a8dc059c9e009c628e1c47f91495d", size = 12701356, upload-time = "2025-05-29T13:35:13.553Z" }, + { url = "https://files.pythonhosted.org/packages/0a/ad/0e93c18987a1182c350f7a5fab70550852f9fabe30ecb63bfbe51b602074/mypy-1.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:afe420c9380ccec31e744e8baff0d406c846683681025db3531b32db56962d52", size = 12900745, upload-time = "2025-05-29T13:17:24.409Z" }, + { url = "https://files.pythonhosted.org/packages/28/5d/036c278d7a013e97e33f08c047fe5583ab4f1fc47c9a49f985f1cdd2a2d7/mypy-1.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:55f9076c6ce55dd3f8cd0c6fff26a008ca8e5131b89d5ba6d86bd3f47e736eeb", size = 9572200, upload-time = "2025-05-29T13:33:44.92Z" }, + { url = "https://files.pythonhosted.org/packages/99/a3/6ed10530dec8e0fdc890d81361260c9ef1f5e5c217ad8c9b21ecb2b8366b/mypy-1.16.0-py3-none-any.whl", hash = "sha256:29e1499864a3888bca5c1542f2d7232c6e586295183320caa95758fc84034031", size = 2265773, upload-time = "2025-05-29T13:35:18.762Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11' and platform_python_implementation != 'PyPy'", + "python_full_version < '3.11' and platform_python_implementation == 'PyPy'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, +] + +[[package]] +name = "numpy" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'", + "python_full_version >= '3.12' and platform_python_implementation != 'PyPy'", + "python_full_version == '3.11.*' and platform_python_implementation == 'PyPy'", + "python_full_version == '3.11.*' and platform_python_implementation != 'PyPy'", +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/db/8e12381333aea300890829a0a36bfa738cac95475d88982d538725143fd9/numpy-2.3.0.tar.gz", hash = "sha256:581f87f9e9e9db2cba2141400e160e9dd644ee248788d6f90636eeb8fd9260a6", size = 20382813, upload-time = "2025-06-07T14:54:32.608Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/5f/df67435257d827eb3b8af66f585223dc2c3f2eb7ad0b50cb1dae2f35f494/numpy-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c3c9fdde0fa18afa1099d6257eb82890ea4f3102847e692193b54e00312a9ae9", size = 21199688, upload-time = "2025-06-07T14:36:52.067Z" }, + { url = "https://files.pythonhosted.org/packages/e5/ce/aad219575055d6c9ef29c8c540c81e1c38815d3be1fe09cdbe53d48ee838/numpy-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46d16f72c2192da7b83984aa5455baee640e33a9f1e61e656f29adf55e406c2b", size = 14359277, upload-time = "2025-06-07T14:37:15.325Z" }, + { url = "https://files.pythonhosted.org/packages/29/6b/2d31da8e6d2ec99bed54c185337a87f8fbeccc1cd9804e38217e92f3f5e2/numpy-2.3.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a0be278be9307c4ab06b788f2a077f05e180aea817b3e41cebbd5aaf7bd85ed3", size = 5376069, upload-time = "2025-06-07T14:37:25.636Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2a/6c59a062397553ec7045c53d5fcdad44e4536e54972faa2ba44153bca984/numpy-2.3.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:99224862d1412d2562248d4710126355d3a8db7672170a39d6909ac47687a8a4", size = 6913057, upload-time = "2025-06-07T14:37:37.215Z" }, + { url = "https://files.pythonhosted.org/packages/d5/5a/8df16f258d28d033e4f359e29d3aeb54663243ac7b71504e89deeb813202/numpy-2.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:2393a914db64b0ead0ab80c962e42d09d5f385802006a6c87835acb1f58adb96", size = 14568083, upload-time = "2025-06-07T14:37:59.337Z" }, + { url = "https://files.pythonhosted.org/packages/0a/92/0528a563dfc2cdccdcb208c0e241a4bb500d7cde218651ffb834e8febc50/numpy-2.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:7729c8008d55e80784bd113787ce876ca117185c579c0d626f59b87d433ea779", size = 16929402, upload-time = "2025-06-07T14:38:24.343Z" }, + { url = "https://files.pythonhosted.org/packages/e4/2f/e7a8c8d4a2212c527568d84f31587012cf5497a7271ea1f23332142f634e/numpy-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:06d4fb37a8d383b769281714897420c5cc3545c79dc427df57fc9b852ee0bf58", size = 15879193, upload-time = "2025-06-07T14:38:48.007Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c3/dada3f005953847fe35f42ac0fe746f6e1ea90b4c6775e4be605dcd7b578/numpy-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:c39ec392b5db5088259c68250e342612db82dc80ce044cf16496cf14cf6bc6f8", size = 18665318, upload-time = "2025-06-07T14:39:15.794Z" }, + { url = "https://files.pythonhosted.org/packages/3b/ae/3f448517dedefc8dd64d803f9d51a8904a48df730e00a3c5fb1e75a60620/numpy-2.3.0-cp311-cp311-win32.whl", hash = "sha256:ee9d3ee70d62827bc91f3ea5eee33153212c41f639918550ac0475e3588da59f", size = 6601108, upload-time = "2025-06-07T14:39:27.176Z" }, + { url = "https://files.pythonhosted.org/packages/8c/4a/556406d2bb2b9874c8cbc840c962683ac28f21efbc9b01177d78f0199ca1/numpy-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:43c55b6a860b0eb44d42341438b03513cf3879cb3617afb749ad49307e164edd", size = 13021525, upload-time = "2025-06-07T14:39:46.637Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ee/bf54278aef30335ffa9a189f869ea09e1a195b3f4b93062164a3b02678a7/numpy-2.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:2e6a1409eee0cb0316cb64640a49a49ca44deb1a537e6b1121dc7c458a1299a8", size = 10170327, upload-time = "2025-06-07T14:40:02.703Z" }, + { url = "https://files.pythonhosted.org/packages/89/59/9df493df81ac6f76e9f05cdbe013cdb0c9a37b434f6e594f5bd25e278908/numpy-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:389b85335838155a9076e9ad7f8fdba0827496ec2d2dc32ce69ce7898bde03ba", size = 20897025, upload-time = "2025-06-07T14:40:33.558Z" }, + { url = "https://files.pythonhosted.org/packages/2f/86/4ff04335901d6cf3a6bb9c748b0097546ae5af35e455ae9b962ebff4ecd7/numpy-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9498f60cd6bb8238d8eaf468a3d5bb031d34cd12556af53510f05fcf581c1b7e", size = 14129882, upload-time = "2025-06-07T14:40:55.034Z" }, + { url = "https://files.pythonhosted.org/packages/71/8d/a942cd4f959de7f08a79ab0c7e6cecb7431d5403dce78959a726f0f57aa1/numpy-2.3.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:622a65d40d8eb427d8e722fd410ac3ad4958002f109230bc714fa551044ebae2", size = 5110181, upload-time = "2025-06-07T14:41:04.4Z" }, + { url = "https://files.pythonhosted.org/packages/86/5d/45850982efc7b2c839c5626fb67fbbc520d5b0d7c1ba1ae3651f2f74c296/numpy-2.3.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:b9446d9d8505aadadb686d51d838f2b6688c9e85636a0c3abaeb55ed54756459", size = 6647581, upload-time = "2025-06-07T14:41:14.695Z" }, + { url = "https://files.pythonhosted.org/packages/1a/c0/c871d4a83f93b00373d3eebe4b01525eee8ef10b623a335ec262b58f4dc1/numpy-2.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:50080245365d75137a2bf46151e975de63146ae6d79f7e6bd5c0e85c9931d06a", size = 14262317, upload-time = "2025-06-07T14:41:35.862Z" }, + { url = "https://files.pythonhosted.org/packages/b7/f6/bc47f5fa666d5ff4145254f9e618d56e6a4ef9b874654ca74c19113bb538/numpy-2.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:c24bb4113c66936eeaa0dc1e47c74770453d34f46ee07ae4efd853a2ed1ad10a", size = 16633919, upload-time = "2025-06-07T14:42:00.622Z" }, + { url = "https://files.pythonhosted.org/packages/f5/b4/65f48009ca0c9b76df5f404fccdea5a985a1bb2e34e97f21a17d9ad1a4ba/numpy-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4d8d294287fdf685281e671886c6dcdf0291a7c19db3e5cb4178d07ccf6ecc67", size = 15567651, upload-time = "2025-06-07T14:42:24.429Z" }, + { url = "https://files.pythonhosted.org/packages/f1/62/5367855a2018578e9334ed08252ef67cc302e53edc869666f71641cad40b/numpy-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6295f81f093b7f5769d1728a6bd8bf7466de2adfa771ede944ce6711382b89dc", size = 18361723, upload-time = "2025-06-07T14:42:51.167Z" }, + { url = "https://files.pythonhosted.org/packages/d4/75/5baed8cd867eabee8aad1e74d7197d73971d6a3d40c821f1848b8fab8b84/numpy-2.3.0-cp312-cp312-win32.whl", hash = "sha256:e6648078bdd974ef5d15cecc31b0c410e2e24178a6e10bf511e0557eed0f2570", size = 6318285, upload-time = "2025-06-07T14:43:02.052Z" }, + { url = "https://files.pythonhosted.org/packages/bc/49/d5781eaa1a15acb3b3a3f49dc9e2ff18d92d0ce5c2976f4ab5c0a7360250/numpy-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:0898c67a58cdaaf29994bc0e2c65230fd4de0ac40afaf1584ed0b02cd74c6fdd", size = 12732594, upload-time = "2025-06-07T14:43:21.071Z" }, + { url = "https://files.pythonhosted.org/packages/c2/1c/6d343e030815c7c97a1f9fbad00211b47717c7fe446834c224bd5311e6f1/numpy-2.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:bd8df082b6c4695753ad6193018c05aac465d634834dca47a3ae06d4bb22d9ea", size = 9891498, upload-time = "2025-06-07T14:43:36.332Z" }, + { url = "https://files.pythonhosted.org/packages/73/fc/1d67f751fd4dbafc5780244fe699bc4084268bad44b7c5deb0492473127b/numpy-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5754ab5595bfa2c2387d241296e0381c21f44a4b90a776c3c1d39eede13a746a", size = 20889633, upload-time = "2025-06-07T14:44:06.839Z" }, + { url = "https://files.pythonhosted.org/packages/e8/95/73ffdb69e5c3f19ec4530f8924c4386e7ba097efc94b9c0aff607178ad94/numpy-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d11fa02f77752d8099573d64e5fe33de3229b6632036ec08f7080f46b6649959", size = 14151683, upload-time = "2025-06-07T14:44:28.847Z" }, + { url = "https://files.pythonhosted.org/packages/64/d5/06d4bb31bb65a1d9c419eb5676173a2f90fd8da3c59f816cc54c640ce265/numpy-2.3.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:aba48d17e87688a765ab1cd557882052f238e2f36545dfa8e29e6a91aef77afe", size = 5102683, upload-time = "2025-06-07T14:44:38.417Z" }, + { url = "https://files.pythonhosted.org/packages/12/8b/6c2cef44f8ccdc231f6b56013dff1d71138c48124334aded36b1a1b30c5a/numpy-2.3.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4dc58865623023b63b10d52f18abaac3729346a7a46a778381e0e3af4b7f3beb", size = 6640253, upload-time = "2025-06-07T14:44:49.359Z" }, + { url = "https://files.pythonhosted.org/packages/62/aa/fca4bf8de3396ddb59544df9b75ffe5b73096174de97a9492d426f5cd4aa/numpy-2.3.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:df470d376f54e052c76517393fa443758fefcdd634645bc9c1f84eafc67087f0", size = 14258658, upload-time = "2025-06-07T14:45:10.156Z" }, + { url = "https://files.pythonhosted.org/packages/1c/12/734dce1087eed1875f2297f687e671cfe53a091b6f2f55f0c7241aad041b/numpy-2.3.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:87717eb24d4a8a64683b7a4e91ace04e2f5c7c77872f823f02a94feee186168f", size = 16628765, upload-time = "2025-06-07T14:45:35.076Z" }, + { url = "https://files.pythonhosted.org/packages/48/03/ffa41ade0e825cbcd5606a5669962419528212a16082763fc051a7247d76/numpy-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d8fa264d56882b59dcb5ea4d6ab6f31d0c58a57b41aec605848b6eb2ef4a43e8", size = 15564335, upload-time = "2025-06-07T14:45:58.797Z" }, + { url = "https://files.pythonhosted.org/packages/07/58/869398a11863310aee0ff85a3e13b4c12f20d032b90c4b3ee93c3b728393/numpy-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e651756066a0eaf900916497e20e02fe1ae544187cb0fe88de981671ee7f6270", size = 18360608, upload-time = "2025-06-07T14:46:25.687Z" }, + { url = "https://files.pythonhosted.org/packages/2f/8a/5756935752ad278c17e8a061eb2127c9a3edf4ba2c31779548b336f23c8d/numpy-2.3.0-cp313-cp313-win32.whl", hash = "sha256:e43c3cce3b6ae5f94696669ff2a6eafd9a6b9332008bafa4117af70f4b88be6f", size = 6310005, upload-time = "2025-06-07T14:50:13.138Z" }, + { url = "https://files.pythonhosted.org/packages/08/60/61d60cf0dfc0bf15381eaef46366ebc0c1a787856d1db0c80b006092af84/numpy-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:81ae0bf2564cf475f94be4a27ef7bcf8af0c3e28da46770fc904da9abd5279b5", size = 12729093, upload-time = "2025-06-07T14:50:31.82Z" }, + { url = "https://files.pythonhosted.org/packages/66/31/2f2f2d2b3e3c32d5753d01437240feaa32220b73258c9eef2e42a0832866/numpy-2.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:c8738baa52505fa6e82778580b23f945e3578412554d937093eac9205e845e6e", size = 9885689, upload-time = "2025-06-07T14:50:47.888Z" }, + { url = "https://files.pythonhosted.org/packages/f1/89/c7828f23cc50f607ceb912774bb4cff225ccae7131c431398ad8400e2c98/numpy-2.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:39b27d8b38942a647f048b675f134dd5a567f95bfff481f9109ec308515c51d8", size = 20986612, upload-time = "2025-06-07T14:46:56.077Z" }, + { url = "https://files.pythonhosted.org/packages/dd/46/79ecf47da34c4c50eedec7511e53d57ffdfd31c742c00be7dc1d5ffdb917/numpy-2.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0eba4a1ea88f9a6f30f56fdafdeb8da3774349eacddab9581a21234b8535d3d3", size = 14298953, upload-time = "2025-06-07T14:47:18.053Z" }, + { url = "https://files.pythonhosted.org/packages/59/44/f6caf50713d6ff4480640bccb2a534ce1d8e6e0960c8f864947439f0ee95/numpy-2.3.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:b0f1f11d0a1da54927436505a5a7670b154eac27f5672afc389661013dfe3d4f", size = 5225806, upload-time = "2025-06-07T14:47:27.524Z" }, + { url = "https://files.pythonhosted.org/packages/a6/43/e1fd1aca7c97e234dd05e66de4ab7a5be54548257efcdd1bc33637e72102/numpy-2.3.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:690d0a5b60a47e1f9dcec7b77750a4854c0d690e9058b7bef3106e3ae9117808", size = 6735169, upload-time = "2025-06-07T14:47:38.057Z" }, + { url = "https://files.pythonhosted.org/packages/84/89/f76f93b06a03177c0faa7ca94d0856c4e5c4bcaf3c5f77640c9ed0303e1c/numpy-2.3.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:8b51ead2b258284458e570942137155978583e407babc22e3d0ed7af33ce06f8", size = 14330701, upload-time = "2025-06-07T14:47:59.113Z" }, + { url = "https://files.pythonhosted.org/packages/aa/f5/4858c3e9ff7a7d64561b20580cf7cc5d085794bd465a19604945d6501f6c/numpy-2.3.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:aaf81c7b82c73bd9b45e79cfb9476cb9c29e937494bfe9092c26aece812818ad", size = 16692983, upload-time = "2025-06-07T14:48:24.196Z" }, + { url = "https://files.pythonhosted.org/packages/08/17/0e3b4182e691a10e9483bcc62b4bb8693dbf9ea5dc9ba0b77a60435074bb/numpy-2.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f420033a20b4f6a2a11f585f93c843ac40686a7c3fa514060a97d9de93e5e72b", size = 15641435, upload-time = "2025-06-07T14:48:47.712Z" }, + { url = "https://files.pythonhosted.org/packages/4e/d5/463279fda028d3c1efa74e7e8d507605ae87f33dbd0543cf4c4527c8b882/numpy-2.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:d344ca32ab482bcf8735d8f95091ad081f97120546f3d250240868430ce52555", size = 18433798, upload-time = "2025-06-07T14:49:14.866Z" }, + { url = "https://files.pythonhosted.org/packages/0e/1e/7a9d98c886d4c39a2b4d3a7c026bffcf8fbcaf518782132d12a301cfc47a/numpy-2.3.0-cp313-cp313t-win32.whl", hash = "sha256:48a2e8eaf76364c32a1feaa60d6925eaf32ed7a040183b807e02674305beef61", size = 6438632, upload-time = "2025-06-07T14:49:25.67Z" }, + { url = "https://files.pythonhosted.org/packages/fe/ab/66fc909931d5eb230107d016861824f335ae2c0533f422e654e5ff556784/numpy-2.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ba17f93a94e503551f154de210e4d50c5e3ee20f7e7a1b5f6ce3f22d419b93bb", size = 12868491, upload-time = "2025-06-07T14:49:44.898Z" }, + { url = "https://files.pythonhosted.org/packages/ee/e8/2c8a1c9e34d6f6d600c83d5ce5b71646c32a13f34ca5c518cc060639841c/numpy-2.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:f14e016d9409680959691c109be98c436c6249eaf7f118b424679793607b5944", size = 9935345, upload-time = "2025-06-07T14:50:02.311Z" }, + { url = "https://files.pythonhosted.org/packages/6a/a2/f8c1133f90eaa1c11bbbec1dc28a42054d0ce74bc2c9838c5437ba5d4980/numpy-2.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:80b46117c7359de8167cc00a2c7d823bdd505e8c7727ae0871025a86d668283b", size = 21070759, upload-time = "2025-06-07T14:51:18.241Z" }, + { url = "https://files.pythonhosted.org/packages/6c/e0/4c05fc44ba28463096eee5ae2a12832c8d2759cc5bcec34ae33386d3ff83/numpy-2.3.0-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:5814a0f43e70c061f47abd5857d120179609ddc32a613138cbb6c4e9e2dbdda5", size = 5301054, upload-time = "2025-06-07T14:51:27.413Z" }, + { url = "https://files.pythonhosted.org/packages/8a/3b/6c06cdebe922bbc2a466fe2105f50f661238ea223972a69c7deb823821e7/numpy-2.3.0-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:ef6c1e88fd6b81ac6d215ed71dc8cd027e54d4bf1d2682d362449097156267a2", size = 6817520, upload-time = "2025-06-07T14:51:38.015Z" }, + { url = "https://files.pythonhosted.org/packages/9d/a3/1e536797fd10eb3c5dbd2e376671667c9af19e241843548575267242ea02/numpy-2.3.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:33a5a12a45bb82d9997e2c0b12adae97507ad7c347546190a18ff14c28bbca12", size = 14398078, upload-time = "2025-06-07T14:52:00.122Z" }, + { url = "https://files.pythonhosted.org/packages/7c/61/9d574b10d9368ecb1a0c923952aa593510a20df4940aa615b3a71337c8db/numpy-2.3.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:54dfc8681c1906d239e95ab1508d0a533c4a9505e52ee2d71a5472b04437ef97", size = 16751324, upload-time = "2025-06-07T14:52:25.077Z" }, + { url = "https://files.pythonhosted.org/packages/39/de/bcad52ce972dc26232629ca3a99721fd4b22c1d2bda84d5db6541913ef9c/numpy-2.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:e017a8a251ff4d18d71f139e28bdc7c31edba7a507f72b1414ed902cbe48c74d", size = 12924237, upload-time = "2025-06-07T14:52:44.713Z" }, +] + +[[package]] +name = "oauthlib" +version = "3.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6d/fa/fbf4001037904031639e6bfbfc02badfc7e12f137a8afa254df6c4c8a670/oauthlib-3.2.2.tar.gz", hash = "sha256:9859c40929662bec5d64f34d01c99e093149682a3f38915dc0655d5a633dd918", size = 177352, upload-time = "2022-10-17T20:04:27.471Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/80/cab10959dc1faead58dc8384a781dfbf93cb4d33d50988f7a69f1b7c9bbe/oauthlib-3.2.2-py3-none-any.whl", hash = "sha256:8139f29aac13e25d502680e9e19963e83f16838d48a0d71c287fe40e7067fbca", size = 151688, upload-time = "2022-10-17T20:04:24.037Z" }, +] + +[[package]] +name = "packaging" +version = "25.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" }, +] + +[[package]] +name = "pandas" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "python-dateutil" }, + { name = "pytz" }, + { name = "tzdata" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/51/48f713c4c728d7c55ef7444ba5ea027c26998d96d1a40953b346438602fc/pandas-2.3.0.tar.gz", hash = "sha256:34600ab34ebf1131a7613a260a61dbe8b62c188ec0ea4c296da7c9a06b004133", size = 4484490, upload-time = "2025-06-05T03:27:54.133Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e2/2d/df6b98c736ba51b8eaa71229e8fcd91233a831ec00ab520e1e23090cc072/pandas-2.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:625466edd01d43b75b1883a64d859168e4556261a5035b32f9d743b67ef44634", size = 11527531, upload-time = "2025-06-05T03:25:48.648Z" }, + { url = "https://files.pythonhosted.org/packages/77/1c/3f8c331d223f86ba1d0ed7d3ed7fcf1501c6f250882489cc820d2567ddbf/pandas-2.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a6872d695c896f00df46b71648eea332279ef4077a409e2fe94220208b6bb675", size = 10774764, upload-time = "2025-06-05T03:25:53.228Z" }, + { url = "https://files.pythonhosted.org/packages/1b/45/d2599400fad7fe06b849bd40b52c65684bc88fbe5f0a474d0513d057a377/pandas-2.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4dd97c19bd06bc557ad787a15b6489d2614ddaab5d104a0310eb314c724b2d2", size = 11711963, upload-time = "2025-06-05T03:25:56.855Z" }, + { url = "https://files.pythonhosted.org/packages/66/f8/5508bc45e994e698dbc93607ee6b9b6eb67df978dc10ee2b09df80103d9e/pandas-2.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:034abd6f3db8b9880aaee98f4f5d4dbec7c4829938463ec046517220b2f8574e", size = 12349446, upload-time = "2025-06-05T03:26:01.292Z" }, + { url = "https://files.pythonhosted.org/packages/f7/fc/17851e1b1ea0c8456ba90a2f514c35134dd56d981cf30ccdc501a0adeac4/pandas-2.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:23c2b2dc5213810208ca0b80b8666670eb4660bbfd9d45f58592cc4ddcfd62e1", size = 12920002, upload-time = "2025-06-06T00:00:07.925Z" }, + { url = "https://files.pythonhosted.org/packages/a1/9b/8743be105989c81fa33f8e2a4e9822ac0ad4aaf812c00fee6bb09fc814f9/pandas-2.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:39ff73ec07be5e90330cc6ff5705c651ace83374189dcdcb46e6ff54b4a72cd6", size = 13651218, upload-time = "2025-06-05T03:26:09.731Z" }, + { url = "https://files.pythonhosted.org/packages/26/fa/8eeb2353f6d40974a6a9fd4081ad1700e2386cf4264a8f28542fd10b3e38/pandas-2.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:40cecc4ea5abd2921682b57532baea5588cc5f80f0231c624056b146887274d2", size = 11082485, upload-time = "2025-06-05T03:26:17.572Z" }, + { url = "https://files.pythonhosted.org/packages/96/1e/ba313812a699fe37bf62e6194265a4621be11833f5fce46d9eae22acb5d7/pandas-2.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8adff9f138fc614347ff33812046787f7d43b3cef7c0f0171b3340cae333f6ca", size = 11551836, upload-time = "2025-06-05T03:26:22.784Z" }, + { url = "https://files.pythonhosted.org/packages/1b/cc/0af9c07f8d714ea563b12383a7e5bde9479cf32413ee2f346a9c5a801f22/pandas-2.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e5f08eb9a445d07720776df6e641975665c9ea12c9d8a331e0f6890f2dcd76ef", size = 10807977, upload-time = "2025-06-05T16:50:11.109Z" }, + { url = "https://files.pythonhosted.org/packages/ee/3e/8c0fb7e2cf4a55198466ced1ca6a9054ae3b7e7630df7757031df10001fd/pandas-2.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fa35c266c8cd1a67d75971a1912b185b492d257092bdd2709bbdebe574ed228d", size = 11788230, upload-time = "2025-06-05T03:26:27.417Z" }, + { url = "https://files.pythonhosted.org/packages/14/22/b493ec614582307faf3f94989be0f7f0a71932ed6f56c9a80c0bb4a3b51e/pandas-2.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14a0cc77b0f089d2d2ffe3007db58f170dae9b9f54e569b299db871a3ab5bf46", size = 12370423, upload-time = "2025-06-05T03:26:34.142Z" }, + { url = "https://files.pythonhosted.org/packages/9f/74/b012addb34cda5ce855218a37b258c4e056a0b9b334d116e518d72638737/pandas-2.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c06f6f144ad0a1bf84699aeea7eff6068ca5c63ceb404798198af7eb86082e33", size = 12990594, upload-time = "2025-06-06T00:00:13.934Z" }, + { url = "https://files.pythonhosted.org/packages/95/81/b310e60d033ab64b08e66c635b94076488f0b6ce6a674379dd5b224fc51c/pandas-2.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ed16339bc354a73e0a609df36d256672c7d296f3f767ac07257801aa064ff73c", size = 13745952, upload-time = "2025-06-05T03:26:39.475Z" }, + { url = "https://files.pythonhosted.org/packages/25/ac/f6ee5250a8881b55bd3aecde9b8cfddea2f2b43e3588bca68a4e9aaf46c8/pandas-2.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:fa07e138b3f6c04addfeaf56cc7fdb96c3b68a3fe5e5401251f231fce40a0d7a", size = 11094534, upload-time = "2025-06-05T03:26:43.23Z" }, + { url = "https://files.pythonhosted.org/packages/94/46/24192607058dd607dbfacdd060a2370f6afb19c2ccb617406469b9aeb8e7/pandas-2.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2eb4728a18dcd2908c7fccf74a982e241b467d178724545a48d0caf534b38ebf", size = 11573865, upload-time = "2025-06-05T03:26:46.774Z" }, + { url = "https://files.pythonhosted.org/packages/9f/cc/ae8ea3b800757a70c9fdccc68b67dc0280a6e814efcf74e4211fd5dea1ca/pandas-2.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9d8c3187be7479ea5c3d30c32a5d73d62a621166675063b2edd21bc47614027", size = 10702154, upload-time = "2025-06-05T16:50:14.439Z" }, + { url = "https://files.pythonhosted.org/packages/d8/ba/a7883d7aab3d24c6540a2768f679e7414582cc389876d469b40ec749d78b/pandas-2.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9ff730713d4c4f2f1c860e36c005c7cefc1c7c80c21c0688fd605aa43c9fcf09", size = 11262180, upload-time = "2025-06-05T16:50:17.453Z" }, + { url = "https://files.pythonhosted.org/packages/01/a5/931fc3ad333d9d87b10107d948d757d67ebcfc33b1988d5faccc39c6845c/pandas-2.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba24af48643b12ffe49b27065d3babd52702d95ab70f50e1b34f71ca703e2c0d", size = 11991493, upload-time = "2025-06-05T03:26:51.813Z" }, + { url = "https://files.pythonhosted.org/packages/d7/bf/0213986830a92d44d55153c1d69b509431a972eb73f204242988c4e66e86/pandas-2.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:404d681c698e3c8a40a61d0cd9412cc7364ab9a9cc6e144ae2992e11a2e77a20", size = 12470733, upload-time = "2025-06-06T00:00:18.651Z" }, + { url = "https://files.pythonhosted.org/packages/a4/0e/21eb48a3a34a7d4bac982afc2c4eb5ab09f2d988bdf29d92ba9ae8e90a79/pandas-2.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6021910b086b3ca756755e86ddc64e0ddafd5e58e076c72cb1585162e5ad259b", size = 13212406, upload-time = "2025-06-05T03:26:55.992Z" }, + { url = "https://files.pythonhosted.org/packages/1f/d9/74017c4eec7a28892d8d6e31ae9de3baef71f5a5286e74e6b7aad7f8c837/pandas-2.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:094e271a15b579650ebf4c5155c05dcd2a14fd4fdd72cf4854b2f7ad31ea30be", size = 10976199, upload-time = "2025-06-05T03:26:59.594Z" }, + { url = "https://files.pythonhosted.org/packages/d3/57/5cb75a56a4842bbd0511c3d1c79186d8315b82dac802118322b2de1194fe/pandas-2.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2c7e2fc25f89a49a11599ec1e76821322439d90820108309bf42130d2f36c983", size = 11518913, upload-time = "2025-06-05T03:27:02.757Z" }, + { url = "https://files.pythonhosted.org/packages/05/01/0c8785610e465e4948a01a059562176e4c8088aa257e2e074db868f86d4e/pandas-2.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c6da97aeb6a6d233fb6b17986234cc723b396b50a3c6804776351994f2a658fd", size = 10655249, upload-time = "2025-06-05T16:50:20.17Z" }, + { url = "https://files.pythonhosted.org/packages/e8/6a/47fd7517cd8abe72a58706aab2b99e9438360d36dcdb052cf917b7bf3bdc/pandas-2.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb32dc743b52467d488e7a7c8039b821da2826a9ba4f85b89ea95274f863280f", size = 11328359, upload-time = "2025-06-05T03:27:06.431Z" }, + { url = "https://files.pythonhosted.org/packages/2a/b3/463bfe819ed60fb7e7ddffb4ae2ee04b887b3444feee6c19437b8f834837/pandas-2.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:213cd63c43263dbb522c1f8a7c9d072e25900f6975596f883f4bebd77295d4f3", size = 12024789, upload-time = "2025-06-05T03:27:09.875Z" }, + { url = "https://files.pythonhosted.org/packages/04/0c/e0704ccdb0ac40aeb3434d1c641c43d05f75c92e67525df39575ace35468/pandas-2.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1d2b33e68d0ce64e26a4acc2e72d747292084f4e8db4c847c6f5f6cbe56ed6d8", size = 12480734, upload-time = "2025-06-06T00:00:22.246Z" }, + { url = "https://files.pythonhosted.org/packages/e9/df/815d6583967001153bb27f5cf075653d69d51ad887ebbf4cfe1173a1ac58/pandas-2.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:430a63bae10b5086995db1b02694996336e5a8ac9a96b4200572b413dfdfccb9", size = 13223381, upload-time = "2025-06-05T03:27:15.641Z" }, + { url = "https://files.pythonhosted.org/packages/79/88/ca5973ed07b7f484c493e941dbff990861ca55291ff7ac67c815ce347395/pandas-2.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:4930255e28ff5545e2ca404637bcc56f031893142773b3468dc021c6c32a1390", size = 10970135, upload-time = "2025-06-05T03:27:24.131Z" }, + { url = "https://files.pythonhosted.org/packages/24/fb/0994c14d1f7909ce83f0b1fb27958135513c4f3f2528bde216180aa73bfc/pandas-2.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:f925f1ef673b4bd0271b1809b72b3270384f2b7d9d14a189b12b7fc02574d575", size = 12141356, upload-time = "2025-06-05T03:27:34.547Z" }, + { url = "https://files.pythonhosted.org/packages/9d/a2/9b903e5962134497ac4f8a96f862ee3081cb2506f69f8e4778ce3d9c9d82/pandas-2.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78ad363ddb873a631e92a3c063ade1ecfb34cae71e9a2be6ad100f875ac1042", size = 11474674, upload-time = "2025-06-05T03:27:39.448Z" }, + { url = "https://files.pythonhosted.org/packages/81/3a/3806d041bce032f8de44380f866059437fb79e36d6b22c82c187e65f765b/pandas-2.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:951805d146922aed8357e4cc5671b8b0b9be1027f0619cea132a9f3f65f2f09c", size = 11439876, upload-time = "2025-06-05T03:27:43.652Z" }, + { url = "https://files.pythonhosted.org/packages/15/aa/3fc3181d12b95da71f5c2537c3e3b3af6ab3a8c392ab41ebb766e0929bc6/pandas-2.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a881bc1309f3fce34696d07b00f13335c41f5f5a8770a33b09ebe23261cfc67", size = 11966182, upload-time = "2025-06-05T03:27:47.652Z" }, + { url = "https://files.pythonhosted.org/packages/37/e7/e12f2d9b0a2c4a2cc86e2aabff7ccfd24f03e597d770abfa2acd313ee46b/pandas-2.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e1991bbb96f4050b09b5f811253c4f3cf05ee89a589379aa36cd623f21a31d6f", size = 12547686, upload-time = "2025-06-06T00:00:26.142Z" }, + { url = "https://files.pythonhosted.org/packages/39/c2/646d2e93e0af70f4e5359d870a63584dacbc324b54d73e6b3267920ff117/pandas-2.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:bb3be958022198531eb7ec2008cfc78c5b1eed51af8600c6c5d9160d89d8d249", size = 13231847, upload-time = "2025-06-05T03:27:51.465Z" }, +] + +[[package]] +name = "parso" +version = "0.8.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/66/94/68e2e17afaa9169cf6412ab0f28623903be73d1b32e208d9e8e541bb086d/parso-0.8.4.tar.gz", hash = "sha256:eb3a7b58240fb99099a345571deecc0f9540ea5f4dd2fe14c2a99d6b281ab92d", size = 400609, upload-time = "2024-04-05T09:43:55.897Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650, upload-time = "2024-04-05T09:43:53.299Z" }, +] + +[[package]] +name = "pathspec" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "11.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/af/cb/bb5c01fcd2a69335b86c22142b2bccfc3464087efb7fd382eee5ffc7fdf7/pillow-11.2.1.tar.gz", hash = "sha256:a64dd61998416367b7ef979b73d3a85853ba9bec4c2925f74e588879a58716b6", size = 47026707, upload-time = "2025-04-12T17:50:03.289Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/8b/b158ad57ed44d3cc54db8d68ad7c0a58b8fc0e4c7a3f995f9d62d5b464a1/pillow-11.2.1-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:d57a75d53922fc20c165016a20d9c44f73305e67c351bbc60d1adaf662e74047", size = 3198442, upload-time = "2025-04-12T17:47:10.666Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f8/bb5d956142f86c2d6cc36704943fa761f2d2e4c48b7436fd0a85c20f1713/pillow-11.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:127bf6ac4a5b58b3d32fc8289656f77f80567d65660bc46f72c0d77e6600cc95", size = 3030553, upload-time = "2025-04-12T17:47:13.153Z" }, + { url = "https://files.pythonhosted.org/packages/22/7f/0e413bb3e2aa797b9ca2c5c38cb2e2e45d88654e5b12da91ad446964cfae/pillow-11.2.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b4ba4be812c7a40280629e55ae0b14a0aafa150dd6451297562e1764808bbe61", size = 4405503, upload-time = "2025-04-12T17:47:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/f3/b4/cc647f4d13f3eb837d3065824aa58b9bcf10821f029dc79955ee43f793bd/pillow-11.2.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8bd62331e5032bc396a93609982a9ab6b411c05078a52f5fe3cc59234a3abd1", size = 4490648, upload-time = "2025-04-12T17:47:17.37Z" }, + { url = "https://files.pythonhosted.org/packages/c2/6f/240b772a3b35cdd7384166461567aa6713799b4e78d180c555bd284844ea/pillow-11.2.1-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:562d11134c97a62fe3af29581f083033179f7ff435f78392565a1ad2d1c2c45c", size = 4508937, upload-time = "2025-04-12T17:47:19.066Z" }, + { url = "https://files.pythonhosted.org/packages/f3/5e/7ca9c815ade5fdca18853db86d812f2f188212792780208bdb37a0a6aef4/pillow-11.2.1-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:c97209e85b5be259994eb5b69ff50c5d20cca0f458ef9abd835e262d9d88b39d", size = 4599802, upload-time = "2025-04-12T17:47:21.404Z" }, + { url = "https://files.pythonhosted.org/packages/02/81/c3d9d38ce0c4878a77245d4cf2c46d45a4ad0f93000227910a46caff52f3/pillow-11.2.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0c3e6d0f59171dfa2e25d7116217543310908dfa2770aa64b8f87605f8cacc97", size = 4576717, upload-time = "2025-04-12T17:47:23.571Z" }, + { url = "https://files.pythonhosted.org/packages/42/49/52b719b89ac7da3185b8d29c94d0e6aec8140059e3d8adcaa46da3751180/pillow-11.2.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc1c3bc53befb6096b84165956e886b1729634a799e9d6329a0c512ab651e579", size = 4654874, upload-time = "2025-04-12T17:47:25.783Z" }, + { url = "https://files.pythonhosted.org/packages/5b/0b/ede75063ba6023798267023dc0d0401f13695d228194d2242d5a7ba2f964/pillow-11.2.1-cp310-cp310-win32.whl", hash = "sha256:312c77b7f07ab2139924d2639860e084ec2a13e72af54d4f08ac843a5fc9c79d", size = 2331717, upload-time = "2025-04-12T17:47:28.922Z" }, + { url = "https://files.pythonhosted.org/packages/ed/3c/9831da3edea527c2ed9a09f31a2c04e77cd705847f13b69ca60269eec370/pillow-11.2.1-cp310-cp310-win_amd64.whl", hash = "sha256:9bc7ae48b8057a611e5fe9f853baa88093b9a76303937449397899385da06fad", size = 2676204, upload-time = "2025-04-12T17:47:31.283Z" }, + { url = "https://files.pythonhosted.org/packages/01/97/1f66ff8a1503d8cbfc5bae4dc99d54c6ec1e22ad2b946241365320caabc2/pillow-11.2.1-cp310-cp310-win_arm64.whl", hash = "sha256:2728567e249cdd939f6cc3d1f049595c66e4187f3c34078cbc0a7d21c47482d2", size = 2414767, upload-time = "2025-04-12T17:47:34.655Z" }, + { url = "https://files.pythonhosted.org/packages/68/08/3fbf4b98924c73037a8e8b4c2c774784805e0fb4ebca6c5bb60795c40125/pillow-11.2.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:35ca289f712ccfc699508c4658a1d14652e8033e9b69839edf83cbdd0ba39e70", size = 3198450, upload-time = "2025-04-12T17:47:37.135Z" }, + { url = "https://files.pythonhosted.org/packages/84/92/6505b1af3d2849d5e714fc75ba9e69b7255c05ee42383a35a4d58f576b16/pillow-11.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0409af9f829f87a2dfb7e259f78f317a5351f2045158be321fd135973fff7bf", size = 3030550, upload-time = "2025-04-12T17:47:39.345Z" }, + { url = "https://files.pythonhosted.org/packages/3c/8c/ac2f99d2a70ff966bc7eb13dacacfaab57c0549b2ffb351b6537c7840b12/pillow-11.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4e5c5edee874dce4f653dbe59db7c73a600119fbea8d31f53423586ee2aafd7", size = 4415018, upload-time = "2025-04-12T17:47:41.128Z" }, + { url = "https://files.pythonhosted.org/packages/1f/e3/0a58b5d838687f40891fff9cbaf8669f90c96b64dc8f91f87894413856c6/pillow-11.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b93a07e76d13bff9444f1a029e0af2964e654bfc2e2c2d46bfd080df5ad5f3d8", size = 4498006, upload-time = "2025-04-12T17:47:42.912Z" }, + { url = "https://files.pythonhosted.org/packages/21/f5/6ba14718135f08fbfa33308efe027dd02b781d3f1d5c471444a395933aac/pillow-11.2.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:e6def7eed9e7fa90fde255afaf08060dc4b343bbe524a8f69bdd2a2f0018f600", size = 4517773, upload-time = "2025-04-12T17:47:44.611Z" }, + { url = "https://files.pythonhosted.org/packages/20/f2/805ad600fc59ebe4f1ba6129cd3a75fb0da126975c8579b8f57abeb61e80/pillow-11.2.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8f4f3724c068be008c08257207210c138d5f3731af6c155a81c2b09a9eb3a788", size = 4607069, upload-time = "2025-04-12T17:47:46.46Z" }, + { url = "https://files.pythonhosted.org/packages/71/6b/4ef8a288b4bb2e0180cba13ca0a519fa27aa982875882392b65131401099/pillow-11.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a0a6709b47019dff32e678bc12c63008311b82b9327613f534e496dacaefb71e", size = 4583460, upload-time = "2025-04-12T17:47:49.255Z" }, + { url = "https://files.pythonhosted.org/packages/62/ae/f29c705a09cbc9e2a456590816e5c234382ae5d32584f451c3eb41a62062/pillow-11.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f6b0c664ccb879109ee3ca702a9272d877f4fcd21e5eb63c26422fd6e415365e", size = 4661304, upload-time = "2025-04-12T17:47:51.067Z" }, + { url = "https://files.pythonhosted.org/packages/6e/1a/c8217b6f2f73794a5e219fbad087701f412337ae6dbb956db37d69a9bc43/pillow-11.2.1-cp311-cp311-win32.whl", hash = "sha256:cc5d875d56e49f112b6def6813c4e3d3036d269c008bf8aef72cd08d20ca6df6", size = 2331809, upload-time = "2025-04-12T17:47:54.425Z" }, + { url = "https://files.pythonhosted.org/packages/e2/72/25a8f40170dc262e86e90f37cb72cb3de5e307f75bf4b02535a61afcd519/pillow-11.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:0f5c7eda47bf8e3c8a283762cab94e496ba977a420868cb819159980b6709193", size = 2676338, upload-time = "2025-04-12T17:47:56.535Z" }, + { url = "https://files.pythonhosted.org/packages/06/9e/76825e39efee61efea258b479391ca77d64dbd9e5804e4ad0fa453b4ba55/pillow-11.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:4d375eb838755f2528ac8cbc926c3e31cc49ca4ad0cf79cff48b20e30634a4a7", size = 2414918, upload-time = "2025-04-12T17:47:58.217Z" }, + { url = "https://files.pythonhosted.org/packages/c7/40/052610b15a1b8961f52537cc8326ca6a881408bc2bdad0d852edeb6ed33b/pillow-11.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:78afba22027b4accef10dbd5eed84425930ba41b3ea0a86fa8d20baaf19d807f", size = 3190185, upload-time = "2025-04-12T17:48:00.417Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7e/b86dbd35a5f938632093dc40d1682874c33dcfe832558fc80ca56bfcb774/pillow-11.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:78092232a4ab376a35d68c4e6d5e00dfd73454bd12b230420025fbe178ee3b0b", size = 3030306, upload-time = "2025-04-12T17:48:02.391Z" }, + { url = "https://files.pythonhosted.org/packages/a4/5c/467a161f9ed53e5eab51a42923c33051bf8d1a2af4626ac04f5166e58e0c/pillow-11.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:25a5f306095c6780c52e6bbb6109624b95c5b18e40aab1c3041da3e9e0cd3e2d", size = 4416121, upload-time = "2025-04-12T17:48:04.554Z" }, + { url = "https://files.pythonhosted.org/packages/62/73/972b7742e38ae0e2ac76ab137ca6005dcf877480da0d9d61d93b613065b4/pillow-11.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c7b29dbd4281923a2bfe562acb734cee96bbb129e96e6972d315ed9f232bef4", size = 4501707, upload-time = "2025-04-12T17:48:06.831Z" }, + { url = "https://files.pythonhosted.org/packages/e4/3a/427e4cb0b9e177efbc1a84798ed20498c4f233abde003c06d2650a6d60cb/pillow-11.2.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:3e645b020f3209a0181a418bffe7b4a93171eef6c4ef6cc20980b30bebf17b7d", size = 4522921, upload-time = "2025-04-12T17:48:09.229Z" }, + { url = "https://files.pythonhosted.org/packages/fe/7c/d8b1330458e4d2f3f45d9508796d7caf0c0d3764c00c823d10f6f1a3b76d/pillow-11.2.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:b2dbea1012ccb784a65349f57bbc93730b96e85b42e9bf7b01ef40443db720b4", size = 4612523, upload-time = "2025-04-12T17:48:11.631Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2f/65738384e0b1acf451de5a573d8153fe84103772d139e1e0bdf1596be2ea/pillow-11.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:da3104c57bbd72948d75f6a9389e6727d2ab6333c3617f0a89d72d4940aa0443", size = 4587836, upload-time = "2025-04-12T17:48:13.592Z" }, + { url = "https://files.pythonhosted.org/packages/6a/c5/e795c9f2ddf3debb2dedd0df889f2fe4b053308bb59a3cc02a0cd144d641/pillow-11.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:598174aef4589af795f66f9caab87ba4ff860ce08cd5bb447c6fc553ffee603c", size = 4669390, upload-time = "2025-04-12T17:48:15.938Z" }, + { url = "https://files.pythonhosted.org/packages/96/ae/ca0099a3995976a9fce2f423166f7bff9b12244afdc7520f6ed38911539a/pillow-11.2.1-cp312-cp312-win32.whl", hash = "sha256:1d535df14716e7f8776b9e7fee118576d65572b4aad3ed639be9e4fa88a1cad3", size = 2332309, upload-time = "2025-04-12T17:48:17.885Z" }, + { url = "https://files.pythonhosted.org/packages/7c/18/24bff2ad716257fc03da964c5e8f05d9790a779a8895d6566e493ccf0189/pillow-11.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:14e33b28bf17c7a38eede290f77db7c664e4eb01f7869e37fa98a5aa95978941", size = 2676768, upload-time = "2025-04-12T17:48:19.655Z" }, + { url = "https://files.pythonhosted.org/packages/da/bb/e8d656c9543276517ee40184aaa39dcb41e683bca121022f9323ae11b39d/pillow-11.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:21e1470ac9e5739ff880c211fc3af01e3ae505859392bf65458c224d0bf283eb", size = 2415087, upload-time = "2025-04-12T17:48:21.991Z" }, + { url = "https://files.pythonhosted.org/packages/36/9c/447528ee3776e7ab8897fe33697a7ff3f0475bb490c5ac1456a03dc57956/pillow-11.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:fdec757fea0b793056419bca3e9932eb2b0ceec90ef4813ea4c1e072c389eb28", size = 3190098, upload-time = "2025-04-12T17:48:23.915Z" }, + { url = "https://files.pythonhosted.org/packages/b5/09/29d5cd052f7566a63e5b506fac9c60526e9ecc553825551333e1e18a4858/pillow-11.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b0e130705d568e2f43a17bcbe74d90958e8a16263868a12c3e0d9c8162690830", size = 3030166, upload-time = "2025-04-12T17:48:25.738Z" }, + { url = "https://files.pythonhosted.org/packages/71/5d/446ee132ad35e7600652133f9c2840b4799bbd8e4adba881284860da0a36/pillow-11.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bdb5e09068332578214cadd9c05e3d64d99e0e87591be22a324bdbc18925be0", size = 4408674, upload-time = "2025-04-12T17:48:27.908Z" }, + { url = "https://files.pythonhosted.org/packages/69/5f/cbe509c0ddf91cc3a03bbacf40e5c2339c4912d16458fcb797bb47bcb269/pillow-11.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d189ba1bebfbc0c0e529159631ec72bb9e9bc041f01ec6d3233d6d82eb823bc1", size = 4496005, upload-time = "2025-04-12T17:48:29.888Z" }, + { url = "https://files.pythonhosted.org/packages/f9/b3/dd4338d8fb8a5f312021f2977fb8198a1184893f9b00b02b75d565c33b51/pillow-11.2.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:191955c55d8a712fab8934a42bfefbf99dd0b5875078240943f913bb66d46d9f", size = 4518707, upload-time = "2025-04-12T17:48:31.874Z" }, + { url = "https://files.pythonhosted.org/packages/13/eb/2552ecebc0b887f539111c2cd241f538b8ff5891b8903dfe672e997529be/pillow-11.2.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:ad275964d52e2243430472fc5d2c2334b4fc3ff9c16cb0a19254e25efa03a155", size = 4610008, upload-time = "2025-04-12T17:48:34.422Z" }, + { url = "https://files.pythonhosted.org/packages/72/d1/924ce51bea494cb6e7959522d69d7b1c7e74f6821d84c63c3dc430cbbf3b/pillow-11.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:750f96efe0597382660d8b53e90dd1dd44568a8edb51cb7f9d5d918b80d4de14", size = 4585420, upload-time = "2025-04-12T17:48:37.641Z" }, + { url = "https://files.pythonhosted.org/packages/43/ab/8f81312d255d713b99ca37479a4cb4b0f48195e530cdc1611990eb8fd04b/pillow-11.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fe15238d3798788d00716637b3d4e7bb6bde18b26e5d08335a96e88564a36b6b", size = 4667655, upload-time = "2025-04-12T17:48:39.652Z" }, + { url = "https://files.pythonhosted.org/packages/94/86/8f2e9d2dc3d308dfd137a07fe1cc478df0a23d42a6c4093b087e738e4827/pillow-11.2.1-cp313-cp313-win32.whl", hash = "sha256:3fe735ced9a607fee4f481423a9c36701a39719252a9bb251679635f99d0f7d2", size = 2332329, upload-time = "2025-04-12T17:48:41.765Z" }, + { url = "https://files.pythonhosted.org/packages/6d/ec/1179083b8d6067a613e4d595359b5fdea65d0a3b7ad623fee906e1b3c4d2/pillow-11.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:74ee3d7ecb3f3c05459ba95eed5efa28d6092d751ce9bf20e3e253a4e497e691", size = 2676388, upload-time = "2025-04-12T17:48:43.625Z" }, + { url = "https://files.pythonhosted.org/packages/23/f1/2fc1e1e294de897df39fa8622d829b8828ddad938b0eaea256d65b84dd72/pillow-11.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:5119225c622403afb4b44bad4c1ca6c1f98eed79db8d3bc6e4e160fc6339d66c", size = 2414950, upload-time = "2025-04-12T17:48:45.475Z" }, + { url = "https://files.pythonhosted.org/packages/c4/3e/c328c48b3f0ead7bab765a84b4977acb29f101d10e4ef57a5e3400447c03/pillow-11.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8ce2e8411c7aaef53e6bb29fe98f28cd4fbd9a1d9be2eeea434331aac0536b22", size = 3192759, upload-time = "2025-04-12T17:48:47.866Z" }, + { url = "https://files.pythonhosted.org/packages/18/0e/1c68532d833fc8b9f404d3a642991441d9058eccd5606eab31617f29b6d4/pillow-11.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:9ee66787e095127116d91dea2143db65c7bb1e232f617aa5957c0d9d2a3f23a7", size = 3033284, upload-time = "2025-04-12T17:48:50.189Z" }, + { url = "https://files.pythonhosted.org/packages/b7/cb/6faf3fb1e7705fd2db74e070f3bf6f88693601b0ed8e81049a8266de4754/pillow-11.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9622e3b6c1d8b551b6e6f21873bdcc55762b4b2126633014cea1803368a9aa16", size = 4445826, upload-time = "2025-04-12T17:48:52.346Z" }, + { url = "https://files.pythonhosted.org/packages/07/94/8be03d50b70ca47fb434a358919d6a8d6580f282bbb7af7e4aa40103461d/pillow-11.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:63b5dff3a68f371ea06025a1a6966c9a1e1ee452fc8020c2cd0ea41b83e9037b", size = 4527329, upload-time = "2025-04-12T17:48:54.403Z" }, + { url = "https://files.pythonhosted.org/packages/fd/a4/bfe78777076dc405e3bd2080bc32da5ab3945b5a25dc5d8acaa9de64a162/pillow-11.2.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:31df6e2d3d8fc99f993fd253e97fae451a8db2e7207acf97859732273e108406", size = 4549049, upload-time = "2025-04-12T17:48:56.383Z" }, + { url = "https://files.pythonhosted.org/packages/65/4d/eaf9068dc687c24979e977ce5677e253624bd8b616b286f543f0c1b91662/pillow-11.2.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:062b7a42d672c45a70fa1f8b43d1d38ff76b63421cbbe7f88146b39e8a558d91", size = 4635408, upload-time = "2025-04-12T17:48:58.782Z" }, + { url = "https://files.pythonhosted.org/packages/1d/26/0fd443365d9c63bc79feb219f97d935cd4b93af28353cba78d8e77b61719/pillow-11.2.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4eb92eca2711ef8be42fd3f67533765d9fd043b8c80db204f16c8ea62ee1a751", size = 4614863, upload-time = "2025-04-12T17:49:00.709Z" }, + { url = "https://files.pythonhosted.org/packages/49/65/dca4d2506be482c2c6641cacdba5c602bc76d8ceb618fd37de855653a419/pillow-11.2.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f91ebf30830a48c825590aede79376cb40f110b387c17ee9bd59932c961044f9", size = 4692938, upload-time = "2025-04-12T17:49:02.946Z" }, + { url = "https://files.pythonhosted.org/packages/b3/92/1ca0c3f09233bd7decf8f7105a1c4e3162fb9142128c74adad0fb361b7eb/pillow-11.2.1-cp313-cp313t-win32.whl", hash = "sha256:e0b55f27f584ed623221cfe995c912c61606be8513bfa0e07d2c674b4516d9dd", size = 2335774, upload-time = "2025-04-12T17:49:04.889Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ac/77525347cb43b83ae905ffe257bbe2cc6fd23acb9796639a1f56aa59d191/pillow-11.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:36d6b82164c39ce5482f649b437382c0fb2395eabc1e2b1702a6deb8ad647d6e", size = 2681895, upload-time = "2025-04-12T17:49:06.635Z" }, + { url = "https://files.pythonhosted.org/packages/67/32/32dc030cfa91ca0fc52baebbba2e009bb001122a1daa8b6a79ad830b38d3/pillow-11.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:225c832a13326e34f212d2072982bb1adb210e0cc0b153e688743018c94a2681", size = 2417234, upload-time = "2025-04-12T17:49:08.399Z" }, + { url = "https://files.pythonhosted.org/packages/33/49/c8c21e4255b4f4a2c0c68ac18125d7f5460b109acc6dfdef1a24f9b960ef/pillow-11.2.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:9b7b0d4fd2635f54ad82785d56bc0d94f147096493a79985d0ab57aedd563156", size = 3181727, upload-time = "2025-04-12T17:49:31.898Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f1/f7255c0838f8c1ef6d55b625cfb286835c17e8136ce4351c5577d02c443b/pillow-11.2.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:aa442755e31c64037aa7c1cb186e0b369f8416c567381852c63444dd666fb772", size = 2999833, upload-time = "2025-04-12T17:49:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/e2/57/9968114457bd131063da98d87790d080366218f64fa2943b65ac6739abb3/pillow-11.2.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0d3348c95b766f54b76116d53d4cb171b52992a1027e7ca50c81b43b9d9e363", size = 3437472, upload-time = "2025-04-12T17:49:36.294Z" }, + { url = "https://files.pythonhosted.org/packages/b2/1b/e35d8a158e21372ecc48aac9c453518cfe23907bb82f950d6e1c72811eb0/pillow-11.2.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85d27ea4c889342f7e35f6d56e7e1cb345632ad592e8c51b693d7b7556043ce0", size = 3459976, upload-time = "2025-04-12T17:49:38.988Z" }, + { url = "https://files.pythonhosted.org/packages/26/da/2c11d03b765efff0ccc473f1c4186dc2770110464f2177efaed9cf6fae01/pillow-11.2.1-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:bf2c33d6791c598142f00c9c4c7d47f6476731c31081331664eb26d6ab583e01", size = 3527133, upload-time = "2025-04-12T17:49:40.985Z" }, + { url = "https://files.pythonhosted.org/packages/79/1a/4e85bd7cadf78412c2a3069249a09c32ef3323650fd3005c97cca7aa21df/pillow-11.2.1-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e616e7154c37669fc1dfc14584f11e284e05d1c650e1c0f972f281c4ccc53193", size = 3571555, upload-time = "2025-04-12T17:49:42.964Z" }, + { url = "https://files.pythonhosted.org/packages/69/03/239939915216de1e95e0ce2334bf17a7870ae185eb390fab6d706aadbfc0/pillow-11.2.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:39ad2e0f424394e3aebc40168845fee52df1394a4673a6ee512d840d14ab3013", size = 2674713, upload-time = "2025-04-12T17:49:44.944Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ad/2613c04633c7257d9481ab21d6b5364b59fc5d75faafd7cb8693523945a3/pillow-11.2.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:80f1df8dbe9572b4b7abdfa17eb5d78dd620b1d55d9e25f834efdbee872d3aed", size = 3181734, upload-time = "2025-04-12T17:49:46.789Z" }, + { url = "https://files.pythonhosted.org/packages/a4/fd/dcdda4471ed667de57bb5405bb42d751e6cfdd4011a12c248b455c778e03/pillow-11.2.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ea926cfbc3957090becbcbbb65ad177161a2ff2ad578b5a6ec9bb1e1cd78753c", size = 2999841, upload-time = "2025-04-12T17:49:48.812Z" }, + { url = "https://files.pythonhosted.org/packages/ac/89/8a2536e95e77432833f0db6fd72a8d310c8e4272a04461fb833eb021bf94/pillow-11.2.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:738db0e0941ca0376804d4de6a782c005245264edaa253ffce24e5a15cbdc7bd", size = 3437470, upload-time = "2025-04-12T17:49:50.831Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8f/abd47b73c60712f88e9eda32baced7bfc3e9bd6a7619bb64b93acff28c3e/pillow-11.2.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9db98ab6565c69082ec9b0d4e40dd9f6181dab0dd236d26f7a50b8b9bfbd5076", size = 3460013, upload-time = "2025-04-12T17:49:53.278Z" }, + { url = "https://files.pythonhosted.org/packages/f6/20/5c0a0aa83b213b7a07ec01e71a3d6ea2cf4ad1d2c686cc0168173b6089e7/pillow-11.2.1-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:036e53f4170e270ddb8797d4c590e6dd14d28e15c7da375c18978045f7e6c37b", size = 3527165, upload-time = "2025-04-12T17:49:55.164Z" }, + { url = "https://files.pythonhosted.org/packages/58/0e/2abab98a72202d91146abc839e10c14f7cf36166f12838ea0c4db3ca6ecb/pillow-11.2.1-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:14f73f7c291279bd65fda51ee87affd7c1e097709f7fdd0188957a16c264601f", size = 3571586, upload-time = "2025-04-12T17:49:57.171Z" }, + { url = "https://files.pythonhosted.org/packages/21/2c/5e05f58658cf49b6667762cca03d6e7d85cededde2caf2ab37b81f80e574/pillow-11.2.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:208653868d5c9ecc2b327f9b9ef34e0e42a4cdd172c2988fd81d62d2bc9bc044", size = 2674751, upload-time = "2025-04-12T17:49:59.628Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.3.8" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fe/8b/3c73abc9c759ecd3f1f7ceff6685840859e8070c4d947c93fae71f6a0bf2/platformdirs-4.3.8.tar.gz", hash = "sha256:3d512d96e16bcb959a814c9f348431070822a6496326a4be0911c40b5a74c2bc", size = 21362, upload-time = "2025-05-07T22:47:42.121Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fe/39/979e8e21520d4e47a0bbe349e2713c0aac6f3d853d0e5b34d76206c439aa/platformdirs-4.3.8-py3-none-any.whl", hash = "sha256:ff7059bb7eb1179e2685604f4aaf157cfd9535242bd23742eadc3c13542139b4", size = 18567, upload-time = "2025-05-07T22:47:40.376Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.51" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bb/6e/9d084c929dfe9e3bfe0c6a47e31f78a25c54627d64a66e884a8bf5474f1c/prompt_toolkit-3.0.51.tar.gz", hash = "sha256:931a162e3b27fc90c86f1b48bb1fb2c528c2761475e57c9c06de13311c7b54ed", size = 428940, upload-time = "2025-04-15T09:18:47.731Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/4f/5249960887b1fbe561d9ff265496d170b55a735b76724f10ef19f9e40716/prompt_toolkit-3.0.51-py3-none-any.whl", hash = "sha256:52742911fde84e2d423e2f9a4cf1de7d7ac4e51958f648d9540e0fb8db077b07", size = 387810, upload-time = "2025-04-15T09:18:44.753Z" }, +] + +[[package]] +name = "propcache" +version = "0.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/07/c8/fdc6686a986feae3541ea23dcaa661bd93972d3940460646c6bb96e21c40/propcache-0.3.1.tar.gz", hash = "sha256:40d980c33765359098837527e18eddefc9a24cea5b45e078a7f3bb5b032c6ecf", size = 43651, upload-time = "2025-03-26T03:06:12.05Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/56/e27c136101addf877c8291dbda1b3b86ae848f3837ce758510a0d806c92f/propcache-0.3.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f27785888d2fdd918bc36de8b8739f2d6c791399552333721b58193f68ea3e98", size = 80224, upload-time = "2025-03-26T03:03:35.81Z" }, + { url = "https://files.pythonhosted.org/packages/63/bd/88e98836544c4f04db97eefd23b037c2002fa173dd2772301c61cd3085f9/propcache-0.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4e89cde74154c7b5957f87a355bb9c8ec929c167b59c83d90654ea36aeb6180", size = 46491, upload-time = "2025-03-26T03:03:38.107Z" }, + { url = "https://files.pythonhosted.org/packages/15/43/0b8eb2a55753c4a574fc0899885da504b521068d3b08ca56774cad0bea2b/propcache-0.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:730178f476ef03d3d4d255f0c9fa186cb1d13fd33ffe89d39f2cda4da90ceb71", size = 45927, upload-time = "2025-03-26T03:03:39.394Z" }, + { url = "https://files.pythonhosted.org/packages/ad/6c/d01f9dfbbdc613305e0a831016844987a1fb4861dd221cd4c69b1216b43f/propcache-0.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:967a8eec513dbe08330f10137eacb427b2ca52118769e82ebcfcab0fba92a649", size = 206135, upload-time = "2025-03-26T03:03:40.757Z" }, + { url = "https://files.pythonhosted.org/packages/9a/8a/e6e1c77394088f4cfdace4a91a7328e398ebed745d59c2f6764135c5342d/propcache-0.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b9145c35cc87313b5fd480144f8078716007656093d23059e8993d3a8fa730f", size = 220517, upload-time = "2025-03-26T03:03:42.657Z" }, + { url = "https://files.pythonhosted.org/packages/19/3b/6c44fa59d6418f4239d5db8b1ece757351e85d6f3ca126dfe37d427020c8/propcache-0.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e64e948ab41411958670f1093c0a57acfdc3bee5cf5b935671bbd5313bcf229", size = 218952, upload-time = "2025-03-26T03:03:44.549Z" }, + { url = "https://files.pythonhosted.org/packages/7c/e4/4aeb95a1cd085e0558ab0de95abfc5187329616193a1012a6c4c930e9f7a/propcache-0.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:319fa8765bfd6a265e5fa661547556da381e53274bc05094fc9ea50da51bfd46", size = 206593, upload-time = "2025-03-26T03:03:46.114Z" }, + { url = "https://files.pythonhosted.org/packages/da/6a/29fa75de1cbbb302f1e1d684009b969976ca603ee162282ae702287b6621/propcache-0.3.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c66d8ccbc902ad548312b96ed8d5d266d0d2c6d006fd0f66323e9d8f2dd49be7", size = 196745, upload-time = "2025-03-26T03:03:48.02Z" }, + { url = "https://files.pythonhosted.org/packages/19/7e/2237dad1dbffdd2162de470599fa1a1d55df493b16b71e5d25a0ac1c1543/propcache-0.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:2d219b0dbabe75e15e581fc1ae796109b07c8ba7d25b9ae8d650da582bed01b0", size = 203369, upload-time = "2025-03-26T03:03:49.63Z" }, + { url = "https://files.pythonhosted.org/packages/a4/bc/a82c5878eb3afb5c88da86e2cf06e1fe78b7875b26198dbb70fe50a010dc/propcache-0.3.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cd6a55f65241c551eb53f8cf4d2f4af33512c39da5d9777694e9d9c60872f519", size = 198723, upload-time = "2025-03-26T03:03:51.091Z" }, + { url = "https://files.pythonhosted.org/packages/17/76/9632254479c55516f51644ddbf747a45f813031af5adcb8db91c0b824375/propcache-0.3.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9979643ffc69b799d50d3a7b72b5164a2e97e117009d7af6dfdd2ab906cb72cd", size = 200751, upload-time = "2025-03-26T03:03:52.631Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c3/a90b773cf639bd01d12a9e20c95be0ae978a5a8abe6d2d343900ae76cd71/propcache-0.3.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:4cf9e93a81979f1424f1a3d155213dc928f1069d697e4353edb8a5eba67c6259", size = 210730, upload-time = "2025-03-26T03:03:54.498Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ec/ad5a952cdb9d65c351f88db7c46957edd3d65ffeee72a2f18bd6341433e0/propcache-0.3.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2fce1df66915909ff6c824bbb5eb403d2d15f98f1518e583074671a30fe0c21e", size = 213499, upload-time = "2025-03-26T03:03:56.054Z" }, + { url = "https://files.pythonhosted.org/packages/83/c0/ea5133dda43e298cd2010ec05c2821b391e10980e64ee72c0a76cdbb813a/propcache-0.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4d0dfdd9a2ebc77b869a0b04423591ea8823f791293b527dc1bb896c1d6f1136", size = 207132, upload-time = "2025-03-26T03:03:57.398Z" }, + { url = "https://files.pythonhosted.org/packages/79/dd/71aae9dec59333064cfdd7eb31a63fa09f64181b979802a67a90b2abfcba/propcache-0.3.1-cp310-cp310-win32.whl", hash = "sha256:1f6cc0ad7b4560e5637eb2c994e97b4fa41ba8226069c9277eb5ea7101845b42", size = 40952, upload-time = "2025-03-26T03:03:59.146Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/49ff7e5056c17dfba62cbdcbb90a29daffd199c52f8e65e5cb09d5f53a57/propcache-0.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:47ef24aa6511e388e9894ec16f0fbf3313a53ee68402bc428744a367ec55b833", size = 45163, upload-time = "2025-03-26T03:04:00.672Z" }, + { url = "https://files.pythonhosted.org/packages/90/0f/5a5319ee83bd651f75311fcb0c492c21322a7fc8f788e4eef23f44243427/propcache-0.3.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7f30241577d2fef2602113b70ef7231bf4c69a97e04693bde08ddab913ba0ce5", size = 80243, upload-time = "2025-03-26T03:04:01.912Z" }, + { url = "https://files.pythonhosted.org/packages/ce/84/3db5537e0879942783e2256616ff15d870a11d7ac26541336fe1b673c818/propcache-0.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:43593c6772aa12abc3af7784bff4a41ffa921608dd38b77cf1dfd7f5c4e71371", size = 46503, upload-time = "2025-03-26T03:04:03.704Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c8/b649ed972433c3f0d827d7f0cf9ea47162f4ef8f4fe98c5f3641a0bc63ff/propcache-0.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a75801768bbe65499495660b777e018cbe90c7980f07f8aa57d6be79ea6f71da", size = 45934, upload-time = "2025-03-26T03:04:05.257Z" }, + { url = "https://files.pythonhosted.org/packages/59/f9/4c0a5cf6974c2c43b1a6810c40d889769cc8f84cea676cbe1e62766a45f8/propcache-0.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6f1324db48f001c2ca26a25fa25af60711e09b9aaf4b28488602776f4f9a744", size = 233633, upload-time = "2025-03-26T03:04:07.044Z" }, + { url = "https://files.pythonhosted.org/packages/e7/64/66f2f4d1b4f0007c6e9078bd95b609b633d3957fe6dd23eac33ebde4b584/propcache-0.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cdb0f3e1eb6dfc9965d19734d8f9c481b294b5274337a8cb5cb01b462dcb7e0", size = 241124, upload-time = "2025-03-26T03:04:08.676Z" }, + { url = "https://files.pythonhosted.org/packages/aa/bf/7b8c9fd097d511638fa9b6af3d986adbdf567598a567b46338c925144c1b/propcache-0.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1eb34d90aac9bfbced9a58b266f8946cb5935869ff01b164573a7634d39fbcb5", size = 240283, upload-time = "2025-03-26T03:04:10.172Z" }, + { url = "https://files.pythonhosted.org/packages/fa/c9/e85aeeeaae83358e2a1ef32d6ff50a483a5d5248bc38510d030a6f4e2816/propcache-0.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f35c7070eeec2cdaac6fd3fe245226ed2a6292d3ee8c938e5bb645b434c5f256", size = 232498, upload-time = "2025-03-26T03:04:11.616Z" }, + { url = "https://files.pythonhosted.org/packages/8e/66/acb88e1f30ef5536d785c283af2e62931cb934a56a3ecf39105887aa8905/propcache-0.3.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b23c11c2c9e6d4e7300c92e022046ad09b91fd00e36e83c44483df4afa990073", size = 221486, upload-time = "2025-03-26T03:04:13.102Z" }, + { url = "https://files.pythonhosted.org/packages/f5/f9/233ddb05ffdcaee4448508ee1d70aa7deff21bb41469ccdfcc339f871427/propcache-0.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3e19ea4ea0bf46179f8a3652ac1426e6dcbaf577ce4b4f65be581e237340420d", size = 222675, upload-time = "2025-03-26T03:04:14.658Z" }, + { url = "https://files.pythonhosted.org/packages/98/b8/eb977e28138f9e22a5a789daf608d36e05ed93093ef12a12441030da800a/propcache-0.3.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:bd39c92e4c8f6cbf5f08257d6360123af72af9f4da75a690bef50da77362d25f", size = 215727, upload-time = "2025-03-26T03:04:16.207Z" }, + { url = "https://files.pythonhosted.org/packages/89/2d/5f52d9c579f67b8ee1edd9ec073c91b23cc5b7ff7951a1e449e04ed8fdf3/propcache-0.3.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b0313e8b923b3814d1c4a524c93dfecea5f39fa95601f6a9b1ac96cd66f89ea0", size = 217878, upload-time = "2025-03-26T03:04:18.11Z" }, + { url = "https://files.pythonhosted.org/packages/7a/fd/5283e5ed8a82b00c7a989b99bb6ea173db1ad750bf0bf8dff08d3f4a4e28/propcache-0.3.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e861ad82892408487be144906a368ddbe2dc6297074ade2d892341b35c59844a", size = 230558, upload-time = "2025-03-26T03:04:19.562Z" }, + { url = "https://files.pythonhosted.org/packages/90/38/ab17d75938ef7ac87332c588857422ae126b1c76253f0f5b1242032923ca/propcache-0.3.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:61014615c1274df8da5991a1e5da85a3ccb00c2d4701ac6f3383afd3ca47ab0a", size = 233754, upload-time = "2025-03-26T03:04:21.065Z" }, + { url = "https://files.pythonhosted.org/packages/06/5d/3b921b9c60659ae464137508d3b4c2b3f52f592ceb1964aa2533b32fcf0b/propcache-0.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:71ebe3fe42656a2328ab08933d420df5f3ab121772eef78f2dc63624157f0ed9", size = 226088, upload-time = "2025-03-26T03:04:22.718Z" }, + { url = "https://files.pythonhosted.org/packages/54/6e/30a11f4417d9266b5a464ac5a8c5164ddc9dd153dfa77bf57918165eb4ae/propcache-0.3.1-cp311-cp311-win32.whl", hash = "sha256:58aa11f4ca8b60113d4b8e32d37e7e78bd8af4d1a5b5cb4979ed856a45e62005", size = 40859, upload-time = "2025-03-26T03:04:24.039Z" }, + { url = "https://files.pythonhosted.org/packages/1d/3a/8a68dd867da9ca2ee9dfd361093e9cb08cb0f37e5ddb2276f1b5177d7731/propcache-0.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:9532ea0b26a401264b1365146c440a6d78269ed41f83f23818d4b79497aeabe7", size = 45153, upload-time = "2025-03-26T03:04:25.211Z" }, + { url = "https://files.pythonhosted.org/packages/41/aa/ca78d9be314d1e15ff517b992bebbed3bdfef5b8919e85bf4940e57b6137/propcache-0.3.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f78eb8422acc93d7b69964012ad7048764bb45a54ba7a39bb9e146c72ea29723", size = 80430, upload-time = "2025-03-26T03:04:26.436Z" }, + { url = "https://files.pythonhosted.org/packages/1a/d8/f0c17c44d1cda0ad1979af2e593ea290defdde9eaeb89b08abbe02a5e8e1/propcache-0.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:89498dd49c2f9a026ee057965cdf8192e5ae070ce7d7a7bd4b66a8e257d0c976", size = 46637, upload-time = "2025-03-26T03:04:27.932Z" }, + { url = "https://files.pythonhosted.org/packages/ae/bd/c1e37265910752e6e5e8a4c1605d0129e5b7933c3dc3cf1b9b48ed83b364/propcache-0.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:09400e98545c998d57d10035ff623266927cb784d13dd2b31fd33b8a5316b85b", size = 46123, upload-time = "2025-03-26T03:04:30.659Z" }, + { url = "https://files.pythonhosted.org/packages/d4/b0/911eda0865f90c0c7e9f0415d40a5bf681204da5fd7ca089361a64c16b28/propcache-0.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa8efd8c5adc5a2c9d3b952815ff8f7710cefdcaf5f2c36d26aff51aeca2f12f", size = 243031, upload-time = "2025-03-26T03:04:31.977Z" }, + { url = "https://files.pythonhosted.org/packages/0a/06/0da53397c76a74271621807265b6eb61fb011451b1ddebf43213df763669/propcache-0.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c2fe5c910f6007e716a06d269608d307b4f36e7babee5f36533722660e8c4a70", size = 249100, upload-time = "2025-03-26T03:04:33.45Z" }, + { url = "https://files.pythonhosted.org/packages/f1/eb/13090e05bf6b963fc1653cdc922133ced467cb4b8dab53158db5a37aa21e/propcache-0.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a0ab8cf8cdd2194f8ff979a43ab43049b1df0b37aa64ab7eca04ac14429baeb7", size = 250170, upload-time = "2025-03-26T03:04:35.542Z" }, + { url = "https://files.pythonhosted.org/packages/3b/4c/f72c9e1022b3b043ec7dc475a0f405d4c3e10b9b1d378a7330fecf0652da/propcache-0.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:563f9d8c03ad645597b8d010ef4e9eab359faeb11a0a2ac9f7b4bc8c28ebef25", size = 245000, upload-time = "2025-03-26T03:04:37.501Z" }, + { url = "https://files.pythonhosted.org/packages/e8/fd/970ca0e22acc829f1adf5de3724085e778c1ad8a75bec010049502cb3a86/propcache-0.3.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb6e0faf8cb6b4beea5d6ed7b5a578254c6d7df54c36ccd3d8b3eb00d6770277", size = 230262, upload-time = "2025-03-26T03:04:39.532Z" }, + { url = "https://files.pythonhosted.org/packages/c4/42/817289120c6b9194a44f6c3e6b2c3277c5b70bbad39e7df648f177cc3634/propcache-0.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1c5c7ab7f2bb3f573d1cb921993006ba2d39e8621019dffb1c5bc94cdbae81e8", size = 236772, upload-time = "2025-03-26T03:04:41.109Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9c/3b3942b302badd589ad6b672da3ca7b660a6c2f505cafd058133ddc73918/propcache-0.3.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:050b571b2e96ec942898f8eb46ea4bfbb19bd5502424747e83badc2d4a99a44e", size = 231133, upload-time = "2025-03-26T03:04:42.544Z" }, + { url = "https://files.pythonhosted.org/packages/98/a1/75f6355f9ad039108ff000dfc2e19962c8dea0430da9a1428e7975cf24b2/propcache-0.3.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e1c4d24b804b3a87e9350f79e2371a705a188d292fd310e663483af6ee6718ee", size = 230741, upload-time = "2025-03-26T03:04:44.06Z" }, + { url = "https://files.pythonhosted.org/packages/67/0c/3e82563af77d1f8731132166da69fdfd95e71210e31f18edce08a1eb11ea/propcache-0.3.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e4fe2a6d5ce975c117a6bb1e8ccda772d1e7029c1cca1acd209f91d30fa72815", size = 244047, upload-time = "2025-03-26T03:04:45.983Z" }, + { url = "https://files.pythonhosted.org/packages/f7/50/9fb7cca01532a08c4d5186d7bb2da6c4c587825c0ae134b89b47c7d62628/propcache-0.3.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:feccd282de1f6322f56f6845bf1207a537227812f0a9bf5571df52bb418d79d5", size = 246467, upload-time = "2025-03-26T03:04:47.699Z" }, + { url = "https://files.pythonhosted.org/packages/a9/02/ccbcf3e1c604c16cc525309161d57412c23cf2351523aedbb280eb7c9094/propcache-0.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ec314cde7314d2dd0510c6787326bbffcbdc317ecee6b7401ce218b3099075a7", size = 241022, upload-time = "2025-03-26T03:04:49.195Z" }, + { url = "https://files.pythonhosted.org/packages/db/19/e777227545e09ca1e77a6e21274ae9ec45de0f589f0ce3eca2a41f366220/propcache-0.3.1-cp312-cp312-win32.whl", hash = "sha256:7d2d5a0028d920738372630870e7d9644ce437142197f8c827194fca404bf03b", size = 40647, upload-time = "2025-03-26T03:04:50.595Z" }, + { url = "https://files.pythonhosted.org/packages/24/bb/3b1b01da5dd04c77a204c84e538ff11f624e31431cfde7201d9110b092b1/propcache-0.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:88c423efef9d7a59dae0614eaed718449c09a5ac79a5f224a8b9664d603f04a3", size = 44784, upload-time = "2025-03-26T03:04:51.791Z" }, + { url = "https://files.pythonhosted.org/packages/58/60/f645cc8b570f99be3cf46714170c2de4b4c9d6b827b912811eff1eb8a412/propcache-0.3.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f1528ec4374617a7a753f90f20e2f551121bb558fcb35926f99e3c42367164b8", size = 77865, upload-time = "2025-03-26T03:04:53.406Z" }, + { url = "https://files.pythonhosted.org/packages/6f/d4/c1adbf3901537582e65cf90fd9c26fde1298fde5a2c593f987112c0d0798/propcache-0.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc1915ec523b3b494933b5424980831b636fe483d7d543f7afb7b3bf00f0c10f", size = 45452, upload-time = "2025-03-26T03:04:54.624Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b5/fe752b2e63f49f727c6c1c224175d21b7d1727ce1d4873ef1c24c9216830/propcache-0.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a110205022d077da24e60b3df8bcee73971be9575dec5573dd17ae5d81751111", size = 44800, upload-time = "2025-03-26T03:04:55.844Z" }, + { url = "https://files.pythonhosted.org/packages/62/37/fc357e345bc1971e21f76597028b059c3d795c5ca7690d7a8d9a03c9708a/propcache-0.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d249609e547c04d190e820d0d4c8ca03ed4582bcf8e4e160a6969ddfb57b62e5", size = 225804, upload-time = "2025-03-26T03:04:57.158Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f1/16e12c33e3dbe7f8b737809bad05719cff1dccb8df4dafbcff5575002c0e/propcache-0.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ced33d827625d0a589e831126ccb4f5c29dfdf6766cac441d23995a65825dcb", size = 230650, upload-time = "2025-03-26T03:04:58.61Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a2/018b9f2ed876bf5091e60153f727e8f9073d97573f790ff7cdf6bc1d1fb8/propcache-0.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4114c4ada8f3181af20808bedb250da6bae56660e4b8dfd9cd95d4549c0962f7", size = 234235, upload-time = "2025-03-26T03:05:00.599Z" }, + { url = "https://files.pythonhosted.org/packages/45/5f/3faee66fc930dfb5da509e34c6ac7128870631c0e3582987fad161fcb4b1/propcache-0.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:975af16f406ce48f1333ec5e912fe11064605d5c5b3f6746969077cc3adeb120", size = 228249, upload-time = "2025-03-26T03:05:02.11Z" }, + { url = "https://files.pythonhosted.org/packages/62/1e/a0d5ebda5da7ff34d2f5259a3e171a94be83c41eb1e7cd21a2105a84a02e/propcache-0.3.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a34aa3a1abc50740be6ac0ab9d594e274f59960d3ad253cd318af76b996dd654", size = 214964, upload-time = "2025-03-26T03:05:03.599Z" }, + { url = "https://files.pythonhosted.org/packages/db/a0/d72da3f61ceab126e9be1f3bc7844b4e98c6e61c985097474668e7e52152/propcache-0.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9cec3239c85ed15bfaded997773fdad9fb5662b0a7cbc854a43f291eb183179e", size = 222501, upload-time = "2025-03-26T03:05:05.107Z" }, + { url = "https://files.pythonhosted.org/packages/18/6d/a008e07ad7b905011253adbbd97e5b5375c33f0b961355ca0a30377504ac/propcache-0.3.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:05543250deac8e61084234d5fc54f8ebd254e8f2b39a16b1dce48904f45b744b", size = 217917, upload-time = "2025-03-26T03:05:06.59Z" }, + { url = "https://files.pythonhosted.org/packages/98/37/02c9343ffe59e590e0e56dc5c97d0da2b8b19fa747ebacf158310f97a79a/propcache-0.3.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5cb5918253912e088edbf023788de539219718d3b10aef334476b62d2b53de53", size = 217089, upload-time = "2025-03-26T03:05:08.1Z" }, + { url = "https://files.pythonhosted.org/packages/53/1b/d3406629a2c8a5666d4674c50f757a77be119b113eedd47b0375afdf1b42/propcache-0.3.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f3bbecd2f34d0e6d3c543fdb3b15d6b60dd69970c2b4c822379e5ec8f6f621d5", size = 228102, upload-time = "2025-03-26T03:05:09.982Z" }, + { url = "https://files.pythonhosted.org/packages/cd/a7/3664756cf50ce739e5f3abd48febc0be1a713b1f389a502ca819791a6b69/propcache-0.3.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aca63103895c7d960a5b9b044a83f544b233c95e0dcff114389d64d762017af7", size = 230122, upload-time = "2025-03-26T03:05:11.408Z" }, + { url = "https://files.pythonhosted.org/packages/35/36/0bbabaacdcc26dac4f8139625e930f4311864251276033a52fd52ff2a274/propcache-0.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5a0a9898fdb99bf11786265468571e628ba60af80dc3f6eb89a3545540c6b0ef", size = 226818, upload-time = "2025-03-26T03:05:12.909Z" }, + { url = "https://files.pythonhosted.org/packages/cc/27/4e0ef21084b53bd35d4dae1634b6d0bad35e9c58ed4f032511acca9d4d26/propcache-0.3.1-cp313-cp313-win32.whl", hash = "sha256:3a02a28095b5e63128bcae98eb59025924f121f048a62393db682f049bf4ac24", size = 40112, upload-time = "2025-03-26T03:05:14.289Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2c/a54614d61895ba6dd7ac8f107e2b2a0347259ab29cbf2ecc7b94fa38c4dc/propcache-0.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:813fbb8b6aea2fc9659815e585e548fe706d6f663fa73dff59a1677d4595a037", size = 44034, upload-time = "2025-03-26T03:05:15.616Z" }, + { url = "https://files.pythonhosted.org/packages/5a/a8/0a4fd2f664fc6acc66438370905124ce62e84e2e860f2557015ee4a61c7e/propcache-0.3.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a444192f20f5ce8a5e52761a031b90f5ea6288b1eef42ad4c7e64fef33540b8f", size = 82613, upload-time = "2025-03-26T03:05:16.913Z" }, + { url = "https://files.pythonhosted.org/packages/4d/e5/5ef30eb2cd81576256d7b6caaa0ce33cd1d2c2c92c8903cccb1af1a4ff2f/propcache-0.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0fbe94666e62ebe36cd652f5fc012abfbc2342de99b523f8267a678e4dfdee3c", size = 47763, upload-time = "2025-03-26T03:05:18.607Z" }, + { url = "https://files.pythonhosted.org/packages/87/9a/87091ceb048efeba4d28e903c0b15bcc84b7c0bf27dc0261e62335d9b7b8/propcache-0.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f011f104db880f4e2166bcdcf7f58250f7a465bc6b068dc84c824a3d4a5c94dc", size = 47175, upload-time = "2025-03-26T03:05:19.85Z" }, + { url = "https://files.pythonhosted.org/packages/3e/2f/854e653c96ad1161f96194c6678a41bbb38c7947d17768e8811a77635a08/propcache-0.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e584b6d388aeb0001d6d5c2bd86b26304adde6d9bb9bfa9c4889805021b96de", size = 292265, upload-time = "2025-03-26T03:05:21.654Z" }, + { url = "https://files.pythonhosted.org/packages/40/8d/090955e13ed06bc3496ba4a9fb26c62e209ac41973cb0d6222de20c6868f/propcache-0.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8a17583515a04358b034e241f952f1715243482fc2c2945fd99a1b03a0bd77d6", size = 294412, upload-time = "2025-03-26T03:05:23.147Z" }, + { url = "https://files.pythonhosted.org/packages/39/e6/d51601342e53cc7582449e6a3c14a0479fab2f0750c1f4d22302e34219c6/propcache-0.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5aed8d8308215089c0734a2af4f2e95eeb360660184ad3912686c181e500b2e7", size = 294290, upload-time = "2025-03-26T03:05:24.577Z" }, + { url = "https://files.pythonhosted.org/packages/3b/4d/be5f1a90abc1881884aa5878989a1acdafd379a91d9c7e5e12cef37ec0d7/propcache-0.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d8e309ff9a0503ef70dc9a0ebd3e69cf7b3894c9ae2ae81fc10943c37762458", size = 282926, upload-time = "2025-03-26T03:05:26.459Z" }, + { url = "https://files.pythonhosted.org/packages/57/2b/8f61b998c7ea93a2b7eca79e53f3e903db1787fca9373af9e2cf8dc22f9d/propcache-0.3.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b655032b202028a582d27aeedc2e813299f82cb232f969f87a4fde491a233f11", size = 267808, upload-time = "2025-03-26T03:05:28.188Z" }, + { url = "https://files.pythonhosted.org/packages/11/1c/311326c3dfce59c58a6098388ba984b0e5fb0381ef2279ec458ef99bd547/propcache-0.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f64d91b751df77931336b5ff7bafbe8845c5770b06630e27acd5dbb71e1931c", size = 290916, upload-time = "2025-03-26T03:05:29.757Z" }, + { url = "https://files.pythonhosted.org/packages/4b/74/91939924b0385e54dc48eb2e4edd1e4903ffd053cf1916ebc5347ac227f7/propcache-0.3.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:19a06db789a4bd896ee91ebc50d059e23b3639c25d58eb35be3ca1cbe967c3bf", size = 262661, upload-time = "2025-03-26T03:05:31.472Z" }, + { url = "https://files.pythonhosted.org/packages/c2/d7/e6079af45136ad325c5337f5dd9ef97ab5dc349e0ff362fe5c5db95e2454/propcache-0.3.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:bef100c88d8692864651b5f98e871fb090bd65c8a41a1cb0ff2322db39c96c27", size = 264384, upload-time = "2025-03-26T03:05:32.984Z" }, + { url = "https://files.pythonhosted.org/packages/b7/d5/ba91702207ac61ae6f1c2da81c5d0d6bf6ce89e08a2b4d44e411c0bbe867/propcache-0.3.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:87380fb1f3089d2a0b8b00f006ed12bd41bd858fabfa7330c954c70f50ed8757", size = 291420, upload-time = "2025-03-26T03:05:34.496Z" }, + { url = "https://files.pythonhosted.org/packages/58/70/2117780ed7edcd7ba6b8134cb7802aada90b894a9810ec56b7bb6018bee7/propcache-0.3.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e474fc718e73ba5ec5180358aa07f6aded0ff5f2abe700e3115c37d75c947e18", size = 290880, upload-time = "2025-03-26T03:05:36.256Z" }, + { url = "https://files.pythonhosted.org/packages/4a/1f/ecd9ce27710021ae623631c0146719280a929d895a095f6d85efb6a0be2e/propcache-0.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:17d1c688a443355234f3c031349da69444be052613483f3e4158eef751abcd8a", size = 287407, upload-time = "2025-03-26T03:05:37.799Z" }, + { url = "https://files.pythonhosted.org/packages/3e/66/2e90547d6b60180fb29e23dc87bd8c116517d4255240ec6d3f7dc23d1926/propcache-0.3.1-cp313-cp313t-win32.whl", hash = "sha256:359e81a949a7619802eb601d66d37072b79b79c2505e6d3fd8b945538411400d", size = 42573, upload-time = "2025-03-26T03:05:39.193Z" }, + { url = "https://files.pythonhosted.org/packages/cb/8f/50ad8599399d1861b4d2b6b45271f0ef6af1b09b0a2386a46dbaf19c9535/propcache-0.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e7fb9a84c9abbf2b2683fa3e7b0d7da4d8ecf139a1c635732a8bda29c5214b0e", size = 46757, upload-time = "2025-03-26T03:05:40.811Z" }, + { url = "https://files.pythonhosted.org/packages/b8/d3/c3cb8f1d6ae3b37f83e1de806713a9b3642c5895f0215a62e1a4bd6e5e34/propcache-0.3.1-py3-none-any.whl", hash = "sha256:9a8ecf38de50a7f518c21568c80f985e776397b902f1ce0b01f799aba1608b40", size = 12376, upload-time = "2025-03-26T03:06:10.5Z" }, +] + +[[package]] +name = "psutil" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2a/80/336820c1ad9286a4ded7e845b2eccfcb27851ab8ac6abece774a6ff4d3de/psutil-7.0.0.tar.gz", hash = "sha256:7be9c3eba38beccb6495ea33afd982a44074b78f28c434a1f51cc07fd315c456", size = 497003, upload-time = "2025-02-13T21:54:07.946Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/e6/2d26234410f8b8abdbf891c9da62bee396583f713fb9f3325a4760875d22/psutil-7.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:101d71dc322e3cffd7cea0650b09b3d08b8e7c4109dd6809fe452dfd00e58b25", size = 238051, upload-time = "2025-02-13T21:54:12.36Z" }, + { url = "https://files.pythonhosted.org/packages/04/8b/30f930733afe425e3cbfc0e1468a30a18942350c1a8816acfade80c005c4/psutil-7.0.0-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:39db632f6bb862eeccf56660871433e111b6ea58f2caea825571951d4b6aa3da", size = 239535, upload-time = "2025-02-13T21:54:16.07Z" }, + { url = "https://files.pythonhosted.org/packages/2a/ed/d362e84620dd22876b55389248e522338ed1bf134a5edd3b8231d7207f6d/psutil-7.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1fcee592b4c6f146991ca55919ea3d1f8926497a713ed7faaf8225e174581e91", size = 275004, upload-time = "2025-02-13T21:54:18.662Z" }, + { url = "https://files.pythonhosted.org/packages/bf/b9/b0eb3f3cbcb734d930fdf839431606844a825b23eaf9a6ab371edac8162c/psutil-7.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b1388a4f6875d7e2aff5c4ca1cc16c545ed41dd8bb596cefea80111db353a34", size = 277986, upload-time = "2025-02-13T21:54:21.811Z" }, + { url = "https://files.pythonhosted.org/packages/eb/a2/709e0fe2f093556c17fbafda93ac032257242cabcc7ff3369e2cb76a97aa/psutil-7.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5f098451abc2828f7dc6b58d44b532b22f2088f4999a937557b603ce72b1993", size = 279544, upload-time = "2025-02-13T21:54:24.68Z" }, + { url = "https://files.pythonhosted.org/packages/50/e6/eecf58810b9d12e6427369784efe814a1eec0f492084ce8eb8f4d89d6d61/psutil-7.0.0-cp37-abi3-win32.whl", hash = "sha256:ba3fcef7523064a6c9da440fc4d6bd07da93ac726b5733c29027d7dc95b39d99", size = 241053, upload-time = "2025-02-13T21:54:34.31Z" }, + { url = "https://files.pythonhosted.org/packages/50/1b/6921afe68c74868b4c9fa424dad3be35b095e16687989ebbb50ce4fceb7c/psutil-7.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:4cf3d4eb1aa9b348dec30105c55cd9b7d4629285735a102beb4441e38db90553", size = 244885, upload-time = "2025-02-13T21:54:37.486Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pycparser" +version = "2.22" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" }, +] + +[[package]] +name = "pydantic" +version = "2.11.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f0/86/8ce9040065e8f924d642c58e4a344e33163a07f6b57f836d0d734e0ad3fb/pydantic-2.11.5.tar.gz", hash = "sha256:7f853db3d0ce78ce8bbb148c401c2cdd6431b3473c0cdff2755c7690952a7b7a", size = 787102, upload-time = "2025-05-22T21:18:08.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/69/831ed22b38ff9b4b64b66569f0e5b7b97cf3638346eb95a2147fdb49ad5f/pydantic-2.11.5-py3-none-any.whl", hash = "sha256:f9c26ba06f9747749ca1e5c94d6a85cb84254577553c8785576fd38fa64dc0f7", size = 444229, upload-time = "2025-05-22T21:18:06.329Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.33.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e5/92/b31726561b5dae176c2d2c2dc43a9c5bfba5d32f96f8b4c0a600dd492447/pydantic_core-2.33.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:2b3d326aaef0c0399d9afffeb6367d5e26ddc24d351dbc9c636840ac355dc5d8", size = 2028817, upload-time = "2025-04-23T18:30:43.919Z" }, + { url = "https://files.pythonhosted.org/packages/a3/44/3f0b95fafdaca04a483c4e685fe437c6891001bf3ce8b2fded82b9ea3aa1/pydantic_core-2.33.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0e5b2671f05ba48b94cb90ce55d8bdcaaedb8ba00cc5359f6810fc918713983d", size = 1861357, upload-time = "2025-04-23T18:30:46.372Z" }, + { url = "https://files.pythonhosted.org/packages/30/97/e8f13b55766234caae05372826e8e4b3b96e7b248be3157f53237682e43c/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0069c9acc3f3981b9ff4cdfaf088e98d83440a4c7ea1bc07460af3d4dc22e72d", size = 1898011, upload-time = "2025-04-23T18:30:47.591Z" }, + { url = "https://files.pythonhosted.org/packages/9b/a3/99c48cf7bafc991cc3ee66fd544c0aae8dc907b752f1dad2d79b1b5a471f/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d53b22f2032c42eaaf025f7c40c2e3b94568ae077a606f006d206a463bc69572", size = 1982730, upload-time = "2025-04-23T18:30:49.328Z" }, + { url = "https://files.pythonhosted.org/packages/de/8e/a5b882ec4307010a840fb8b58bd9bf65d1840c92eae7534c7441709bf54b/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0405262705a123b7ce9f0b92f123334d67b70fd1f20a9372b907ce1080c7ba02", size = 2136178, upload-time = "2025-04-23T18:30:50.907Z" }, + { url = "https://files.pythonhosted.org/packages/e4/bb/71e35fc3ed05af6834e890edb75968e2802fe98778971ab5cba20a162315/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4b25d91e288e2c4e0662b8038a28c6a07eaac3e196cfc4ff69de4ea3db992a1b", size = 2736462, upload-time = "2025-04-23T18:30:52.083Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/c8f7593e6bc7066289bbc366f2235701dcbebcd1ff0ef8e64f6f239fb47d/pydantic_core-2.33.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6bdfe4b3789761f3bcb4b1ddf33355a71079858958e3a552f16d5af19768fef2", size = 2005652, upload-time = "2025-04-23T18:30:53.389Z" }, + { url = "https://files.pythonhosted.org/packages/d2/7a/996d8bd75f3eda405e3dd219ff5ff0a283cd8e34add39d8ef9157e722867/pydantic_core-2.33.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:efec8db3266b76ef9607c2c4c419bdb06bf335ae433b80816089ea7585816f6a", size = 2113306, upload-time = "2025-04-23T18:30:54.661Z" }, + { url = "https://files.pythonhosted.org/packages/ff/84/daf2a6fb2db40ffda6578a7e8c5a6e9c8affb251a05c233ae37098118788/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:031c57d67ca86902726e0fae2214ce6770bbe2f710dc33063187a68744a5ecac", size = 2073720, upload-time = "2025-04-23T18:30:56.11Z" }, + { url = "https://files.pythonhosted.org/packages/77/fb/2258da019f4825128445ae79456a5499c032b55849dbd5bed78c95ccf163/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:f8de619080e944347f5f20de29a975c2d815d9ddd8be9b9b7268e2e3ef68605a", size = 2244915, upload-time = "2025-04-23T18:30:57.501Z" }, + { url = "https://files.pythonhosted.org/packages/d8/7a/925ff73756031289468326e355b6fa8316960d0d65f8b5d6b3a3e7866de7/pydantic_core-2.33.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:73662edf539e72a9440129f231ed3757faab89630d291b784ca99237fb94db2b", size = 2241884, upload-time = "2025-04-23T18:30:58.867Z" }, + { url = "https://files.pythonhosted.org/packages/0b/b0/249ee6d2646f1cdadcb813805fe76265745c4010cf20a8eba7b0e639d9b2/pydantic_core-2.33.2-cp310-cp310-win32.whl", hash = "sha256:0a39979dcbb70998b0e505fb1556a1d550a0781463ce84ebf915ba293ccb7e22", size = 1910496, upload-time = "2025-04-23T18:31:00.078Z" }, + { url = "https://files.pythonhosted.org/packages/66/ff/172ba8f12a42d4b552917aa65d1f2328990d3ccfc01d5b7c943ec084299f/pydantic_core-2.33.2-cp310-cp310-win_amd64.whl", hash = "sha256:b0379a2b24882fef529ec3b4987cb5d003b9cda32256024e6fe1586ac45fc640", size = 1955019, upload-time = "2025-04-23T18:31:01.335Z" }, + { url = "https://files.pythonhosted.org/packages/3f/8d/71db63483d518cbbf290261a1fc2839d17ff89fce7089e08cad07ccfce67/pydantic_core-2.33.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:4c5b0a576fb381edd6d27f0a85915c6daf2f8138dc5c267a57c08a62900758c7", size = 2028584, upload-time = "2025-04-23T18:31:03.106Z" }, + { url = "https://files.pythonhosted.org/packages/24/2f/3cfa7244ae292dd850989f328722d2aef313f74ffc471184dc509e1e4e5a/pydantic_core-2.33.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e799c050df38a639db758c617ec771fd8fb7a5f8eaaa4b27b101f266b216a246", size = 1855071, upload-time = "2025-04-23T18:31:04.621Z" }, + { url = "https://files.pythonhosted.org/packages/b3/d3/4ae42d33f5e3f50dd467761304be2fa0a9417fbf09735bc2cce003480f2a/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dc46a01bf8d62f227d5ecee74178ffc448ff4e5197c756331f71efcc66dc980f", size = 1897823, upload-time = "2025-04-23T18:31:06.377Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f3/aa5976e8352b7695ff808599794b1fba2a9ae2ee954a3426855935799488/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a144d4f717285c6d9234a66778059f33a89096dfb9b39117663fd8413d582dcc", size = 1983792, upload-time = "2025-04-23T18:31:07.93Z" }, + { url = "https://files.pythonhosted.org/packages/d5/7a/cda9b5a23c552037717f2b2a5257e9b2bfe45e687386df9591eff7b46d28/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cf6373c21bc80b2e0dc88444f41ae60b2f070ed02095754eb5a01df12256de", size = 2136338, upload-time = "2025-04-23T18:31:09.283Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9f/b8f9ec8dd1417eb9da784e91e1667d58a2a4a7b7b34cf4af765ef663a7e5/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dc625f4aa79713512d1976fe9f0bc99f706a9dee21dfd1810b4bbbf228d0e8a", size = 2730998, upload-time = "2025-04-23T18:31:11.7Z" }, + { url = "https://files.pythonhosted.org/packages/47/bc/cd720e078576bdb8255d5032c5d63ee5c0bf4b7173dd955185a1d658c456/pydantic_core-2.33.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b21b5549499972441da4758d662aeea93f1923f953e9cbaff14b8b9565aef", size = 2003200, upload-time = "2025-04-23T18:31:13.536Z" }, + { url = "https://files.pythonhosted.org/packages/ca/22/3602b895ee2cd29d11a2b349372446ae9727c32e78a94b3d588a40fdf187/pydantic_core-2.33.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bdc25f3681f7b78572699569514036afe3c243bc3059d3942624e936ec93450e", size = 2113890, upload-time = "2025-04-23T18:31:15.011Z" }, + { url = "https://files.pythonhosted.org/packages/ff/e6/e3c5908c03cf00d629eb38393a98fccc38ee0ce8ecce32f69fc7d7b558a7/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fe5b32187cbc0c862ee201ad66c30cf218e5ed468ec8dc1cf49dec66e160cc4d", size = 2073359, upload-time = "2025-04-23T18:31:16.393Z" }, + { url = "https://files.pythonhosted.org/packages/12/e7/6a36a07c59ebefc8777d1ffdaf5ae71b06b21952582e4b07eba88a421c79/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:bc7aee6f634a6f4a95676fcb5d6559a2c2a390330098dba5e5a5f28a2e4ada30", size = 2245883, upload-time = "2025-04-23T18:31:17.892Z" }, + { url = "https://files.pythonhosted.org/packages/16/3f/59b3187aaa6cc0c1e6616e8045b284de2b6a87b027cce2ffcea073adf1d2/pydantic_core-2.33.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:235f45e5dbcccf6bd99f9f472858849f73d11120d76ea8707115415f8e5ebebf", size = 2241074, upload-time = "2025-04-23T18:31:19.205Z" }, + { url = "https://files.pythonhosted.org/packages/e0/ed/55532bb88f674d5d8f67ab121a2a13c385df382de2a1677f30ad385f7438/pydantic_core-2.33.2-cp311-cp311-win32.whl", hash = "sha256:6368900c2d3ef09b69cb0b913f9f8263b03786e5b2a387706c5afb66800efd51", size = 1910538, upload-time = "2025-04-23T18:31:20.541Z" }, + { url = "https://files.pythonhosted.org/packages/fe/1b/25b7cccd4519c0b23c2dd636ad39d381abf113085ce4f7bec2b0dc755eb1/pydantic_core-2.33.2-cp311-cp311-win_amd64.whl", hash = "sha256:1e063337ef9e9820c77acc768546325ebe04ee38b08703244c1309cccc4f1bab", size = 1952909, upload-time = "2025-04-23T18:31:22.371Z" }, + { url = "https://files.pythonhosted.org/packages/49/a9/d809358e49126438055884c4366a1f6227f0f84f635a9014e2deb9b9de54/pydantic_core-2.33.2-cp311-cp311-win_arm64.whl", hash = "sha256:6b99022f1d19bc32a4c2a0d544fc9a76e3be90f0b3f4af413f87d38749300e65", size = 1897786, upload-time = "2025-04-23T18:31:24.161Z" }, + { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" }, + { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" }, + { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" }, + { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" }, + { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" }, + { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" }, + { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" }, + { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" }, + { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" }, + { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" }, + { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" }, + { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" }, + { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" }, + { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" }, + { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" }, + { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" }, + { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" }, + { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" }, + { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" }, + { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" }, + { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" }, + { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" }, + { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" }, + { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" }, + { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" }, + { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" }, + { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" }, + { url = "https://files.pythonhosted.org/packages/30/68/373d55e58b7e83ce371691f6eaa7175e3a24b956c44628eb25d7da007917/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5c4aa4e82353f65e548c476b37e64189783aa5384903bfea4f41580f255fddfa", size = 2023982, upload-time = "2025-04-23T18:32:53.14Z" }, + { url = "https://files.pythonhosted.org/packages/a4/16/145f54ac08c96a63d8ed6442f9dec17b2773d19920b627b18d4f10a061ea/pydantic_core-2.33.2-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d946c8bf0d5c24bf4fe333af284c59a19358aa3ec18cb3dc4370080da1e8ad29", size = 1858412, upload-time = "2025-04-23T18:32:55.52Z" }, + { url = "https://files.pythonhosted.org/packages/41/b1/c6dc6c3e2de4516c0bb2c46f6a373b91b5660312342a0cf5826e38ad82fa/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:87b31b6846e361ef83fedb187bb5b4372d0da3f7e28d85415efa92d6125d6e6d", size = 1892749, upload-time = "2025-04-23T18:32:57.546Z" }, + { url = "https://files.pythonhosted.org/packages/12/73/8cd57e20afba760b21b742106f9dbdfa6697f1570b189c7457a1af4cd8a0/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa9d91b338f2df0508606f7009fde642391425189bba6d8c653afd80fd6bb64e", size = 2067527, upload-time = "2025-04-23T18:32:59.771Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d5/0bb5d988cc019b3cba4a78f2d4b3854427fc47ee8ec8e9eaabf787da239c/pydantic_core-2.33.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2058a32994f1fde4ca0480ab9d1e75a0e8c87c22b53a3ae66554f9af78f2fe8c", size = 2108225, upload-time = "2025-04-23T18:33:04.51Z" }, + { url = "https://files.pythonhosted.org/packages/f1/c5/00c02d1571913d496aabf146106ad8239dc132485ee22efe08085084ff7c/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:0e03262ab796d986f978f79c943fc5f620381be7287148b8010b4097f79a39ec", size = 2069490, upload-time = "2025-04-23T18:33:06.391Z" }, + { url = "https://files.pythonhosted.org/packages/22/a8/dccc38768274d3ed3a59b5d06f59ccb845778687652daa71df0cab4040d7/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:1a8695a8d00c73e50bff9dfda4d540b7dee29ff9b8053e38380426a85ef10052", size = 2237525, upload-time = "2025-04-23T18:33:08.44Z" }, + { url = "https://files.pythonhosted.org/packages/d4/e7/4f98c0b125dda7cf7ccd14ba936218397b44f50a56dd8c16a3091df116c3/pydantic_core-2.33.2-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:fa754d1850735a0b0e03bcffd9d4b4343eb417e47196e4485d9cca326073a42c", size = 2238446, upload-time = "2025-04-23T18:33:10.313Z" }, + { url = "https://files.pythonhosted.org/packages/ce/91/2ec36480fdb0b783cd9ef6795753c1dea13882f2e68e73bce76ae8c21e6a/pydantic_core-2.33.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a11c8d26a50bfab49002947d3d237abe4d9e4b5bdc8846a63537b6488e197808", size = 2066678, upload-time = "2025-04-23T18:33:12.224Z" }, + { url = "https://files.pythonhosted.org/packages/7b/27/d4ae6487d73948d6f20dddcd94be4ea43e74349b56eba82e9bdee2d7494c/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:dd14041875d09cc0f9308e37a6f8b65f5585cf2598a53aa0123df8b129d481f8", size = 2025200, upload-time = "2025-04-23T18:33:14.199Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b8/b3cb95375f05d33801024079b9392a5ab45267a63400bf1866e7ce0f0de4/pydantic_core-2.33.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d87c561733f66531dced0da6e864f44ebf89a8fba55f31407b00c2f7f9449593", size = 1859123, upload-time = "2025-04-23T18:33:16.555Z" }, + { url = "https://files.pythonhosted.org/packages/05/bc/0d0b5adeda59a261cd30a1235a445bf55c7e46ae44aea28f7bd6ed46e091/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2f82865531efd18d6e07a04a17331af02cb7a651583c418df8266f17a63c6612", size = 1892852, upload-time = "2025-04-23T18:33:18.513Z" }, + { url = "https://files.pythonhosted.org/packages/3e/11/d37bdebbda2e449cb3f519f6ce950927b56d62f0b84fd9cb9e372a26a3d5/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bfb5112df54209d820d7bf9317c7a6c9025ea52e49f46b6a2060104bba37de7", size = 2067484, upload-time = "2025-04-23T18:33:20.475Z" }, + { url = "https://files.pythonhosted.org/packages/8c/55/1f95f0a05ce72ecb02a8a8a1c3be0579bbc29b1d5ab68f1378b7bebc5057/pydantic_core-2.33.2-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:64632ff9d614e5eecfb495796ad51b0ed98c453e447a76bcbeeb69615079fc7e", size = 2108896, upload-time = "2025-04-23T18:33:22.501Z" }, + { url = "https://files.pythonhosted.org/packages/53/89/2b2de6c81fa131f423246a9109d7b2a375e83968ad0800d6e57d0574629b/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:f889f7a40498cc077332c7ab6b4608d296d852182211787d4f3ee377aaae66e8", size = 2069475, upload-time = "2025-04-23T18:33:24.528Z" }, + { url = "https://files.pythonhosted.org/packages/b8/e9/1f7efbe20d0b2b10f6718944b5d8ece9152390904f29a78e68d4e7961159/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:de4b83bb311557e439b9e186f733f6c645b9417c84e2eb8203f3f820a4b988bf", size = 2239013, upload-time = "2025-04-23T18:33:26.621Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/5309c905a93811524a49b4e031e9851a6b00ff0fb668794472ea7746b448/pydantic_core-2.33.2-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:82f68293f055f51b51ea42fafc74b6aad03e70e191799430b90c13d643059ebb", size = 2238715, upload-time = "2025-04-23T18:33:28.656Z" }, + { url = "https://files.pythonhosted.org/packages/32/56/8a7ca5d2cd2cda1d245d34b1c9a942920a718082ae8e54e5f3e5a58b7add/pydantic_core-2.33.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:329467cecfb529c925cf2bbd4d60d2c509bc2fb52a20c1045bf09bb70971a9c1", size = 2066757, upload-time = "2025-04-23T18:33:30.645Z" }, +] + +[[package]] +name = "pygments" +version = "2.19.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581, upload-time = "2025-01-06T17:26:30.443Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293, upload-time = "2025-01-06T17:26:25.553Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bb/22/f1129e69d94ffff626bdb5c835506b3a5b4f3d070f17ea295e12c2c6f60f/pyparsing-3.2.3.tar.gz", hash = "sha256:b9c13f1ab8b3b542f72e28f634bad4de758ab3ce4546e4301970ad6fa77c38be", size = 1088608, upload-time = "2025-03-25T05:01:28.114Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/e7/df2285f3d08fee213f2d041540fa4fc9ca6c2d44cf36d3a035bf2a8d2bcc/pyparsing-3.2.3-py3-none-any.whl", hash = "sha256:a749938e02d6fd0b59b356ca504a24982314bb090c383e3cf201c95ef7e2bfcf", size = 111120, upload-time = "2025-03-25T05:01:24.908Z" }, +] + +[[package]] +name = "pytest" +version = "8.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/aa/405082ce2749be5398045152251ac69c0f3578c7077efc53431303af97ce/pytest-8.4.0.tar.gz", hash = "sha256:14d920b48472ea0dbf68e45b96cd1ffda4705f33307dcc86c676c1b5104838a6", size = 1515232, upload-time = "2025-06-02T17:36:30.03Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/de/afa024cbe022b1b318a3d224125aa24939e99b4ff6f22e0ba639a2eaee47/pytest-8.4.0-py3-none-any.whl", hash = "sha256:f40f825768ad76c0977cbacdf1fd37c6f7a468e460ea6a0636078f8972d4517e", size = 363797, upload-time = "2025-06-02T17:36:27.859Z" }, +] + +[[package]] +name = "pytest-vcr" +version = "1.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pytest" }, + { name = "vcrpy", version = "5.1.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation == 'PyPy'" }, + { name = "vcrpy", version = "7.0.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1a/60/104c619483c1a42775d3f8b27293f1ecfc0728014874d065e68cb9702d49/pytest-vcr-1.0.2.tar.gz", hash = "sha256:23ee51b75abbcc43d926272773aae4f39f93aceb75ed56852d0bf618f92e1896", size = 3810, upload-time = "2019-04-26T19:04:00.806Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/d3/ff520d11e6ee400602711d1ece8168dcfc5b6d8146fb7db4244a6ad6a9c3/pytest_vcr-1.0.2-py2.py3-none-any.whl", hash = "sha256:2f316e0539399bea0296e8b8401145c62b6f85e9066af7e57b6151481b0d6d9c", size = 4137, upload-time = "2019-04-26T19:03:57.034Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "pytz" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/bf/abbd3cdfb8fbc7fb3d4d38d320f2441b1e7cbe29be4f23797b4a2b5d8aac/pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3", size = 320884, upload-time = "2025-03-25T02:25:00.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/c4/34e93fe5f5429d7570ec1fa436f1986fb1f00c3e0f43a589fe2bbcd22c3f/pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00", size = 509225, upload-time = "2025-03-25T02:24:58.468Z" }, +] + +[[package]] +name = "pywin32" +version = "310" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/95/da/a5f38fffbba2fb99aa4aa905480ac4b8e83ca486659ac8c95bce47fb5276/pywin32-310-cp310-cp310-win32.whl", hash = "sha256:6dd97011efc8bf51d6793a82292419eba2c71cf8e7250cfac03bba284454abc1", size = 8848240, upload-time = "2025-03-17T00:55:46.783Z" }, + { url = "https://files.pythonhosted.org/packages/aa/fe/d873a773324fa565619ba555a82c9dabd677301720f3660a731a5d07e49a/pywin32-310-cp310-cp310-win_amd64.whl", hash = "sha256:c3e78706e4229b915a0821941a84e7ef420bf2b77e08c9dae3c76fd03fd2ae3d", size = 9601854, upload-time = "2025-03-17T00:55:48.783Z" }, + { url = "https://files.pythonhosted.org/packages/3c/84/1a8e3d7a15490d28a5d816efa229ecb4999cdc51a7c30dd8914f669093b8/pywin32-310-cp310-cp310-win_arm64.whl", hash = "sha256:33babed0cf0c92a6f94cc6cc13546ab24ee13e3e800e61ed87609ab91e4c8213", size = 8522963, upload-time = "2025-03-17T00:55:50.969Z" }, + { url = "https://files.pythonhosted.org/packages/f7/b1/68aa2986129fb1011dabbe95f0136f44509afaf072b12b8f815905a39f33/pywin32-310-cp311-cp311-win32.whl", hash = "sha256:1e765f9564e83011a63321bb9d27ec456a0ed90d3732c4b2e312b855365ed8bd", size = 8784284, upload-time = "2025-03-17T00:55:53.124Z" }, + { url = "https://files.pythonhosted.org/packages/b3/bd/d1592635992dd8db5bb8ace0551bc3a769de1ac8850200cfa517e72739fb/pywin32-310-cp311-cp311-win_amd64.whl", hash = "sha256:126298077a9d7c95c53823934f000599f66ec9296b09167810eb24875f32689c", size = 9520748, upload-time = "2025-03-17T00:55:55.203Z" }, + { url = "https://files.pythonhosted.org/packages/90/b1/ac8b1ffce6603849eb45a91cf126c0fa5431f186c2e768bf56889c46f51c/pywin32-310-cp311-cp311-win_arm64.whl", hash = "sha256:19ec5fc9b1d51c4350be7bb00760ffce46e6c95eaf2f0b2f1150657b1a43c582", size = 8455941, upload-time = "2025-03-17T00:55:57.048Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ec/4fdbe47932f671d6e348474ea35ed94227fb5df56a7c30cbbb42cd396ed0/pywin32-310-cp312-cp312-win32.whl", hash = "sha256:8a75a5cc3893e83a108c05d82198880704c44bbaee4d06e442e471d3c9ea4f3d", size = 8796239, upload-time = "2025-03-17T00:55:58.807Z" }, + { url = "https://files.pythonhosted.org/packages/e3/e5/b0627f8bb84e06991bea89ad8153a9e50ace40b2e1195d68e9dff6b03d0f/pywin32-310-cp312-cp312-win_amd64.whl", hash = "sha256:bf5c397c9a9a19a6f62f3fb821fbf36cac08f03770056711f765ec1503972060", size = 9503839, upload-time = "2025-03-17T00:56:00.8Z" }, + { url = "https://files.pythonhosted.org/packages/1f/32/9ccf53748df72301a89713936645a664ec001abd35ecc8578beda593d37d/pywin32-310-cp312-cp312-win_arm64.whl", hash = "sha256:2349cc906eae872d0663d4d6290d13b90621eaf78964bb1578632ff20e152966", size = 8459470, upload-time = "2025-03-17T00:56:02.601Z" }, + { url = "https://files.pythonhosted.org/packages/1c/09/9c1b978ffc4ae53999e89c19c77ba882d9fce476729f23ef55211ea1c034/pywin32-310-cp313-cp313-win32.whl", hash = "sha256:5d241a659c496ada3253cd01cfaa779b048e90ce4b2b38cd44168ad555ce74ab", size = 8794384, upload-time = "2025-03-17T00:56:04.383Z" }, + { url = "https://files.pythonhosted.org/packages/45/3c/b4640f740ffebadd5d34df35fecba0e1cfef8fde9f3e594df91c28ad9b50/pywin32-310-cp313-cp313-win_amd64.whl", hash = "sha256:667827eb3a90208ddbdcc9e860c81bde63a135710e21e4cb3348968e4bd5249e", size = 9503039, upload-time = "2025-03-17T00:56:06.207Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f4/f785020090fb050e7fb6d34b780f2231f302609dc964672f72bfaeb59a28/pywin32-310-cp313-cp313-win_arm64.whl", hash = "sha256:e308f831de771482b7cf692a1f308f8fca701b2d8f9dde6cc440c7da17e47b33", size = 8458152, upload-time = "2025-03-17T00:56:07.819Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/ed/79a089b6be93607fa5cdaedf301d7dfb23af5f25c398d5ead2525b063e17/pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e", size = 130631, upload-time = "2024-08-06T20:33:50.674Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/95/a3fac87cb7158e231b5a6012e438c647e1a87f09f8e0d123acec8ab8bf71/PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086", size = 184199, upload-time = "2024-08-06T20:31:40.178Z" }, + { url = "https://files.pythonhosted.org/packages/c7/7a/68bd47624dab8fd4afbfd3c48e3b79efe09098ae941de5b58abcbadff5cb/PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf", size = 171758, upload-time = "2024-08-06T20:31:42.173Z" }, + { url = "https://files.pythonhosted.org/packages/49/ee/14c54df452143b9ee9f0f29074d7ca5516a36edb0b4cc40c3f280131656f/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237", size = 718463, upload-time = "2024-08-06T20:31:44.263Z" }, + { url = "https://files.pythonhosted.org/packages/4d/61/de363a97476e766574650d742205be468921a7b532aa2499fcd886b62530/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b", size = 719280, upload-time = "2024-08-06T20:31:50.199Z" }, + { url = "https://files.pythonhosted.org/packages/6b/4e/1523cb902fd98355e2e9ea5e5eb237cbc5f3ad5f3075fa65087aa0ecb669/PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed", size = 751239, upload-time = "2024-08-06T20:31:52.292Z" }, + { url = "https://files.pythonhosted.org/packages/b7/33/5504b3a9a4464893c32f118a9cc045190a91637b119a9c881da1cf6b7a72/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180", size = 695802, upload-time = "2024-08-06T20:31:53.836Z" }, + { url = "https://files.pythonhosted.org/packages/5c/20/8347dcabd41ef3a3cdc4f7b7a2aff3d06598c8779faa189cdbf878b626a4/PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68", size = 720527, upload-time = "2024-08-06T20:31:55.565Z" }, + { url = "https://files.pythonhosted.org/packages/be/aa/5afe99233fb360d0ff37377145a949ae258aaab831bde4792b32650a4378/PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99", size = 144052, upload-time = "2024-08-06T20:31:56.914Z" }, + { url = "https://files.pythonhosted.org/packages/b5/84/0fa4b06f6d6c958d207620fc60005e241ecedceee58931bb20138e1e5776/PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e", size = 161774, upload-time = "2024-08-06T20:31:58.304Z" }, + { url = "https://files.pythonhosted.org/packages/f8/aa/7af4e81f7acba21a4c6be026da38fd2b872ca46226673c89a758ebdc4fd2/PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774", size = 184612, upload-time = "2024-08-06T20:32:03.408Z" }, + { url = "https://files.pythonhosted.org/packages/8b/62/b9faa998fd185f65c1371643678e4d58254add437edb764a08c5a98fb986/PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee", size = 172040, upload-time = "2024-08-06T20:32:04.926Z" }, + { url = "https://files.pythonhosted.org/packages/ad/0c/c804f5f922a9a6563bab712d8dcc70251e8af811fce4524d57c2c0fd49a4/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c", size = 736829, upload-time = "2024-08-06T20:32:06.459Z" }, + { url = "https://files.pythonhosted.org/packages/51/16/6af8d6a6b210c8e54f1406a6b9481febf9c64a3109c541567e35a49aa2e7/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317", size = 764167, upload-time = "2024-08-06T20:32:08.338Z" }, + { url = "https://files.pythonhosted.org/packages/75/e4/2c27590dfc9992f73aabbeb9241ae20220bd9452df27483b6e56d3975cc5/PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85", size = 762952, upload-time = "2024-08-06T20:32:14.124Z" }, + { url = "https://files.pythonhosted.org/packages/9b/97/ecc1abf4a823f5ac61941a9c00fe501b02ac3ab0e373c3857f7d4b83e2b6/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4", size = 735301, upload-time = "2024-08-06T20:32:16.17Z" }, + { url = "https://files.pythonhosted.org/packages/45/73/0f49dacd6e82c9430e46f4a027baa4ca205e8b0a9dce1397f44edc23559d/PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e", size = 756638, upload-time = "2024-08-06T20:32:18.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/5f/956f0f9fc65223a58fbc14459bf34b4cc48dec52e00535c79b8db361aabd/PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5", size = 143850, upload-time = "2024-08-06T20:32:19.889Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/8da0bbe2ab9dcdd11f4f4557ccaf95c10b9811b13ecced089d43ce59c3c8/PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44", size = 161980, upload-time = "2024-08-06T20:32:21.273Z" }, + { url = "https://files.pythonhosted.org/packages/86/0c/c581167fc46d6d6d7ddcfb8c843a4de25bdd27e4466938109ca68492292c/PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab", size = 183873, upload-time = "2024-08-06T20:32:25.131Z" }, + { url = "https://files.pythonhosted.org/packages/a8/0c/38374f5bb272c051e2a69281d71cba6fdb983413e6758b84482905e29a5d/PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725", size = 173302, upload-time = "2024-08-06T20:32:26.511Z" }, + { url = "https://files.pythonhosted.org/packages/c3/93/9916574aa8c00aa06bbac729972eb1071d002b8e158bd0e83a3b9a20a1f7/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5", size = 739154, upload-time = "2024-08-06T20:32:28.363Z" }, + { url = "https://files.pythonhosted.org/packages/95/0f/b8938f1cbd09739c6da569d172531567dbcc9789e0029aa070856f123984/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425", size = 766223, upload-time = "2024-08-06T20:32:30.058Z" }, + { url = "https://files.pythonhosted.org/packages/b9/2b/614b4752f2e127db5cc206abc23a8c19678e92b23c3db30fc86ab731d3bd/PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476", size = 767542, upload-time = "2024-08-06T20:32:31.881Z" }, + { url = "https://files.pythonhosted.org/packages/d4/00/dd137d5bcc7efea1836d6264f049359861cf548469d18da90cd8216cf05f/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48", size = 731164, upload-time = "2024-08-06T20:32:37.083Z" }, + { url = "https://files.pythonhosted.org/packages/c9/1f/4f998c900485e5c0ef43838363ba4a9723ac0ad73a9dc42068b12aaba4e4/PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b", size = 756611, upload-time = "2024-08-06T20:32:38.898Z" }, + { url = "https://files.pythonhosted.org/packages/df/d1/f5a275fdb252768b7a11ec63585bc38d0e87c9e05668a139fea92b80634c/PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4", size = 140591, upload-time = "2024-08-06T20:32:40.241Z" }, + { url = "https://files.pythonhosted.org/packages/0c/e8/4f648c598b17c3d06e8753d7d13d57542b30d56e6c2dedf9c331ae56312e/PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8", size = 156338, upload-time = "2024-08-06T20:32:41.93Z" }, + { url = "https://files.pythonhosted.org/packages/ef/e3/3af305b830494fa85d95f6d95ef7fa73f2ee1cc8ef5b495c7c3269fb835f/PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba", size = 181309, upload-time = "2024-08-06T20:32:43.4Z" }, + { url = "https://files.pythonhosted.org/packages/45/9f/3b1c20a0b7a3200524eb0076cc027a970d320bd3a6592873c85c92a08731/PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1", size = 171679, upload-time = "2024-08-06T20:32:44.801Z" }, + { url = "https://files.pythonhosted.org/packages/7c/9a/337322f27005c33bcb656c655fa78325b730324c78620e8328ae28b64d0c/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133", size = 733428, upload-time = "2024-08-06T20:32:46.432Z" }, + { url = "https://files.pythonhosted.org/packages/a3/69/864fbe19e6c18ea3cc196cbe5d392175b4cf3d5d0ac1403ec3f2d237ebb5/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484", size = 763361, upload-time = "2024-08-06T20:32:51.188Z" }, + { url = "https://files.pythonhosted.org/packages/04/24/b7721e4845c2f162d26f50521b825fb061bc0a5afcf9a386840f23ea19fa/PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5", size = 759523, upload-time = "2024-08-06T20:32:53.019Z" }, + { url = "https://files.pythonhosted.org/packages/2b/b2/e3234f59ba06559c6ff63c4e10baea10e5e7df868092bf9ab40e5b9c56b6/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc", size = 726660, upload-time = "2024-08-06T20:32:54.708Z" }, + { url = "https://files.pythonhosted.org/packages/fe/0f/25911a9f080464c59fab9027482f822b86bf0608957a5fcc6eaac85aa515/PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652", size = 751597, upload-time = "2024-08-06T20:32:56.985Z" }, + { url = "https://files.pythonhosted.org/packages/14/0d/e2c3b43bbce3cf6bd97c840b46088a3031085179e596d4929729d8d68270/PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183", size = 140527, upload-time = "2024-08-06T20:33:03.001Z" }, + { url = "https://files.pythonhosted.org/packages/fa/de/02b54f42487e3d3c6efb3f89428677074ca7bf43aae402517bc7cca949f3/PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563", size = 156446, upload-time = "2024-08-06T20:33:04.33Z" }, +] + +[[package]] +name = "pyzmq" +version = "26.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/11/b9213d25230ac18a71b39b3723494e57adebe36e066397b961657b3b41c1/pyzmq-26.4.0.tar.gz", hash = "sha256:4bd13f85f80962f91a651a7356fe0472791a5f7a92f227822b5acf44795c626d", size = 278293, upload-time = "2025-04-04T12:05:44.049Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/b8/af1d814ffc3ff9730f9a970cbf216b6f078e5d251a25ef5201d7bc32a37c/pyzmq-26.4.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:0329bdf83e170ac133f44a233fc651f6ed66ef8e66693b5af7d54f45d1ef5918", size = 1339238, upload-time = "2025-04-04T12:03:07.022Z" }, + { url = "https://files.pythonhosted.org/packages/ee/e4/5aafed4886c264f2ea6064601ad39c5fc4e9b6539c6ebe598a859832eeee/pyzmq-26.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:398a825d2dea96227cf6460ce0a174cf7657d6f6827807d4d1ae9d0f9ae64315", size = 672848, upload-time = "2025-04-04T12:03:08.591Z" }, + { url = "https://files.pythonhosted.org/packages/79/39/026bf49c721cb42f1ef3ae0ee3d348212a7621d2adb739ba97599b6e4d50/pyzmq-26.4.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6d52d62edc96787f5c1dfa6c6ccff9b581cfae5a70d94ec4c8da157656c73b5b", size = 911299, upload-time = "2025-04-04T12:03:10Z" }, + { url = "https://files.pythonhosted.org/packages/03/23/b41f936a9403b8f92325c823c0f264c6102a0687a99c820f1aaeb99c1def/pyzmq-26.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1410c3a3705db68d11eb2424d75894d41cff2f64d948ffe245dd97a9debfebf4", size = 867920, upload-time = "2025-04-04T12:03:11.311Z" }, + { url = "https://files.pythonhosted.org/packages/c1/3e/2de5928cdadc2105e7c8f890cc5f404136b41ce5b6eae5902167f1d5641c/pyzmq-26.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:7dacb06a9c83b007cc01e8e5277f94c95c453c5851aac5e83efe93e72226353f", size = 862514, upload-time = "2025-04-04T12:03:13.013Z" }, + { url = "https://files.pythonhosted.org/packages/ce/57/109569514dd32e05a61d4382bc88980c95bfd2f02e58fea47ec0ccd96de1/pyzmq-26.4.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6bab961c8c9b3a4dc94d26e9b2cdf84de9918931d01d6ff38c721a83ab3c0ef5", size = 1204494, upload-time = "2025-04-04T12:03:14.795Z" }, + { url = "https://files.pythonhosted.org/packages/aa/02/dc51068ff2ca70350d1151833643a598625feac7b632372d229ceb4de3e1/pyzmq-26.4.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:7a5c09413b924d96af2aa8b57e76b9b0058284d60e2fc3730ce0f979031d162a", size = 1514525, upload-time = "2025-04-04T12:03:16.246Z" }, + { url = "https://files.pythonhosted.org/packages/48/2a/a7d81873fff0645eb60afaec2b7c78a85a377af8f1d911aff045d8955bc7/pyzmq-26.4.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7d489ac234d38e57f458fdbd12a996bfe990ac028feaf6f3c1e81ff766513d3b", size = 1414659, upload-time = "2025-04-04T12:03:17.652Z" }, + { url = "https://files.pythonhosted.org/packages/ef/ea/813af9c42ae21845c1ccfe495bd29c067622a621e85d7cda6bc437de8101/pyzmq-26.4.0-cp310-cp310-win32.whl", hash = "sha256:dea1c8db78fb1b4b7dc9f8e213d0af3fc8ecd2c51a1d5a3ca1cde1bda034a980", size = 580348, upload-time = "2025-04-04T12:03:19.384Z" }, + { url = "https://files.pythonhosted.org/packages/20/68/318666a89a565252c81d3fed7f3b4c54bd80fd55c6095988dfa2cd04a62b/pyzmq-26.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:fa59e1f5a224b5e04dc6c101d7186058efa68288c2d714aa12d27603ae93318b", size = 643838, upload-time = "2025-04-04T12:03:20.795Z" }, + { url = "https://files.pythonhosted.org/packages/91/f8/fb1a15b5f4ecd3e588bfde40c17d32ed84b735195b5c7d1d7ce88301a16f/pyzmq-26.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:a651fe2f447672f4a815e22e74630b6b1ec3a1ab670c95e5e5e28dcd4e69bbb5", size = 559565, upload-time = "2025-04-04T12:03:22.676Z" }, + { url = "https://files.pythonhosted.org/packages/32/6d/234e3b0aa82fd0290b1896e9992f56bdddf1f97266110be54d0177a9d2d9/pyzmq-26.4.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:bfcf82644c9b45ddd7cd2a041f3ff8dce4a0904429b74d73a439e8cab1bd9e54", size = 1339723, upload-time = "2025-04-04T12:03:24.358Z" }, + { url = "https://files.pythonhosted.org/packages/4f/11/6d561efe29ad83f7149a7cd48e498e539ed09019c6cd7ecc73f4cc725028/pyzmq-26.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e9bcae3979b2654d5289d3490742378b2f3ce804b0b5fd42036074e2bf35b030", size = 672645, upload-time = "2025-04-04T12:03:25.693Z" }, + { url = "https://files.pythonhosted.org/packages/19/fd/81bfe3e23f418644660bad1a90f0d22f0b3eebe33dd65a79385530bceb3d/pyzmq-26.4.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ccdff8ac4246b6fb60dcf3982dfaeeff5dd04f36051fe0632748fc0aa0679c01", size = 910133, upload-time = "2025-04-04T12:03:27.625Z" }, + { url = "https://files.pythonhosted.org/packages/97/68/321b9c775595ea3df832a9516252b653fe32818db66fdc8fa31c9b9fce37/pyzmq-26.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4550af385b442dc2d55ab7717837812799d3674cb12f9a3aa897611839c18e9e", size = 867428, upload-time = "2025-04-04T12:03:29.004Z" }, + { url = "https://files.pythonhosted.org/packages/4e/6e/159cbf2055ef36aa2aa297e01b24523176e5b48ead283c23a94179fb2ba2/pyzmq-26.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:2f9f7ffe9db1187a253fca95191854b3fda24696f086e8789d1d449308a34b88", size = 862409, upload-time = "2025-04-04T12:03:31.032Z" }, + { url = "https://files.pythonhosted.org/packages/05/1c/45fb8db7be5a7d0cadea1070a9cbded5199a2d578de2208197e592f219bd/pyzmq-26.4.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:3709c9ff7ba61589b7372923fd82b99a81932b592a5c7f1a24147c91da9a68d6", size = 1205007, upload-time = "2025-04-04T12:03:32.687Z" }, + { url = "https://files.pythonhosted.org/packages/f8/fa/658c7f583af6498b463f2fa600f34e298e1b330886f82f1feba0dc2dd6c3/pyzmq-26.4.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:f8f3c30fb2d26ae5ce36b59768ba60fb72507ea9efc72f8f69fa088450cff1df", size = 1514599, upload-time = "2025-04-04T12:03:34.084Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d7/44d641522353ce0a2bbd150379cb5ec32f7120944e6bfba4846586945658/pyzmq-26.4.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:382a4a48c8080e273427fc692037e3f7d2851959ffe40864f2db32646eeb3cef", size = 1414546, upload-time = "2025-04-04T12:03:35.478Z" }, + { url = "https://files.pythonhosted.org/packages/72/76/c8ed7263218b3d1e9bce07b9058502024188bd52cc0b0a267a9513b431fc/pyzmq-26.4.0-cp311-cp311-win32.whl", hash = "sha256:d56aad0517d4c09e3b4f15adebba8f6372c5102c27742a5bdbfc74a7dceb8fca", size = 579247, upload-time = "2025-04-04T12:03:36.846Z" }, + { url = "https://files.pythonhosted.org/packages/c3/d0/2d9abfa2571a0b1a67c0ada79a8aa1ba1cce57992d80f771abcdf99bb32c/pyzmq-26.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:963977ac8baed7058c1e126014f3fe58b3773f45c78cce7af5c26c09b6823896", size = 644727, upload-time = "2025-04-04T12:03:38.578Z" }, + { url = "https://files.pythonhosted.org/packages/0d/d1/c8ad82393be6ccedfc3c9f3adb07f8f3976e3c4802640fe3f71441941e70/pyzmq-26.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:c0c8e8cadc81e44cc5088fcd53b9b3b4ce9344815f6c4a03aec653509296fae3", size = 559942, upload-time = "2025-04-04T12:03:40.143Z" }, + { url = "https://files.pythonhosted.org/packages/10/44/a778555ebfdf6c7fc00816aad12d185d10a74d975800341b1bc36bad1187/pyzmq-26.4.0-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:5227cb8da4b6f68acfd48d20c588197fd67745c278827d5238c707daf579227b", size = 1341586, upload-time = "2025-04-04T12:03:41.954Z" }, + { url = "https://files.pythonhosted.org/packages/9c/4f/f3a58dc69ac757e5103be3bd41fb78721a5e17da7cc617ddb56d973a365c/pyzmq-26.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1c07a7fa7f7ba86554a2b1bef198c9fed570c08ee062fd2fd6a4dcacd45f905", size = 665880, upload-time = "2025-04-04T12:03:43.45Z" }, + { url = "https://files.pythonhosted.org/packages/fe/45/50230bcfb3ae5cb98bee683b6edeba1919f2565d7cc1851d3c38e2260795/pyzmq-26.4.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae775fa83f52f52de73183f7ef5395186f7105d5ed65b1ae65ba27cb1260de2b", size = 902216, upload-time = "2025-04-04T12:03:45.572Z" }, + { url = "https://files.pythonhosted.org/packages/41/59/56bbdc5689be5e13727491ad2ba5efd7cd564365750514f9bc8f212eef82/pyzmq-26.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66c760d0226ebd52f1e6b644a9e839b5db1e107a23f2fcd46ec0569a4fdd4e63", size = 859814, upload-time = "2025-04-04T12:03:47.188Z" }, + { url = "https://files.pythonhosted.org/packages/81/b1/57db58cfc8af592ce94f40649bd1804369c05b2190e4cbc0a2dad572baeb/pyzmq-26.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ef8c6ecc1d520debc147173eaa3765d53f06cd8dbe7bd377064cdbc53ab456f5", size = 855889, upload-time = "2025-04-04T12:03:49.223Z" }, + { url = "https://files.pythonhosted.org/packages/e8/92/47542e629cbac8f221c230a6d0f38dd3d9cff9f6f589ed45fdf572ffd726/pyzmq-26.4.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3150ef4084e163dec29ae667b10d96aad309b668fac6810c9e8c27cf543d6e0b", size = 1197153, upload-time = "2025-04-04T12:03:50.591Z" }, + { url = "https://files.pythonhosted.org/packages/07/e5/b10a979d1d565d54410afc87499b16c96b4a181af46e7645ab4831b1088c/pyzmq-26.4.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:4448c9e55bf8329fa1dcedd32f661bf611214fa70c8e02fee4347bc589d39a84", size = 1507352, upload-time = "2025-04-04T12:03:52.473Z" }, + { url = "https://files.pythonhosted.org/packages/ab/58/5a23db84507ab9c01c04b1232a7a763be66e992aa2e66498521bbbc72a71/pyzmq-26.4.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e07dde3647afb084d985310d067a3efa6efad0621ee10826f2cb2f9a31b89d2f", size = 1406834, upload-time = "2025-04-04T12:03:54Z" }, + { url = "https://files.pythonhosted.org/packages/22/74/aaa837b331580c13b79ac39396601fb361454ee184ca85e8861914769b99/pyzmq-26.4.0-cp312-cp312-win32.whl", hash = "sha256:ba034a32ecf9af72adfa5ee383ad0fd4f4e38cdb62b13624278ef768fe5b5b44", size = 577992, upload-time = "2025-04-04T12:03:55.815Z" }, + { url = "https://files.pythonhosted.org/packages/30/0f/55f8c02c182856743b82dde46b2dc3e314edda7f1098c12a8227eeda0833/pyzmq-26.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:056a97aab4064f526ecb32f4343917a4022a5d9efb6b9df990ff72e1879e40be", size = 640466, upload-time = "2025-04-04T12:03:57.231Z" }, + { url = "https://files.pythonhosted.org/packages/e4/29/073779afc3ef6f830b8de95026ef20b2d1ec22d0324d767748d806e57379/pyzmq-26.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:2f23c750e485ce1eb639dbd576d27d168595908aa2d60b149e2d9e34c9df40e0", size = 556342, upload-time = "2025-04-04T12:03:59.218Z" }, + { url = "https://files.pythonhosted.org/packages/d7/20/fb2c92542488db70f833b92893769a569458311a76474bda89dc4264bd18/pyzmq-26.4.0-cp313-cp313-macosx_10_15_universal2.whl", hash = "sha256:c43fac689880f5174d6fc864857d1247fe5cfa22b09ed058a344ca92bf5301e3", size = 1339484, upload-time = "2025-04-04T12:04:00.671Z" }, + { url = "https://files.pythonhosted.org/packages/58/29/2f06b9cabda3a6ea2c10f43e67ded3e47fc25c54822e2506dfb8325155d4/pyzmq-26.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:902aca7eba477657c5fb81c808318460328758e8367ecdd1964b6330c73cae43", size = 666106, upload-time = "2025-04-04T12:04:02.366Z" }, + { url = "https://files.pythonhosted.org/packages/77/e4/dcf62bd29e5e190bd21bfccaa4f3386e01bf40d948c239239c2f1e726729/pyzmq-26.4.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5e48a830bfd152fe17fbdeaf99ac5271aa4122521bf0d275b6b24e52ef35eb6", size = 902056, upload-time = "2025-04-04T12:04:03.919Z" }, + { url = "https://files.pythonhosted.org/packages/1a/cf/b36b3d7aea236087d20189bec1a87eeb2b66009731d7055e5c65f845cdba/pyzmq-26.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31be2b6de98c824c06f5574331f805707c667dc8f60cb18580b7de078479891e", size = 860148, upload-time = "2025-04-04T12:04:05.581Z" }, + { url = "https://files.pythonhosted.org/packages/18/a6/f048826bc87528c208e90604c3bf573801e54bd91e390cbd2dfa860e82dc/pyzmq-26.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:6332452034be001bbf3206ac59c0d2a7713de5f25bb38b06519fc6967b7cf771", size = 855983, upload-time = "2025-04-04T12:04:07.096Z" }, + { url = "https://files.pythonhosted.org/packages/0a/27/454d34ab6a1d9772a36add22f17f6b85baf7c16e14325fa29e7202ca8ee8/pyzmq-26.4.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:da8c0f5dd352136853e6a09b1b986ee5278dfddfebd30515e16eae425c872b30", size = 1197274, upload-time = "2025-04-04T12:04:08.523Z" }, + { url = "https://files.pythonhosted.org/packages/f4/3d/7abfeab6b83ad38aa34cbd57c6fc29752c391e3954fd12848bd8d2ec0df6/pyzmq-26.4.0-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:f4ccc1a0a2c9806dda2a2dd118a3b7b681e448f3bb354056cad44a65169f6d86", size = 1507120, upload-time = "2025-04-04T12:04:10.58Z" }, + { url = "https://files.pythonhosted.org/packages/13/ff/bc8d21dbb9bc8705126e875438a1969c4f77e03fc8565d6901c7933a3d01/pyzmq-26.4.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:1c0b5fceadbab461578daf8d1dcc918ebe7ddd2952f748cf30c7cf2de5d51101", size = 1406738, upload-time = "2025-04-04T12:04:12.509Z" }, + { url = "https://files.pythonhosted.org/packages/f5/5d/d4cd85b24de71d84d81229e3bbb13392b2698432cf8fdcea5afda253d587/pyzmq-26.4.0-cp313-cp313-win32.whl", hash = "sha256:28e2b0ff5ba4b3dd11062d905682bad33385cfa3cc03e81abd7f0822263e6637", size = 577826, upload-time = "2025-04-04T12:04:14.289Z" }, + { url = "https://files.pythonhosted.org/packages/c6/6c/f289c1789d7bb6e5a3b3bef7b2a55089b8561d17132be7d960d3ff33b14e/pyzmq-26.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:23ecc9d241004c10e8b4f49d12ac064cd7000e1643343944a10df98e57bc544b", size = 640406, upload-time = "2025-04-04T12:04:15.757Z" }, + { url = "https://files.pythonhosted.org/packages/b3/99/676b8851cb955eb5236a0c1e9ec679ea5ede092bf8bf2c8a68d7e965cac3/pyzmq-26.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:1edb0385c7f025045d6e0f759d4d3afe43c17a3d898914ec6582e6f464203c08", size = 556216, upload-time = "2025-04-04T12:04:17.212Z" }, + { url = "https://files.pythonhosted.org/packages/65/c2/1fac340de9d7df71efc59d9c50fc7a635a77b103392d1842898dd023afcb/pyzmq-26.4.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:93a29e882b2ba1db86ba5dd5e88e18e0ac6b627026c5cfbec9983422011b82d4", size = 1333769, upload-time = "2025-04-04T12:04:18.665Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c7/6c03637e8d742c3b00bec4f5e4cd9d1c01b2f3694c6f140742e93ca637ed/pyzmq-26.4.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb45684f276f57110bb89e4300c00f1233ca631f08f5f42528a5c408a79efc4a", size = 658826, upload-time = "2025-04-04T12:04:20.405Z" }, + { url = "https://files.pythonhosted.org/packages/a5/97/a8dca65913c0f78e0545af2bb5078aebfc142ca7d91cdaffa1fbc73e5dbd/pyzmq-26.4.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f72073e75260cb301aad4258ad6150fa7f57c719b3f498cb91e31df16784d89b", size = 891650, upload-time = "2025-04-04T12:04:22.413Z" }, + { url = "https://files.pythonhosted.org/packages/7d/7e/f63af1031eb060bf02d033732b910fe48548dcfdbe9c785e9f74a6cc6ae4/pyzmq-26.4.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:be37e24b13026cfedd233bcbbccd8c0bcd2fdd186216094d095f60076201538d", size = 849776, upload-time = "2025-04-04T12:04:23.959Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/1a009ce582802a895c0d5fe9413f029c940a0a8ee828657a3bb0acffd88b/pyzmq-26.4.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:237b283044934d26f1eeff4075f751b05d2f3ed42a257fc44386d00df6a270cf", size = 842516, upload-time = "2025-04-04T12:04:25.449Z" }, + { url = "https://files.pythonhosted.org/packages/6e/bc/f88b0bad0f7a7f500547d71e99f10336f2314e525d4ebf576a1ea4a1d903/pyzmq-26.4.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:b30f862f6768b17040929a68432c8a8be77780317f45a353cb17e423127d250c", size = 1189183, upload-time = "2025-04-04T12:04:27.035Z" }, + { url = "https://files.pythonhosted.org/packages/d9/8c/db446a3dd9cf894406dec2e61eeffaa3c07c3abb783deaebb9812c4af6a5/pyzmq-26.4.0-cp313-cp313t-musllinux_1_1_i686.whl", hash = "sha256:c80fcd3504232f13617c6ab501124d373e4895424e65de8b72042333316f64a8", size = 1495501, upload-time = "2025-04-04T12:04:28.833Z" }, + { url = "https://files.pythonhosted.org/packages/05/4c/bf3cad0d64c3214ac881299c4562b815f05d503bccc513e3fd4fdc6f67e4/pyzmq-26.4.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:26a2a7451606b87f67cdeca2c2789d86f605da08b4bd616b1a9981605ca3a364", size = 1395540, upload-time = "2025-04-04T12:04:30.562Z" }, + { url = "https://files.pythonhosted.org/packages/47/03/96004704a84095f493be8d2b476641f5c967b269390173f85488a53c1c13/pyzmq-26.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:98d948288ce893a2edc5ec3c438fe8de2daa5bbbd6e2e865ec5f966e237084ba", size = 834408, upload-time = "2025-04-04T12:05:04.569Z" }, + { url = "https://files.pythonhosted.org/packages/e4/7f/68d8f3034a20505db7551cb2260248be28ca66d537a1ac9a257913d778e4/pyzmq-26.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a9f34f5c9e0203ece706a1003f1492a56c06c0632d86cb77bcfe77b56aacf27b", size = 569580, upload-time = "2025-04-04T12:05:06.283Z" }, + { url = "https://files.pythonhosted.org/packages/9b/a6/2b0d6801ec33f2b2a19dd8d02e0a1e8701000fec72926e6787363567d30c/pyzmq-26.4.0-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:80c9b48aef586ff8b698359ce22f9508937c799cc1d2c9c2f7c95996f2300c94", size = 798250, upload-time = "2025-04-04T12:05:07.88Z" }, + { url = "https://files.pythonhosted.org/packages/96/2a/0322b3437de977dcac8a755d6d7ce6ec5238de78e2e2d9353730b297cf12/pyzmq-26.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3f2a5b74009fd50b53b26f65daff23e9853e79aa86e0aa08a53a7628d92d44a", size = 756758, upload-time = "2025-04-04T12:05:09.483Z" }, + { url = "https://files.pythonhosted.org/packages/c2/33/43704f066369416d65549ccee366cc19153911bec0154da7c6b41fca7e78/pyzmq-26.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:61c5f93d7622d84cb3092d7f6398ffc77654c346545313a3737e266fc11a3beb", size = 555371, upload-time = "2025-04-04T12:05:11.062Z" }, + { url = "https://files.pythonhosted.org/packages/04/52/a70fcd5592715702248306d8e1729c10742c2eac44529984413b05c68658/pyzmq-26.4.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4478b14cb54a805088299c25a79f27eaf530564a7a4f72bf432a040042b554eb", size = 834405, upload-time = "2025-04-04T12:05:13.3Z" }, + { url = "https://files.pythonhosted.org/packages/25/f9/1a03f1accff16b3af1a6fa22cbf7ced074776abbf688b2e9cb4629700c62/pyzmq-26.4.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8a28ac29c60e4ba84b5f58605ace8ad495414a724fe7aceb7cf06cd0598d04e1", size = 569578, upload-time = "2025-04-04T12:05:15.36Z" }, + { url = "https://files.pythonhosted.org/packages/76/0c/3a633acd762aa6655fcb71fa841907eae0ab1e8582ff494b137266de341d/pyzmq-26.4.0-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:43b03c1ceea27c6520124f4fb2ba9c647409b9abdf9a62388117148a90419494", size = 798248, upload-time = "2025-04-04T12:05:17.376Z" }, + { url = "https://files.pythonhosted.org/packages/cd/cc/6c99c84aa60ac1cc56747bed6be8ce6305b9b861d7475772e7a25ce019d3/pyzmq-26.4.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7731abd23a782851426d4e37deb2057bf9410848a4459b5ede4fe89342e687a9", size = 756757, upload-time = "2025-04-04T12:05:19.19Z" }, + { url = "https://files.pythonhosted.org/packages/13/9c/d8073bd898eb896e94c679abe82e47506e2b750eb261cf6010ced869797c/pyzmq-26.4.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:a222ad02fbe80166b0526c038776e8042cd4e5f0dec1489a006a1df47e9040e0", size = 555371, upload-time = "2025-04-04T12:05:20.702Z" }, +] + +[[package]] +name = "requests" +version = "2.32.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/0a/929373653770d8a0d7ea76c37de6e41f11eb07559b103b1c02cafb3f7cf8/requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422", size = 135258, upload-time = "2025-06-09T16:43:07.34Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7c/e4/56027c4a6b4ae70ca9de302488c5ca95ad4a39e190093d6c1a8ace08341b/requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c", size = 64847, upload-time = "2025-06-09T16:43:05.728Z" }, +] + +[[package]] +name = "requests-oauthlib" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "oauthlib" }, + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/f2/05f29bc3913aea15eb670be136045bf5c5bbf4b99ecb839da9b422bb2c85/requests-oauthlib-2.0.0.tar.gz", hash = "sha256:b3dffaebd884d8cd778494369603a9e7b58d29111bf6b41bdc2dcd87203af4e9", size = 55650, upload-time = "2024-03-22T20:32:29.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/5d/63d4ae3b9daea098d5d6f5da83984853c1bbacd5dc826764b249fe119d24/requests_oauthlib-2.0.0-py2.py3-none-any.whl", hash = "sha256:7dd8a5c40426b779b0868c404bdef9768deccf22749cde15852df527e6269b36", size = 24179, upload-time = "2024-03-22T20:32:28.055Z" }, +] + +[[package]] +name = "ruff" +version = "0.11.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ed/da/9c6f995903b4d9474b39da91d2d626659af3ff1eeb43e9ae7c119349dba6/ruff-0.11.13.tar.gz", hash = "sha256:26fa247dc68d1d4e72c179e08889a25ac0c7ba4d78aecfc835d49cbfd60bf514", size = 4282054, upload-time = "2025-06-05T21:00:15.721Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7d/ce/a11d381192966e0b4290842cc8d4fac7dc9214ddf627c11c1afff87da29b/ruff-0.11.13-py3-none-linux_armv6l.whl", hash = "sha256:4bdfbf1240533f40042ec00c9e09a3aade6f8c10b6414cf11b519488d2635d46", size = 10292516, upload-time = "2025-06-05T20:59:32.944Z" }, + { url = "https://files.pythonhosted.org/packages/78/db/87c3b59b0d4e753e40b6a3b4a2642dfd1dcaefbff121ddc64d6c8b47ba00/ruff-0.11.13-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:aef9c9ed1b5ca28bb15c7eac83b8670cf3b20b478195bd49c8d756ba0a36cf48", size = 11106083, upload-time = "2025-06-05T20:59:37.03Z" }, + { url = "https://files.pythonhosted.org/packages/77/79/d8cec175856ff810a19825d09ce700265f905c643c69f45d2b737e4a470a/ruff-0.11.13-py3-none-macosx_11_0_arm64.whl", hash = "sha256:53b15a9dfdce029c842e9a5aebc3855e9ab7771395979ff85b7c1dedb53ddc2b", size = 10436024, upload-time = "2025-06-05T20:59:39.741Z" }, + { url = "https://files.pythonhosted.org/packages/8b/5b/f6d94f2980fa1ee854b41568368a2e1252681b9238ab2895e133d303538f/ruff-0.11.13-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ab153241400789138d13f362c43f7edecc0edfffce2afa6a68434000ecd8f69a", size = 10646324, upload-time = "2025-06-05T20:59:42.185Z" }, + { url = "https://files.pythonhosted.org/packages/6c/9c/b4c2acf24ea4426016d511dfdc787f4ce1ceb835f3c5fbdbcb32b1c63bda/ruff-0.11.13-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6c51f93029d54a910d3d24f7dd0bb909e31b6cd989a5e4ac513f4eb41629f0dc", size = 10174416, upload-time = "2025-06-05T20:59:44.319Z" }, + { url = "https://files.pythonhosted.org/packages/f3/10/e2e62f77c65ede8cd032c2ca39c41f48feabedb6e282bfd6073d81bb671d/ruff-0.11.13-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1808b3ed53e1a777c2ef733aca9051dc9bf7c99b26ece15cb59a0320fbdbd629", size = 11724197, upload-time = "2025-06-05T20:59:46.935Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f0/466fe8469b85c561e081d798c45f8a1d21e0b4a5ef795a1d7f1a9a9ec182/ruff-0.11.13-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:d28ce58b5ecf0f43c1b71edffabe6ed7f245d5336b17805803312ec9bc665933", size = 12511615, upload-time = "2025-06-05T20:59:49.534Z" }, + { url = "https://files.pythonhosted.org/packages/17/0e/cefe778b46dbd0cbcb03a839946c8f80a06f7968eb298aa4d1a4293f3448/ruff-0.11.13-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:55e4bc3a77842da33c16d55b32c6cac1ec5fb0fbec9c8c513bdce76c4f922165", size = 12117080, upload-time = "2025-06-05T20:59:51.654Z" }, + { url = "https://files.pythonhosted.org/packages/5d/2c/caaeda564cbe103bed145ea557cb86795b18651b0f6b3ff6a10e84e5a33f/ruff-0.11.13-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:633bf2c6f35678c56ec73189ba6fa19ff1c5e4807a78bf60ef487b9dd272cc71", size = 11326315, upload-time = "2025-06-05T20:59:54.469Z" }, + { url = "https://files.pythonhosted.org/packages/75/f0/782e7d681d660eda8c536962920c41309e6dd4ebcea9a2714ed5127d44bd/ruff-0.11.13-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4ffbc82d70424b275b089166310448051afdc6e914fdab90e08df66c43bb5ca9", size = 11555640, upload-time = "2025-06-05T20:59:56.986Z" }, + { url = "https://files.pythonhosted.org/packages/5d/d4/3d580c616316c7f07fb3c99dbecfe01fbaea7b6fd9a82b801e72e5de742a/ruff-0.11.13-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:4a9ddd3ec62a9a89578c85842b836e4ac832d4a2e0bfaad3b02243f930ceafcc", size = 10507364, upload-time = "2025-06-05T20:59:59.154Z" }, + { url = "https://files.pythonhosted.org/packages/5a/dc/195e6f17d7b3ea6b12dc4f3e9de575db7983db187c378d44606e5d503319/ruff-0.11.13-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d237a496e0778d719efb05058c64d28b757c77824e04ffe8796c7436e26712b7", size = 10141462, upload-time = "2025-06-05T21:00:01.481Z" }, + { url = "https://files.pythonhosted.org/packages/f4/8e/39a094af6967faa57ecdeacb91bedfb232474ff8c3d20f16a5514e6b3534/ruff-0.11.13-py3-none-musllinux_1_2_i686.whl", hash = "sha256:26816a218ca6ef02142343fd24c70f7cd8c5aa6c203bca284407adf675984432", size = 11121028, upload-time = "2025-06-05T21:00:04.06Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c0/b0b508193b0e8a1654ec683ebab18d309861f8bd64e3a2f9648b80d392cb/ruff-0.11.13-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:51c3f95abd9331dc5b87c47ac7f376db5616041173826dfd556cfe3d4977f492", size = 11602992, upload-time = "2025-06-05T21:00:06.249Z" }, + { url = "https://files.pythonhosted.org/packages/7c/91/263e33ab93ab09ca06ce4f8f8547a858cc198072f873ebc9be7466790bae/ruff-0.11.13-py3-none-win32.whl", hash = "sha256:96c27935418e4e8e77a26bb05962817f28b8ef3843a6c6cc49d8783b5507f250", size = 10474944, upload-time = "2025-06-05T21:00:08.459Z" }, + { url = "https://files.pythonhosted.org/packages/46/f4/7c27734ac2073aae8efb0119cae6931b6fb48017adf048fdf85c19337afc/ruff-0.11.13-py3-none-win_amd64.whl", hash = "sha256:29c3189895a8a6a657b7af4e97d330c8a3afd2c9c8f46c81e2fc5a31866517e3", size = 11548669, upload-time = "2025-06-05T21:00:11.147Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bf/b273dd11673fed8a6bd46032c0ea2a04b2ac9bfa9c628756a5856ba113b0/ruff-0.11.13-py3-none-win_arm64.whl", hash = "sha256:b4385285e9179d608ff1d2fb9922062663c658605819a6876d8beef0c30b7f3b", size = 10683928, upload-time = "2025-06-05T21:00:13.758Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "tomli" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175, upload-time = "2024-11-27T22:38:36.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077, upload-time = "2024-11-27T22:37:54.956Z" }, + { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429, upload-time = "2024-11-27T22:37:56.698Z" }, + { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067, upload-time = "2024-11-27T22:37:57.63Z" }, + { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030, upload-time = "2024-11-27T22:37:59.344Z" }, + { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898, upload-time = "2024-11-27T22:38:00.429Z" }, + { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894, upload-time = "2024-11-27T22:38:02.094Z" }, + { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319, upload-time = "2024-11-27T22:38:03.206Z" }, + { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273, upload-time = "2024-11-27T22:38:04.217Z" }, + { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310, upload-time = "2024-11-27T22:38:05.908Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309, upload-time = "2024-11-27T22:38:06.812Z" }, + { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762, upload-time = "2024-11-27T22:38:07.731Z" }, + { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453, upload-time = "2024-11-27T22:38:09.384Z" }, + { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486, upload-time = "2024-11-27T22:38:10.329Z" }, + { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349, upload-time = "2024-11-27T22:38:11.443Z" }, + { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159, upload-time = "2024-11-27T22:38:13.099Z" }, + { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243, upload-time = "2024-11-27T22:38:14.766Z" }, + { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645, upload-time = "2024-11-27T22:38:15.843Z" }, + { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584, upload-time = "2024-11-27T22:38:17.645Z" }, + { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875, upload-time = "2024-11-27T22:38:19.159Z" }, + { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418, upload-time = "2024-11-27T22:38:20.064Z" }, + { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708, upload-time = "2024-11-27T22:38:21.659Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582, upload-time = "2024-11-27T22:38:22.693Z" }, + { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543, upload-time = "2024-11-27T22:38:24.367Z" }, + { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691, upload-time = "2024-11-27T22:38:26.081Z" }, + { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170, upload-time = "2024-11-27T22:38:27.921Z" }, + { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530, upload-time = "2024-11-27T22:38:29.591Z" }, + { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666, upload-time = "2024-11-27T22:38:30.639Z" }, + { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954, upload-time = "2024-11-27T22:38:31.702Z" }, + { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724, upload-time = "2024-11-27T22:38:32.837Z" }, + { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383, upload-time = "2024-11-27T22:38:34.455Z" }, + { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload-time = "2024-11-27T22:38:35.385Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/51/89/c72771c81d25d53fe33e3dca61c233b665b2780f21820ba6fd2c6793c12b/tornado-6.5.1.tar.gz", hash = "sha256:84ceece391e8eb9b2b95578db65e920d2a61070260594819589609ba9bc6308c", size = 509934, upload-time = "2025-05-22T18:15:38.788Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/89/f4532dee6843c9e0ebc4e28d4be04c67f54f60813e4bf73d595fe7567452/tornado-6.5.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d50065ba7fd11d3bd41bcad0825227cc9a95154bad83239357094c36708001f7", size = 441948, upload-time = "2025-05-22T18:15:20.862Z" }, + { url = "https://files.pythonhosted.org/packages/15/9a/557406b62cffa395d18772e0cdcf03bed2fff03b374677348eef9f6a3792/tornado-6.5.1-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:9e9ca370f717997cb85606d074b0e5b247282cf5e2e1611568b8821afe0342d6", size = 440112, upload-time = "2025-05-22T18:15:22.591Z" }, + { url = "https://files.pythonhosted.org/packages/55/82/7721b7319013a3cf881f4dffa4f60ceff07b31b394e459984e7a36dc99ec/tornado-6.5.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b77e9dfa7ed69754a54c89d82ef746398be82f749df69c4d3abe75c4d1ff4888", size = 443672, upload-time = "2025-05-22T18:15:24.027Z" }, + { url = "https://files.pythonhosted.org/packages/7d/42/d11c4376e7d101171b94e03cef0cbce43e823ed6567ceda571f54cf6e3ce/tornado-6.5.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:253b76040ee3bab8bcf7ba9feb136436a3787208717a1fb9f2c16b744fba7331", size = 443019, upload-time = "2025-05-22T18:15:25.735Z" }, + { url = "https://files.pythonhosted.org/packages/7d/f7/0c48ba992d875521ac761e6e04b0a1750f8150ae42ea26df1852d6a98942/tornado-6.5.1-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:308473f4cc5a76227157cdf904de33ac268af770b2c5f05ca6c1161d82fdd95e", size = 443252, upload-time = "2025-05-22T18:15:27.499Z" }, + { url = "https://files.pythonhosted.org/packages/89/46/d8d7413d11987e316df4ad42e16023cd62666a3c0dfa1518ffa30b8df06c/tornado-6.5.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:caec6314ce8a81cf69bd89909f4b633b9f523834dc1a352021775d45e51d9401", size = 443930, upload-time = "2025-05-22T18:15:29.299Z" }, + { url = "https://files.pythonhosted.org/packages/78/b2/f8049221c96a06df89bed68260e8ca94beca5ea532ffc63b1175ad31f9cc/tornado-6.5.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:13ce6e3396c24e2808774741331638ee6c2f50b114b97a55c5b442df65fd9692", size = 443351, upload-time = "2025-05-22T18:15:31.038Z" }, + { url = "https://files.pythonhosted.org/packages/76/ff/6a0079e65b326cc222a54720a748e04a4db246870c4da54ece4577bfa702/tornado-6.5.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5cae6145f4cdf5ab24744526cc0f55a17d76f02c98f4cff9daa08ae9a217448a", size = 443328, upload-time = "2025-05-22T18:15:32.426Z" }, + { url = "https://files.pythonhosted.org/packages/49/18/e3f902a1d21f14035b5bc6246a8c0f51e0eef562ace3a2cea403c1fb7021/tornado-6.5.1-cp39-abi3-win32.whl", hash = "sha256:e0a36e1bc684dca10b1aa75a31df8bdfed656831489bc1e6a6ebed05dc1ec365", size = 444396, upload-time = "2025-05-22T18:15:34.205Z" }, + { url = "https://files.pythonhosted.org/packages/7b/09/6526e32bf1049ee7de3bebba81572673b19a2a8541f795d887e92af1a8bc/tornado-6.5.1-cp39-abi3-win_amd64.whl", hash = "sha256:908e7d64567cecd4c2b458075589a775063453aeb1d2a1853eedb806922f568b", size = 444840, upload-time = "2025-05-22T18:15:36.1Z" }, + { url = "https://files.pythonhosted.org/packages/55/a7/535c44c7bea4578e48281d83c615219f3ab19e6abc67625ef637c73987be/tornado-6.5.1-cp39-abi3-win_arm64.whl", hash = "sha256:02420a0eb7bf617257b9935e2b754d1b63897525d8a289c9d65690d580b4dcf7", size = 443596, upload-time = "2025-05-22T18:15:37.433Z" }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + +[[package]] +name = "types-requests" +version = "2.32.0.20250602" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/48/b0/5321e6eeba5d59e4347fcf9bf06a5052f085c3aa0f4876230566d6a4dc97/types_requests-2.32.0.20250602.tar.gz", hash = "sha256:ee603aeefec42051195ae62ca7667cd909a2f8128fdf8aad9e8a5219ecfab3bf", size = 23042, upload-time = "2025-06-02T03:15:02.958Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/18/9b782980e575c6581d5c0c1c99f4c6f89a1d7173dad072ee96b2756c02e6/types_requests-2.32.0.20250602-py3-none-any.whl", hash = "sha256:f4f335f87779b47ce10b8b8597b409130299f6971ead27fead4fe7ba6ea3e726", size = 20638, upload-time = "2025-06-02T03:15:01.959Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d1/bc/51647cd02527e87d05cb083ccc402f93e441606ff1f01739a62c8ad09ba5/typing_extensions-4.14.0.tar.gz", hash = "sha256:8676b788e32f02ab42d9e7c61324048ae4c6d844a399eebace3d4979d75ceef4", size = 107423, upload-time = "2025-06-02T14:52:11.399Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl", hash = "sha256:a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af", size = 43839, upload-time = "2025-06-02T14:52:10.026Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" }, +] + +[[package]] +name = "tzdata" +version = "2025.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/95/32/1a225d6164441be760d75c2c42e2780dc0873fe382da3e98a2e1e48361e5/tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9", size = 196380, upload-time = "2025-03-23T13:54:43.652Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/23/c7abc0ca0a1526a0774eca151daeb8de62ec457e77262b66b359c3c7679e/tzdata-2025.2-py2.py3-none-any.whl", hash = "sha256:1a403fada01ff9221ca8044d701868fa132215d84beb92242d9acd2147f667a8", size = 347839, upload-time = "2025-03-23T13:54:41.845Z" }, +] + +[[package]] +name = "urllib3" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672, upload-time = "2025-04-10T15:23:39.232Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680, upload-time = "2025-04-10T15:23:37.377Z" }, +] + +[[package]] +name = "vcrpy" +version = "5.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and platform_python_implementation == 'PyPy'", + "python_full_version == '3.11.*' and platform_python_implementation == 'PyPy'", + "python_full_version < '3.11' and platform_python_implementation == 'PyPy'", +] +dependencies = [ + { name = "pyyaml", marker = "platform_python_implementation == 'PyPy'" }, + { name = "wrapt", marker = "platform_python_implementation == 'PyPy'" }, + { name = "yarl", marker = "platform_python_implementation == 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a5/ea/a166a3cce4ac5958ba9bbd9768acdb1ba38ae17ff7986da09fa5b9dbc633/vcrpy-5.1.0.tar.gz", hash = "sha256:bbf1532f2618a04f11bce2a99af3a9647a32c880957293ff91e0a5f187b6b3d2", size = 84576, upload-time = "2023-07-31T03:19:32.231Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2a/5b/3f70bcb279ad30026cc4f1df0a0491a0205a24dddd88301f396c485de9e7/vcrpy-5.1.0-py2.py3-none-any.whl", hash = "sha256:605e7b7a63dcd940db1df3ab2697ca7faf0e835c0852882142bafb19649d599e", size = 41969, upload-time = "2023-07-31T03:19:30.128Z" }, +] + +[[package]] +name = "vcrpy" +version = "7.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12' and platform_python_implementation != 'PyPy'", + "python_full_version == '3.11.*' and platform_python_implementation != 'PyPy'", + "python_full_version < '3.11' and platform_python_implementation != 'PyPy'", +] +dependencies = [ + { name = "pyyaml", marker = "platform_python_implementation != 'PyPy'" }, + { name = "urllib3", marker = "platform_python_implementation != 'PyPy'" }, + { name = "wrapt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "yarl", marker = "platform_python_implementation != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/25/d3/856e06184d4572aada1dd559ddec3bedc46df1f2edc5ab2c91121a2cccdb/vcrpy-7.0.0.tar.gz", hash = "sha256:176391ad0425edde1680c5b20738ea3dc7fb942520a48d2993448050986b3a50", size = 85502, upload-time = "2024-12-31T00:07:57.894Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/13/5d/1f15b252890c968d42b348d1e9b0aa12d5bf3e776704178ec37cceccdb63/vcrpy-7.0.0-py2.py3-none-any.whl", hash = "sha256:55791e26c18daa363435054d8b35bd41a4ac441b6676167635d1b37a71dbe124", size = 42321, upload-time = "2024-12-31T00:07:55.277Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6c/63/53559446a878410fc5a5974feb13d31d78d752eb18aeba59c7fef1af7598/wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5", size = 101301, upload-time = "2024-01-06T02:10:57.829Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fd/84/fd2ba7aafacbad3c4201d395674fc6348826569da3c0937e75505ead3528/wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859", size = 34166, upload-time = "2024-01-06T02:10:55.763Z" }, +] + +[[package]] +name = "wrapt" +version = "1.17.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/fc/e91cc220803d7bc4db93fb02facd8461c37364151b8494762cc88b0fbcef/wrapt-1.17.2.tar.gz", hash = "sha256:41388e9d4d1522446fe79d3213196bd9e3b301a336965b9e27ca2788ebd122f3", size = 55531, upload-time = "2025-01-14T10:35:45.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/d1/1daec934997e8b160040c78d7b31789f19b122110a75eca3d4e8da0049e1/wrapt-1.17.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3d57c572081fed831ad2d26fd430d565b76aa277ed1d30ff4d40670b1c0dd984", size = 53307, upload-time = "2025-01-14T10:33:13.616Z" }, + { url = "https://files.pythonhosted.org/packages/1b/7b/13369d42651b809389c1a7153baa01d9700430576c81a2f5c5e460df0ed9/wrapt-1.17.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b5e251054542ae57ac7f3fba5d10bfff615b6c2fb09abeb37d2f1463f841ae22", size = 38486, upload-time = "2025-01-14T10:33:15.947Z" }, + { url = "https://files.pythonhosted.org/packages/62/bf/e0105016f907c30b4bd9e377867c48c34dc9c6c0c104556c9c9126bd89ed/wrapt-1.17.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:80dd7db6a7cb57ffbc279c4394246414ec99537ae81ffd702443335a61dbf3a7", size = 38777, upload-time = "2025-01-14T10:33:17.462Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/0f6e0679845cbf8b165e027d43402a55494779295c4b08414097b258ac87/wrapt-1.17.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a6e821770cf99cc586d33833b2ff32faebdbe886bd6322395606cf55153246c", size = 83314, upload-time = "2025-01-14T10:33:21.282Z" }, + { url = "https://files.pythonhosted.org/packages/0f/77/0576d841bf84af8579124a93d216f55d6f74374e4445264cb378a6ed33eb/wrapt-1.17.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b60fb58b90c6d63779cb0c0c54eeb38941bae3ecf7a73c764c52c88c2dcb9d72", size = 74947, upload-time = "2025-01-14T10:33:24.414Z" }, + { url = "https://files.pythonhosted.org/packages/90/ec/00759565518f268ed707dcc40f7eeec38637d46b098a1f5143bff488fe97/wrapt-1.17.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b870b5df5b71d8c3359d21be8f0d6c485fa0ebdb6477dda51a1ea54a9b558061", size = 82778, upload-time = "2025-01-14T10:33:26.152Z" }, + { url = "https://files.pythonhosted.org/packages/f8/5a/7cffd26b1c607b0b0c8a9ca9d75757ad7620c9c0a9b4a25d3f8a1480fafc/wrapt-1.17.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4011d137b9955791f9084749cba9a367c68d50ab8d11d64c50ba1688c9b457f2", size = 81716, upload-time = "2025-01-14T10:33:27.372Z" }, + { url = "https://files.pythonhosted.org/packages/7e/09/dccf68fa98e862df7e6a60a61d43d644b7d095a5fc36dbb591bbd4a1c7b2/wrapt-1.17.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:1473400e5b2733e58b396a04eb7f35f541e1fb976d0c0724d0223dd607e0f74c", size = 74548, upload-time = "2025-01-14T10:33:28.52Z" }, + { url = "https://files.pythonhosted.org/packages/b7/8e/067021fa3c8814952c5e228d916963c1115b983e21393289de15128e867e/wrapt-1.17.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3cedbfa9c940fdad3e6e941db7138e26ce8aad38ab5fe9dcfadfed9db7a54e62", size = 81334, upload-time = "2025-01-14T10:33:29.643Z" }, + { url = "https://files.pythonhosted.org/packages/4b/0d/9d4b5219ae4393f718699ca1c05f5ebc0c40d076f7e65fd48f5f693294fb/wrapt-1.17.2-cp310-cp310-win32.whl", hash = "sha256:582530701bff1dec6779efa00c516496968edd851fba224fbd86e46cc6b73563", size = 36427, upload-time = "2025-01-14T10:33:30.832Z" }, + { url = "https://files.pythonhosted.org/packages/72/6a/c5a83e8f61aec1e1aeef939807602fb880e5872371e95df2137142f5c58e/wrapt-1.17.2-cp310-cp310-win_amd64.whl", hash = "sha256:58705da316756681ad3c9c73fd15499aa4d8c69f9fd38dc8a35e06c12468582f", size = 38774, upload-time = "2025-01-14T10:33:32.897Z" }, + { url = "https://files.pythonhosted.org/packages/cd/f7/a2aab2cbc7a665efab072344a8949a71081eed1d2f451f7f7d2b966594a2/wrapt-1.17.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ff04ef6eec3eee8a5efef2401495967a916feaa353643defcc03fc74fe213b58", size = 53308, upload-time = "2025-01-14T10:33:33.992Z" }, + { url = "https://files.pythonhosted.org/packages/50/ff/149aba8365fdacef52b31a258c4dc1c57c79759c335eff0b3316a2664a64/wrapt-1.17.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4db983e7bca53819efdbd64590ee96c9213894272c776966ca6306b73e4affda", size = 38488, upload-time = "2025-01-14T10:33:35.264Z" }, + { url = "https://files.pythonhosted.org/packages/65/46/5a917ce85b5c3b490d35c02bf71aedaa9f2f63f2d15d9949cc4ba56e8ba9/wrapt-1.17.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9abc77a4ce4c6f2a3168ff34b1da9b0f311a8f1cfd694ec96b0603dff1c79438", size = 38776, upload-time = "2025-01-14T10:33:38.28Z" }, + { url = "https://files.pythonhosted.org/packages/ca/74/336c918d2915a4943501c77566db41d1bd6e9f4dbc317f356b9a244dfe83/wrapt-1.17.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b929ac182f5ace000d459c59c2c9c33047e20e935f8e39371fa6e3b85d56f4a", size = 83776, upload-time = "2025-01-14T10:33:40.678Z" }, + { url = "https://files.pythonhosted.org/packages/09/99/c0c844a5ccde0fe5761d4305485297f91d67cf2a1a824c5f282e661ec7ff/wrapt-1.17.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f09b286faeff3c750a879d336fb6d8713206fc97af3adc14def0cdd349df6000", size = 75420, upload-time = "2025-01-14T10:33:41.868Z" }, + { url = "https://files.pythonhosted.org/packages/b4/b0/9fc566b0fe08b282c850063591a756057c3247b2362b9286429ec5bf1721/wrapt-1.17.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1a7ed2d9d039bd41e889f6fb9364554052ca21ce823580f6a07c4ec245c1f5d6", size = 83199, upload-time = "2025-01-14T10:33:43.598Z" }, + { url = "https://files.pythonhosted.org/packages/9d/4b/71996e62d543b0a0bd95dda485219856def3347e3e9380cc0d6cf10cfb2f/wrapt-1.17.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:129a150f5c445165ff941fc02ee27df65940fcb8a22a61828b1853c98763a64b", size = 82307, upload-time = "2025-01-14T10:33:48.499Z" }, + { url = "https://files.pythonhosted.org/packages/39/35/0282c0d8789c0dc9bcc738911776c762a701f95cfe113fb8f0b40e45c2b9/wrapt-1.17.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1fb5699e4464afe5c7e65fa51d4f99e0b2eadcc176e4aa33600a3df7801d6662", size = 75025, upload-time = "2025-01-14T10:33:51.191Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6d/90c9fd2c3c6fee181feecb620d95105370198b6b98a0770cba090441a828/wrapt-1.17.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9a2bce789a5ea90e51a02dfcc39e31b7f1e662bc3317979aa7e5538e3a034f72", size = 81879, upload-time = "2025-01-14T10:33:52.328Z" }, + { url = "https://files.pythonhosted.org/packages/8f/fa/9fb6e594f2ce03ef03eddbdb5f4f90acb1452221a5351116c7c4708ac865/wrapt-1.17.2-cp311-cp311-win32.whl", hash = "sha256:4afd5814270fdf6380616b321fd31435a462019d834f83c8611a0ce7484c7317", size = 36419, upload-time = "2025-01-14T10:33:53.551Z" }, + { url = "https://files.pythonhosted.org/packages/47/f8/fb1773491a253cbc123c5d5dc15c86041f746ed30416535f2a8df1f4a392/wrapt-1.17.2-cp311-cp311-win_amd64.whl", hash = "sha256:acc130bc0375999da18e3d19e5a86403667ac0c4042a094fefb7eec8ebac7cf3", size = 38773, upload-time = "2025-01-14T10:33:56.323Z" }, + { url = "https://files.pythonhosted.org/packages/a1/bd/ab55f849fd1f9a58ed7ea47f5559ff09741b25f00c191231f9f059c83949/wrapt-1.17.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d5e2439eecc762cd85e7bd37161d4714aa03a33c5ba884e26c81559817ca0925", size = 53799, upload-time = "2025-01-14T10:33:57.4Z" }, + { url = "https://files.pythonhosted.org/packages/53/18/75ddc64c3f63988f5a1d7e10fb204ffe5762bc663f8023f18ecaf31a332e/wrapt-1.17.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fc7cb4c1c744f8c05cd5f9438a3caa6ab94ce8344e952d7c45a8ed59dd88392", size = 38821, upload-time = "2025-01-14T10:33:59.334Z" }, + { url = "https://files.pythonhosted.org/packages/48/2a/97928387d6ed1c1ebbfd4efc4133a0633546bec8481a2dd5ec961313a1c7/wrapt-1.17.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8fdbdb757d5390f7c675e558fd3186d590973244fab0c5fe63d373ade3e99d40", size = 38919, upload-time = "2025-01-14T10:34:04.093Z" }, + { url = "https://files.pythonhosted.org/packages/73/54/3bfe5a1febbbccb7a2f77de47b989c0b85ed3a6a41614b104204a788c20e/wrapt-1.17.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5bb1d0dbf99411f3d871deb6faa9aabb9d4e744d67dcaaa05399af89d847a91d", size = 88721, upload-time = "2025-01-14T10:34:07.163Z" }, + { url = "https://files.pythonhosted.org/packages/25/cb/7262bc1b0300b4b64af50c2720ef958c2c1917525238d661c3e9a2b71b7b/wrapt-1.17.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d18a4865f46b8579d44e4fe1e2bcbc6472ad83d98e22a26c963d46e4c125ef0b", size = 80899, upload-time = "2025-01-14T10:34:09.82Z" }, + { url = "https://files.pythonhosted.org/packages/2a/5a/04cde32b07a7431d4ed0553a76fdb7a61270e78c5fd5a603e190ac389f14/wrapt-1.17.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc570b5f14a79734437cb7b0500376b6b791153314986074486e0b0fa8d71d98", size = 89222, upload-time = "2025-01-14T10:34:11.258Z" }, + { url = "https://files.pythonhosted.org/packages/09/28/2e45a4f4771fcfb109e244d5dbe54259e970362a311b67a965555ba65026/wrapt-1.17.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6d9187b01bebc3875bac9b087948a2bccefe464a7d8f627cf6e48b1bbae30f82", size = 86707, upload-time = "2025-01-14T10:34:12.49Z" }, + { url = "https://files.pythonhosted.org/packages/c6/d2/dcb56bf5f32fcd4bd9aacc77b50a539abdd5b6536872413fd3f428b21bed/wrapt-1.17.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9e8659775f1adf02eb1e6f109751268e493c73716ca5761f8acb695e52a756ae", size = 79685, upload-time = "2025-01-14T10:34:15.043Z" }, + { url = "https://files.pythonhosted.org/packages/80/4e/eb8b353e36711347893f502ce91c770b0b0929f8f0bed2670a6856e667a9/wrapt-1.17.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8b2816ebef96d83657b56306152a93909a83f23994f4b30ad4573b00bd11bb9", size = 87567, upload-time = "2025-01-14T10:34:16.563Z" }, + { url = "https://files.pythonhosted.org/packages/17/27/4fe749a54e7fae6e7146f1c7d914d28ef599dacd4416566c055564080fe2/wrapt-1.17.2-cp312-cp312-win32.whl", hash = "sha256:468090021f391fe0056ad3e807e3d9034e0fd01adcd3bdfba977b6fdf4213ea9", size = 36672, upload-time = "2025-01-14T10:34:17.727Z" }, + { url = "https://files.pythonhosted.org/packages/15/06/1dbf478ea45c03e78a6a8c4be4fdc3c3bddea5c8de8a93bc971415e47f0f/wrapt-1.17.2-cp312-cp312-win_amd64.whl", hash = "sha256:ec89ed91f2fa8e3f52ae53cd3cf640d6feff92ba90d62236a81e4e563ac0e991", size = 38865, upload-time = "2025-01-14T10:34:19.577Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b9/0ffd557a92f3b11d4c5d5e0c5e4ad057bd9eb8586615cdaf901409920b14/wrapt-1.17.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6ed6ffac43aecfe6d86ec5b74b06a5be33d5bb9243d055141e8cabb12aa08125", size = 53800, upload-time = "2025-01-14T10:34:21.571Z" }, + { url = "https://files.pythonhosted.org/packages/c0/ef/8be90a0b7e73c32e550c73cfb2fa09db62234227ece47b0e80a05073b375/wrapt-1.17.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:35621ae4c00e056adb0009f8e86e28eb4a41a4bfa8f9bfa9fca7d343fe94f998", size = 38824, upload-time = "2025-01-14T10:34:22.999Z" }, + { url = "https://files.pythonhosted.org/packages/36/89/0aae34c10fe524cce30fe5fc433210376bce94cf74d05b0d68344c8ba46e/wrapt-1.17.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a604bf7a053f8362d27eb9fefd2097f82600b856d5abe996d623babd067b1ab5", size = 38920, upload-time = "2025-01-14T10:34:25.386Z" }, + { url = "https://files.pythonhosted.org/packages/3b/24/11c4510de906d77e0cfb5197f1b1445d4fec42c9a39ea853d482698ac681/wrapt-1.17.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cbabee4f083b6b4cd282f5b817a867cf0b1028c54d445b7ec7cfe6505057cf8", size = 88690, upload-time = "2025-01-14T10:34:28.058Z" }, + { url = "https://files.pythonhosted.org/packages/71/d7/cfcf842291267bf455b3e266c0c29dcb675b5540ee8b50ba1699abf3af45/wrapt-1.17.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:49703ce2ddc220df165bd2962f8e03b84c89fee2d65e1c24a7defff6f988f4d6", size = 80861, upload-time = "2025-01-14T10:34:29.167Z" }, + { url = "https://files.pythonhosted.org/packages/d5/66/5d973e9f3e7370fd686fb47a9af3319418ed925c27d72ce16b791231576d/wrapt-1.17.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8112e52c5822fc4253f3901b676c55ddf288614dc7011634e2719718eaa187dc", size = 89174, upload-time = "2025-01-14T10:34:31.702Z" }, + { url = "https://files.pythonhosted.org/packages/a7/d3/8e17bb70f6ae25dabc1aaf990f86824e4fd98ee9cadf197054e068500d27/wrapt-1.17.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fee687dce376205d9a494e9c121e27183b2a3df18037f89d69bd7b35bcf59e2", size = 86721, upload-time = "2025-01-14T10:34:32.91Z" }, + { url = "https://files.pythonhosted.org/packages/6f/54/f170dfb278fe1c30d0ff864513cff526d624ab8de3254b20abb9cffedc24/wrapt-1.17.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:18983c537e04d11cf027fbb60a1e8dfd5190e2b60cc27bc0808e653e7b218d1b", size = 79763, upload-time = "2025-01-14T10:34:34.903Z" }, + { url = "https://files.pythonhosted.org/packages/4a/98/de07243751f1c4a9b15c76019250210dd3486ce098c3d80d5f729cba029c/wrapt-1.17.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:703919b1633412ab54bcf920ab388735832fdcb9f9a00ae49387f0fe67dad504", size = 87585, upload-time = "2025-01-14T10:34:36.13Z" }, + { url = "https://files.pythonhosted.org/packages/f9/f0/13925f4bd6548013038cdeb11ee2cbd4e37c30f8bfd5db9e5a2a370d6e20/wrapt-1.17.2-cp313-cp313-win32.whl", hash = "sha256:abbb9e76177c35d4e8568e58650aa6926040d6a9f6f03435b7a522bf1c487f9a", size = 36676, upload-time = "2025-01-14T10:34:37.962Z" }, + { url = "https://files.pythonhosted.org/packages/bf/ae/743f16ef8c2e3628df3ddfd652b7d4c555d12c84b53f3d8218498f4ade9b/wrapt-1.17.2-cp313-cp313-win_amd64.whl", hash = "sha256:69606d7bb691b50a4240ce6b22ebb319c1cfb164e5f6569835058196e0f3a845", size = 38871, upload-time = "2025-01-14T10:34:39.13Z" }, + { url = "https://files.pythonhosted.org/packages/3d/bc/30f903f891a82d402ffb5fda27ec1d621cc97cb74c16fea0b6141f1d4e87/wrapt-1.17.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:4a721d3c943dae44f8e243b380cb645a709ba5bd35d3ad27bc2ed947e9c68192", size = 56312, upload-time = "2025-01-14T10:34:40.604Z" }, + { url = "https://files.pythonhosted.org/packages/8a/04/c97273eb491b5f1c918857cd26f314b74fc9b29224521f5b83f872253725/wrapt-1.17.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:766d8bbefcb9e00c3ac3b000d9acc51f1b399513f44d77dfe0eb026ad7c9a19b", size = 40062, upload-time = "2025-01-14T10:34:45.011Z" }, + { url = "https://files.pythonhosted.org/packages/4e/ca/3b7afa1eae3a9e7fefe499db9b96813f41828b9fdb016ee836c4c379dadb/wrapt-1.17.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e496a8ce2c256da1eb98bd15803a79bee00fc351f5dfb9ea82594a3f058309e0", size = 40155, upload-time = "2025-01-14T10:34:47.25Z" }, + { url = "https://files.pythonhosted.org/packages/89/be/7c1baed43290775cb9030c774bc53c860db140397047cc49aedaf0a15477/wrapt-1.17.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40d615e4fe22f4ad3528448c193b218e077656ca9ccb22ce2cb20db730f8d306", size = 113471, upload-time = "2025-01-14T10:34:50.934Z" }, + { url = "https://files.pythonhosted.org/packages/32/98/4ed894cf012b6d6aae5f5cc974006bdeb92f0241775addad3f8cd6ab71c8/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a5aaeff38654462bc4b09023918b7f21790efb807f54c000a39d41d69cf552cb", size = 101208, upload-time = "2025-01-14T10:34:52.297Z" }, + { url = "https://files.pythonhosted.org/packages/ea/fd/0c30f2301ca94e655e5e057012e83284ce8c545df7661a78d8bfca2fac7a/wrapt-1.17.2-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a7d15bbd2bc99e92e39f49a04653062ee6085c0e18b3b7512a4f2fe91f2d681", size = 109339, upload-time = "2025-01-14T10:34:53.489Z" }, + { url = "https://files.pythonhosted.org/packages/75/56/05d000de894c4cfcb84bcd6b1df6214297b8089a7bd324c21a4765e49b14/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e3890b508a23299083e065f435a492b5435eba6e304a7114d2f919d400888cc6", size = 110232, upload-time = "2025-01-14T10:34:55.327Z" }, + { url = "https://files.pythonhosted.org/packages/53/f8/c3f6b2cf9b9277fb0813418e1503e68414cd036b3b099c823379c9575e6d/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:8c8b293cd65ad716d13d8dd3624e42e5a19cc2a2f1acc74b30c2c13f15cb61a6", size = 100476, upload-time = "2025-01-14T10:34:58.055Z" }, + { url = "https://files.pythonhosted.org/packages/a7/b1/0bb11e29aa5139d90b770ebbfa167267b1fc548d2302c30c8f7572851738/wrapt-1.17.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c82b8785d98cdd9fed4cac84d765d234ed3251bd6afe34cb7ac523cb93e8b4f", size = 106377, upload-time = "2025-01-14T10:34:59.3Z" }, + { url = "https://files.pythonhosted.org/packages/6a/e1/0122853035b40b3f333bbb25f1939fc1045e21dd518f7f0922b60c156f7c/wrapt-1.17.2-cp313-cp313t-win32.whl", hash = "sha256:13e6afb7fe71fe7485a4550a8844cc9ffbe263c0f1a1eea569bc7091d4898555", size = 37986, upload-time = "2025-01-14T10:35:00.498Z" }, + { url = "https://files.pythonhosted.org/packages/09/5e/1655cf481e079c1f22d0cabdd4e51733679932718dc23bf2db175f329b76/wrapt-1.17.2-cp313-cp313t-win_amd64.whl", hash = "sha256:eaf675418ed6b3b31c7a989fd007fa7c3be66ce14e5c3b27336383604c9da85c", size = 40750, upload-time = "2025-01-14T10:35:03.378Z" }, + { url = "https://files.pythonhosted.org/packages/2d/82/f56956041adef78f849db6b289b282e72b55ab8045a75abad81898c28d19/wrapt-1.17.2-py3-none-any.whl", hash = "sha256:b18f2d1533a71f069c7f82d524a52599053d4c7166e9dd374ae2136b7f40f7c8", size = 23594, upload-time = "2025-01-14T10:35:44.018Z" }, +] + +[[package]] +name = "yarl" +version = "1.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/62/51/c0edba5219027f6eab262e139f73e2417b0f4efffa23bf562f6e18f76ca5/yarl-1.20.0.tar.gz", hash = "sha256:686d51e51ee5dfe62dec86e4866ee0e9ed66df700d55c828a615640adc885307", size = 185258, upload-time = "2025-04-17T00:45:14.661Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/ab/66082639f99d7ef647a86b2ff4ca20f8ae13bd68a6237e6e166b8eb92edf/yarl-1.20.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f1f6670b9ae3daedb325fa55fbe31c22c8228f6e0b513772c2e1c623caa6ab22", size = 145054, upload-time = "2025-04-17T00:41:27.071Z" }, + { url = "https://files.pythonhosted.org/packages/3d/c2/4e78185c453c3ca02bd11c7907394d0410d26215f9e4b7378648b3522a30/yarl-1.20.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:85a231fa250dfa3308f3c7896cc007a47bc76e9e8e8595c20b7426cac4884c62", size = 96811, upload-time = "2025-04-17T00:41:30.235Z" }, + { url = "https://files.pythonhosted.org/packages/c7/45/91e31dccdcf5b7232dcace78bd51a1bb2d7b4b96c65eece0078b620587d1/yarl-1.20.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1a06701b647c9939d7019acdfa7ebbfbb78ba6aa05985bb195ad716ea759a569", size = 94566, upload-time = "2025-04-17T00:41:32.023Z" }, + { url = "https://files.pythonhosted.org/packages/c8/21/e0aa650bcee881fb804331faa2c0f9a5d6be7609970b2b6e3cdd414e174b/yarl-1.20.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7595498d085becc8fb9203aa314b136ab0516c7abd97e7d74f7bb4eb95042abe", size = 327297, upload-time = "2025-04-17T00:41:34.03Z" }, + { url = "https://files.pythonhosted.org/packages/1a/a4/58f10870f5c17595c5a37da4c6a0b321589b7d7976e10570088d445d0f47/yarl-1.20.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:af5607159085dcdb055d5678fc2d34949bd75ae6ea6b4381e784bbab1c3aa195", size = 323578, upload-time = "2025-04-17T00:41:36.492Z" }, + { url = "https://files.pythonhosted.org/packages/07/df/2506b1382cc0c4bb0d22a535dc3e7ccd53da9a59b411079013a7904ac35c/yarl-1.20.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:95b50910e496567434cb77a577493c26bce0f31c8a305135f3bda6a2483b8e10", size = 343212, upload-time = "2025-04-17T00:41:38.396Z" }, + { url = "https://files.pythonhosted.org/packages/ba/4a/d1c901d0e2158ad06bb0b9a92473e32d992f98673b93c8a06293e091bab0/yarl-1.20.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b594113a301ad537766b4e16a5a6750fcbb1497dcc1bc8a4daae889e6402a634", size = 337956, upload-time = "2025-04-17T00:41:40.519Z" }, + { url = "https://files.pythonhosted.org/packages/8b/fd/10fcf7d86f49b1a11096d6846257485ef32e3d3d322e8a7fdea5b127880c/yarl-1.20.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:083ce0393ea173cd37834eb84df15b6853b555d20c52703e21fbababa8c129d2", size = 333889, upload-time = "2025-04-17T00:41:42.437Z" }, + { url = "https://files.pythonhosted.org/packages/e2/cd/bae926a25154ba31c5fd15f2aa6e50a545c840e08d85e2e2e0807197946b/yarl-1.20.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f1a350a652bbbe12f666109fbddfdf049b3ff43696d18c9ab1531fbba1c977a", size = 322282, upload-time = "2025-04-17T00:41:44.641Z" }, + { url = "https://files.pythonhosted.org/packages/e2/c6/c3ac3597dfde746c63c637c5422cf3954ebf622a8de7f09892d20a68900d/yarl-1.20.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fb0caeac4a164aadce342f1597297ec0ce261ec4532bbc5a9ca8da5622f53867", size = 336270, upload-time = "2025-04-17T00:41:46.812Z" }, + { url = "https://files.pythonhosted.org/packages/dd/42/417fd7b8da5846def29712370ea8916a4be2553de42a2c969815153717be/yarl-1.20.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d88cc43e923f324203f6ec14434fa33b85c06d18d59c167a0637164863b8e995", size = 335500, upload-time = "2025-04-17T00:41:48.896Z" }, + { url = "https://files.pythonhosted.org/packages/37/aa/c2339683f8f05f4be16831b6ad58d04406cf1c7730e48a12f755da9f5ac5/yarl-1.20.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e52d6ed9ea8fd3abf4031325dc714aed5afcbfa19ee4a89898d663c9976eb487", size = 339672, upload-time = "2025-04-17T00:41:50.965Z" }, + { url = "https://files.pythonhosted.org/packages/be/12/ab6c4df95f00d7bc9502bf07a92d5354f11d9d3cb855222a6a8d2bd6e8da/yarl-1.20.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ce360ae48a5e9961d0c730cf891d40698a82804e85f6e74658fb175207a77cb2", size = 351840, upload-time = "2025-04-17T00:41:53.074Z" }, + { url = "https://files.pythonhosted.org/packages/83/3c/08d58c51bbd3899be3e7e83cd7a691fdcf3b9f78b8699d663ecc2c090ab7/yarl-1.20.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:06d06c9d5b5bc3eb56542ceeba6658d31f54cf401e8468512447834856fb0e61", size = 359550, upload-time = "2025-04-17T00:41:55.517Z" }, + { url = "https://files.pythonhosted.org/packages/8a/15/de7906c506f85fb476f0edac4bd74569f49e5ffdcf98e246a0313bf593b9/yarl-1.20.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c27d98f4e5c4060582f44e58309c1e55134880558f1add7a87c1bc36ecfade19", size = 351108, upload-time = "2025-04-17T00:41:57.582Z" }, + { url = "https://files.pythonhosted.org/packages/25/04/c6754f5ae2cdf057ac094ac01137c17875b629b1c29ed75354626a755375/yarl-1.20.0-cp310-cp310-win32.whl", hash = "sha256:f4d3fa9b9f013f7050326e165c3279e22850d02ae544ace285674cb6174b5d6d", size = 86733, upload-time = "2025-04-17T00:41:59.757Z" }, + { url = "https://files.pythonhosted.org/packages/db/1f/5c1952f3d983ac3f5fb079b5b13b62728f8a73fd27d03e1cef7e476addff/yarl-1.20.0-cp310-cp310-win_amd64.whl", hash = "sha256:bc906b636239631d42eb8a07df8359905da02704a868983265603887ed68c076", size = 92916, upload-time = "2025-04-17T00:42:02.177Z" }, + { url = "https://files.pythonhosted.org/packages/60/82/a59d8e21b20ffc836775fa7daedac51d16bb8f3010c4fcb495c4496aa922/yarl-1.20.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fdb5204d17cb32b2de2d1e21c7461cabfacf17f3645e4b9039f210c5d3378bf3", size = 145178, upload-time = "2025-04-17T00:42:04.511Z" }, + { url = "https://files.pythonhosted.org/packages/ba/81/315a3f6f95947cfbf37c92d6fbce42a1a6207b6c38e8c2b452499ec7d449/yarl-1.20.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:eaddd7804d8e77d67c28d154ae5fab203163bd0998769569861258e525039d2a", size = 96859, upload-time = "2025-04-17T00:42:06.43Z" }, + { url = "https://files.pythonhosted.org/packages/ad/17/9b64e575583158551b72272a1023cdbd65af54fe13421d856b2850a6ddb7/yarl-1.20.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:634b7ba6b4a85cf67e9df7c13a7fb2e44fa37b5d34501038d174a63eaac25ee2", size = 94647, upload-time = "2025-04-17T00:42:07.976Z" }, + { url = "https://files.pythonhosted.org/packages/2c/29/8f291e7922a58a21349683f6120a85701aeefaa02e9f7c8a2dc24fe3f431/yarl-1.20.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d409e321e4addf7d97ee84162538c7258e53792eb7c6defd0c33647d754172e", size = 355788, upload-time = "2025-04-17T00:42:09.902Z" }, + { url = "https://files.pythonhosted.org/packages/26/6d/b4892c80b805c42c228c6d11e03cafabf81662d371b0853e7f0f513837d5/yarl-1.20.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ea52f7328a36960ba3231c6677380fa67811b414798a6e071c7085c57b6d20a9", size = 344613, upload-time = "2025-04-17T00:42:11.768Z" }, + { url = "https://files.pythonhosted.org/packages/d7/0e/517aa28d3f848589bae9593717b063a544b86ba0a807d943c70f48fcf3bb/yarl-1.20.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c8703517b924463994c344dcdf99a2d5ce9eca2b6882bb640aa555fb5efc706a", size = 370953, upload-time = "2025-04-17T00:42:13.983Z" }, + { url = "https://files.pythonhosted.org/packages/5f/9b/5bd09d2f1ad6e6f7c2beae9e50db78edd2cca4d194d227b958955573e240/yarl-1.20.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:077989b09ffd2f48fb2d8f6a86c5fef02f63ffe6b1dd4824c76de7bb01e4f2e2", size = 369204, upload-time = "2025-04-17T00:42:16.386Z" }, + { url = "https://files.pythonhosted.org/packages/9c/85/d793a703cf4bd0d4cd04e4b13cc3d44149470f790230430331a0c1f52df5/yarl-1.20.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0acfaf1da020253f3533526e8b7dd212838fdc4109959a2c53cafc6db611bff2", size = 358108, upload-time = "2025-04-17T00:42:18.622Z" }, + { url = "https://files.pythonhosted.org/packages/6f/54/b6c71e13549c1f6048fbc14ce8d930ac5fb8bafe4f1a252e621a24f3f1f9/yarl-1.20.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b4230ac0b97ec5eeb91d96b324d66060a43fd0d2a9b603e3327ed65f084e41f8", size = 346610, upload-time = "2025-04-17T00:42:20.9Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1a/d6087d58bdd0d8a2a37bbcdffac9d9721af6ebe50d85304d9f9b57dfd862/yarl-1.20.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a6a1e6ae21cdd84011c24c78d7a126425148b24d437b5702328e4ba640a8902", size = 365378, upload-time = "2025-04-17T00:42:22.926Z" }, + { url = "https://files.pythonhosted.org/packages/02/84/e25ddff4cbc001dbc4af76f8d41a3e23818212dd1f0a52044cbc60568872/yarl-1.20.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:86de313371ec04dd2531f30bc41a5a1a96f25a02823558ee0f2af0beaa7ca791", size = 356919, upload-time = "2025-04-17T00:42:25.145Z" }, + { url = "https://files.pythonhosted.org/packages/04/76/898ae362353bf8f64636495d222c8014c8e5267df39b1a9fe1e1572fb7d0/yarl-1.20.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:dd59c9dd58ae16eaa0f48c3d0cbe6be8ab4dc7247c3ff7db678edecbaf59327f", size = 364248, upload-time = "2025-04-17T00:42:27.475Z" }, + { url = "https://files.pythonhosted.org/packages/1b/b0/9d9198d83a622f1c40fdbf7bd13b224a6979f2e1fc2cf50bfb1d8773c495/yarl-1.20.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a0bc5e05f457b7c1994cc29e83b58f540b76234ba6b9648a4971ddc7f6aa52da", size = 378418, upload-time = "2025-04-17T00:42:29.333Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ce/1f50c1cc594cf5d3f5bf4a9b616fca68680deaec8ad349d928445ac52eb8/yarl-1.20.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c9471ca18e6aeb0e03276b5e9b27b14a54c052d370a9c0c04a68cefbd1455eb4", size = 383850, upload-time = "2025-04-17T00:42:31.668Z" }, + { url = "https://files.pythonhosted.org/packages/89/1e/a59253a87b35bfec1a25bb5801fb69943330b67cfd266278eb07e0609012/yarl-1.20.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:40ed574b4df723583a26c04b298b283ff171bcc387bc34c2683235e2487a65a5", size = 381218, upload-time = "2025-04-17T00:42:33.523Z" }, + { url = "https://files.pythonhosted.org/packages/85/b0/26f87df2b3044b0ef1a7cf66d321102bdca091db64c5ae853fcb2171c031/yarl-1.20.0-cp311-cp311-win32.whl", hash = "sha256:db243357c6c2bf3cd7e17080034ade668d54ce304d820c2a58514a4e51d0cfd6", size = 86606, upload-time = "2025-04-17T00:42:35.873Z" }, + { url = "https://files.pythonhosted.org/packages/33/46/ca335c2e1f90446a77640a45eeb1cd8f6934f2c6e4df7db0f0f36ef9f025/yarl-1.20.0-cp311-cp311-win_amd64.whl", hash = "sha256:8c12cd754d9dbd14204c328915e23b0c361b88f3cffd124129955e60a4fbfcfb", size = 93374, upload-time = "2025-04-17T00:42:37.586Z" }, + { url = "https://files.pythonhosted.org/packages/c3/e8/3efdcb83073df978bb5b1a9cc0360ce596680e6c3fac01f2a994ccbb8939/yarl-1.20.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e06b9f6cdd772f9b665e5ba8161968e11e403774114420737f7884b5bd7bdf6f", size = 147089, upload-time = "2025-04-17T00:42:39.602Z" }, + { url = "https://files.pythonhosted.org/packages/60/c3/9e776e98ea350f76f94dd80b408eaa54e5092643dbf65fd9babcffb60509/yarl-1.20.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b9ae2fbe54d859b3ade40290f60fe40e7f969d83d482e84d2c31b9bff03e359e", size = 97706, upload-time = "2025-04-17T00:42:41.469Z" }, + { url = "https://files.pythonhosted.org/packages/0c/5b/45cdfb64a3b855ce074ae607b9fc40bc82e7613b94e7612b030255c93a09/yarl-1.20.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6d12b8945250d80c67688602c891237994d203d42427cb14e36d1a732eda480e", size = 95719, upload-time = "2025-04-17T00:42:43.666Z" }, + { url = "https://files.pythonhosted.org/packages/2d/4e/929633b249611eeed04e2f861a14ed001acca3ef9ec2a984a757b1515889/yarl-1.20.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:087e9731884621b162a3e06dc0d2d626e1542a617f65ba7cc7aeab279d55ad33", size = 343972, upload-time = "2025-04-17T00:42:45.391Z" }, + { url = "https://files.pythonhosted.org/packages/49/fd/047535d326c913f1a90407a3baf7ff535b10098611eaef2c527e32e81ca1/yarl-1.20.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:69df35468b66c1a6e6556248e6443ef0ec5f11a7a4428cf1f6281f1879220f58", size = 339639, upload-time = "2025-04-17T00:42:47.552Z" }, + { url = "https://files.pythonhosted.org/packages/48/2f/11566f1176a78f4bafb0937c0072410b1b0d3640b297944a6a7a556e1d0b/yarl-1.20.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3b2992fe29002fd0d4cbaea9428b09af9b8686a9024c840b8a2b8f4ea4abc16f", size = 353745, upload-time = "2025-04-17T00:42:49.406Z" }, + { url = "https://files.pythonhosted.org/packages/26/17/07dfcf034d6ae8837b33988be66045dd52f878dfb1c4e8f80a7343f677be/yarl-1.20.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4c903e0b42aab48abfbac668b5a9d7b6938e721a6341751331bcd7553de2dcae", size = 354178, upload-time = "2025-04-17T00:42:51.588Z" }, + { url = "https://files.pythonhosted.org/packages/15/45/212604d3142d84b4065d5f8cab6582ed3d78e4cc250568ef2a36fe1cf0a5/yarl-1.20.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf099e2432131093cc611623e0b0bcc399b8cddd9a91eded8bfb50402ec35018", size = 349219, upload-time = "2025-04-17T00:42:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e0/a10b30f294111c5f1c682461e9459935c17d467a760c21e1f7db400ff499/yarl-1.20.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8a7f62f5dc70a6c763bec9ebf922be52aa22863d9496a9a30124d65b489ea672", size = 337266, upload-time = "2025-04-17T00:42:55.49Z" }, + { url = "https://files.pythonhosted.org/packages/33/a6/6efa1d85a675d25a46a167f9f3e80104cde317dfdf7f53f112ae6b16a60a/yarl-1.20.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:54ac15a8b60382b2bcefd9a289ee26dc0920cf59b05368c9b2b72450751c6eb8", size = 360873, upload-time = "2025-04-17T00:42:57.895Z" }, + { url = "https://files.pythonhosted.org/packages/77/67/c8ab718cb98dfa2ae9ba0f97bf3cbb7d45d37f13fe1fbad25ac92940954e/yarl-1.20.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:25b3bc0763a7aca16a0f1b5e8ef0f23829df11fb539a1b70476dcab28bd83da7", size = 360524, upload-time = "2025-04-17T00:43:00.094Z" }, + { url = "https://files.pythonhosted.org/packages/bd/e8/c3f18660cea1bc73d9f8a2b3ef423def8dadbbae6c4afabdb920b73e0ead/yarl-1.20.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b2586e36dc070fc8fad6270f93242124df68b379c3a251af534030a4a33ef594", size = 365370, upload-time = "2025-04-17T00:43:02.242Z" }, + { url = "https://files.pythonhosted.org/packages/c9/99/33f3b97b065e62ff2d52817155a89cfa030a1a9b43fee7843ef560ad9603/yarl-1.20.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:866349da9d8c5290cfefb7fcc47721e94de3f315433613e01b435473be63daa6", size = 373297, upload-time = "2025-04-17T00:43:04.189Z" }, + { url = "https://files.pythonhosted.org/packages/3d/89/7519e79e264a5f08653d2446b26d4724b01198a93a74d2e259291d538ab1/yarl-1.20.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:33bb660b390a0554d41f8ebec5cd4475502d84104b27e9b42f5321c5192bfcd1", size = 378771, upload-time = "2025-04-17T00:43:06.609Z" }, + { url = "https://files.pythonhosted.org/packages/3a/58/6c460bbb884abd2917c3eef6f663a4a873f8dc6f498561fc0ad92231c113/yarl-1.20.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:737e9f171e5a07031cbee5e9180f6ce21a6c599b9d4b2c24d35df20a52fabf4b", size = 375000, upload-time = "2025-04-17T00:43:09.01Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2a/dd7ed1aa23fea996834278d7ff178f215b24324ee527df53d45e34d21d28/yarl-1.20.0-cp312-cp312-win32.whl", hash = "sha256:839de4c574169b6598d47ad61534e6981979ca2c820ccb77bf70f4311dd2cc64", size = 86355, upload-time = "2025-04-17T00:43:11.311Z" }, + { url = "https://files.pythonhosted.org/packages/ca/c6/333fe0338305c0ac1c16d5aa7cc4841208d3252bbe62172e0051006b5445/yarl-1.20.0-cp312-cp312-win_amd64.whl", hash = "sha256:3d7dbbe44b443b0c4aa0971cb07dcb2c2060e4a9bf8d1301140a33a93c98e18c", size = 92904, upload-time = "2025-04-17T00:43:13.087Z" }, + { url = "https://files.pythonhosted.org/packages/0f/6f/514c9bff2900c22a4f10e06297714dbaf98707143b37ff0bcba65a956221/yarl-1.20.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2137810a20b933b1b1b7e5cf06a64c3ed3b4747b0e5d79c9447c00db0e2f752f", size = 145030, upload-time = "2025-04-17T00:43:15.083Z" }, + { url = "https://files.pythonhosted.org/packages/4e/9d/f88da3fa319b8c9c813389bfb3463e8d777c62654c7168e580a13fadff05/yarl-1.20.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:447c5eadd750db8389804030d15f43d30435ed47af1313303ed82a62388176d3", size = 96894, upload-time = "2025-04-17T00:43:17.372Z" }, + { url = "https://files.pythonhosted.org/packages/cd/57/92e83538580a6968b2451d6c89c5579938a7309d4785748e8ad42ddafdce/yarl-1.20.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42fbe577272c203528d402eec8bf4b2d14fd49ecfec92272334270b850e9cd7d", size = 94457, upload-time = "2025-04-17T00:43:19.431Z" }, + { url = "https://files.pythonhosted.org/packages/e9/ee/7ee43bd4cf82dddd5da97fcaddb6fa541ab81f3ed564c42f146c83ae17ce/yarl-1.20.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18e321617de4ab170226cd15006a565d0fa0d908f11f724a2c9142d6b2812ab0", size = 343070, upload-time = "2025-04-17T00:43:21.426Z" }, + { url = "https://files.pythonhosted.org/packages/4a/12/b5eccd1109e2097bcc494ba7dc5de156e41cf8309fab437ebb7c2b296ce3/yarl-1.20.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4345f58719825bba29895011e8e3b545e6e00257abb984f9f27fe923afca2501", size = 337739, upload-time = "2025-04-17T00:43:23.634Z" }, + { url = "https://files.pythonhosted.org/packages/7d/6b/0eade8e49af9fc2585552f63c76fa59ef469c724cc05b29519b19aa3a6d5/yarl-1.20.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5d9b980d7234614bc4674468ab173ed77d678349c860c3af83b1fffb6a837ddc", size = 351338, upload-time = "2025-04-17T00:43:25.695Z" }, + { url = "https://files.pythonhosted.org/packages/45/cb/aaaa75d30087b5183c7b8a07b4fb16ae0682dd149a1719b3a28f54061754/yarl-1.20.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:af4baa8a445977831cbaa91a9a84cc09debb10bc8391f128da2f7bd070fc351d", size = 353636, upload-time = "2025-04-17T00:43:27.876Z" }, + { url = "https://files.pythonhosted.org/packages/98/9d/d9cb39ec68a91ba6e66fa86d97003f58570327d6713833edf7ad6ce9dde5/yarl-1.20.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:123393db7420e71d6ce40d24885a9e65eb1edefc7a5228db2d62bcab3386a5c0", size = 348061, upload-time = "2025-04-17T00:43:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/72/6b/103940aae893d0cc770b4c36ce80e2ed86fcb863d48ea80a752b8bda9303/yarl-1.20.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ab47acc9332f3de1b39e9b702d9c916af7f02656b2a86a474d9db4e53ef8fd7a", size = 334150, upload-time = "2025-04-17T00:43:31.742Z" }, + { url = "https://files.pythonhosted.org/packages/ef/b2/986bd82aa222c3e6b211a69c9081ba46484cffa9fab2a5235e8d18ca7a27/yarl-1.20.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4a34c52ed158f89876cba9c600b2c964dfc1ca52ba7b3ab6deb722d1d8be6df2", size = 362207, upload-time = "2025-04-17T00:43:34.099Z" }, + { url = "https://files.pythonhosted.org/packages/14/7c/63f5922437b873795d9422cbe7eb2509d4b540c37ae5548a4bb68fd2c546/yarl-1.20.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:04d8cfb12714158abf2618f792c77bc5c3d8c5f37353e79509608be4f18705c9", size = 361277, upload-time = "2025-04-17T00:43:36.202Z" }, + { url = "https://files.pythonhosted.org/packages/81/83/450938cccf732466953406570bdb42c62b5ffb0ac7ac75a1f267773ab5c8/yarl-1.20.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:7dc63ad0d541c38b6ae2255aaa794434293964677d5c1ec5d0116b0e308031f5", size = 364990, upload-time = "2025-04-17T00:43:38.551Z" }, + { url = "https://files.pythonhosted.org/packages/b4/de/af47d3a47e4a833693b9ec8e87debb20f09d9fdc9139b207b09a3e6cbd5a/yarl-1.20.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f9d02b591a64e4e6ca18c5e3d925f11b559c763b950184a64cf47d74d7e41877", size = 374684, upload-time = "2025-04-17T00:43:40.481Z" }, + { url = "https://files.pythonhosted.org/packages/62/0b/078bcc2d539f1faffdc7d32cb29a2d7caa65f1a6f7e40795d8485db21851/yarl-1.20.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:95fc9876f917cac7f757df80a5dda9de59d423568460fe75d128c813b9af558e", size = 382599, upload-time = "2025-04-17T00:43:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/74/a9/4fdb1a7899f1fb47fd1371e7ba9e94bff73439ce87099d5dd26d285fffe0/yarl-1.20.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bb769ae5760cd1c6a712135ee7915f9d43f11d9ef769cb3f75a23e398a92d384", size = 378573, upload-time = "2025-04-17T00:43:44.797Z" }, + { url = "https://files.pythonhosted.org/packages/fd/be/29f5156b7a319e4d2e5b51ce622b4dfb3aa8d8204cd2a8a339340fbfad40/yarl-1.20.0-cp313-cp313-win32.whl", hash = "sha256:70e0c580a0292c7414a1cead1e076c9786f685c1fc4757573d2967689b370e62", size = 86051, upload-time = "2025-04-17T00:43:47.076Z" }, + { url = "https://files.pythonhosted.org/packages/52/56/05fa52c32c301da77ec0b5f63d2d9605946fe29defacb2a7ebd473c23b81/yarl-1.20.0-cp313-cp313-win_amd64.whl", hash = "sha256:4c43030e4b0af775a85be1fa0433119b1565673266a70bf87ef68a9d5ba3174c", size = 92742, upload-time = "2025-04-17T00:43:49.193Z" }, + { url = "https://files.pythonhosted.org/packages/d4/2f/422546794196519152fc2e2f475f0e1d4d094a11995c81a465faf5673ffd/yarl-1.20.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b6c4c3d0d6a0ae9b281e492b1465c72de433b782e6b5001c8e7249e085b69051", size = 163575, upload-time = "2025-04-17T00:43:51.533Z" }, + { url = "https://files.pythonhosted.org/packages/90/fc/67c64ddab6c0b4a169d03c637fb2d2a212b536e1989dec8e7e2c92211b7f/yarl-1.20.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:8681700f4e4df891eafa4f69a439a6e7d480d64e52bf460918f58e443bd3da7d", size = 106121, upload-time = "2025-04-17T00:43:53.506Z" }, + { url = "https://files.pythonhosted.org/packages/6d/00/29366b9eba7b6f6baed7d749f12add209b987c4cfbfa418404dbadc0f97c/yarl-1.20.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:84aeb556cb06c00652dbf87c17838eb6d92cfd317799a8092cee0e570ee11229", size = 103815, upload-time = "2025-04-17T00:43:55.41Z" }, + { url = "https://files.pythonhosted.org/packages/28/f4/a2a4c967c8323c03689383dff73396281ced3b35d0ed140580825c826af7/yarl-1.20.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f166eafa78810ddb383e930d62e623d288fb04ec566d1b4790099ae0f31485f1", size = 408231, upload-time = "2025-04-17T00:43:57.825Z" }, + { url = "https://files.pythonhosted.org/packages/0f/a1/66f7ffc0915877d726b70cc7a896ac30b6ac5d1d2760613603b022173635/yarl-1.20.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5d3d6d14754aefc7a458261027a562f024d4f6b8a798adb472277f675857b1eb", size = 390221, upload-time = "2025-04-17T00:44:00.526Z" }, + { url = "https://files.pythonhosted.org/packages/41/15/cc248f0504610283271615e85bf38bc014224122498c2016d13a3a1b8426/yarl-1.20.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2a8f64df8ed5d04c51260dbae3cc82e5649834eebea9eadfd829837b8093eb00", size = 411400, upload-time = "2025-04-17T00:44:02.853Z" }, + { url = "https://files.pythonhosted.org/packages/5c/af/f0823d7e092bfb97d24fce6c7269d67fcd1aefade97d0a8189c4452e4d5e/yarl-1.20.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4d9949eaf05b4d30e93e4034a7790634bbb41b8be2d07edd26754f2e38e491de", size = 411714, upload-time = "2025-04-17T00:44:04.904Z" }, + { url = "https://files.pythonhosted.org/packages/83/70/be418329eae64b9f1b20ecdaac75d53aef098797d4c2299d82ae6f8e4663/yarl-1.20.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c366b254082d21cc4f08f522ac201d0d83a8b8447ab562732931d31d80eb2a5", size = 404279, upload-time = "2025-04-17T00:44:07.721Z" }, + { url = "https://files.pythonhosted.org/packages/19/f5/52e02f0075f65b4914eb890eea1ba97e6fd91dd821cc33a623aa707b2f67/yarl-1.20.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:91bc450c80a2e9685b10e34e41aef3d44ddf99b3a498717938926d05ca493f6a", size = 384044, upload-time = "2025-04-17T00:44:09.708Z" }, + { url = "https://files.pythonhosted.org/packages/6a/36/b0fa25226b03d3f769c68d46170b3e92b00ab3853d73127273ba22474697/yarl-1.20.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9c2aa4387de4bc3a5fe158080757748d16567119bef215bec643716b4fbf53f9", size = 416236, upload-time = "2025-04-17T00:44:11.734Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3a/54c828dd35f6831dfdd5a79e6c6b4302ae2c5feca24232a83cb75132b205/yarl-1.20.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:d2cbca6760a541189cf87ee54ff891e1d9ea6406079c66341008f7ef6ab61145", size = 402034, upload-time = "2025-04-17T00:44:13.975Z" }, + { url = "https://files.pythonhosted.org/packages/10/97/c7bf5fba488f7e049f9ad69c1b8fdfe3daa2e8916b3d321aa049e361a55a/yarl-1.20.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:798a5074e656f06b9fad1a162be5a32da45237ce19d07884d0b67a0aa9d5fdda", size = 407943, upload-time = "2025-04-17T00:44:16.052Z" }, + { url = "https://files.pythonhosted.org/packages/fd/a4/022d2555c1e8fcff08ad7f0f43e4df3aba34f135bff04dd35d5526ce54ab/yarl-1.20.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f106e75c454288472dbe615accef8248c686958c2e7dd3b8d8ee2669770d020f", size = 423058, upload-time = "2025-04-17T00:44:18.547Z" }, + { url = "https://files.pythonhosted.org/packages/4c/f6/0873a05563e5df29ccf35345a6ae0ac9e66588b41fdb7043a65848f03139/yarl-1.20.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:3b60a86551669c23dc5445010534d2c5d8a4e012163218fc9114e857c0586fdd", size = 423792, upload-time = "2025-04-17T00:44:20.639Z" }, + { url = "https://files.pythonhosted.org/packages/9e/35/43fbbd082708fa42e923f314c24f8277a28483d219e049552e5007a9aaca/yarl-1.20.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:3e429857e341d5e8e15806118e0294f8073ba9c4580637e59ab7b238afca836f", size = 422242, upload-time = "2025-04-17T00:44:22.851Z" }, + { url = "https://files.pythonhosted.org/packages/ed/f7/f0f2500cf0c469beb2050b522c7815c575811627e6d3eb9ec7550ddd0bfe/yarl-1.20.0-cp313-cp313t-win32.whl", hash = "sha256:65a4053580fe88a63e8e4056b427224cd01edfb5f951498bfefca4052f0ce0ac", size = 93816, upload-time = "2025-04-17T00:44:25.491Z" }, + { url = "https://files.pythonhosted.org/packages/3f/93/f73b61353b2a699d489e782c3f5998b59f974ec3156a2050a52dfd7e8946/yarl-1.20.0-cp313-cp313t-win_amd64.whl", hash = "sha256:53b2da3a6ca0a541c1ae799c349788d480e5144cac47dba0266c7cb6c76151fe", size = 101093, upload-time = "2025-04-17T00:44:27.418Z" }, + { url = "https://files.pythonhosted.org/packages/ea/1f/70c57b3d7278e94ed22d85e09685d3f0a38ebdd8c5c73b65ba4c0d0fe002/yarl-1.20.0-py3-none-any.whl", hash = "sha256:5d0fe6af927a47a230f31e6004621fd0959eaa915fc62acfafa67ff7229a3124", size = 46124, upload-time = "2025-04-17T00:45:12.199Z" }, +] diff --git a/portingplan.md b/portingplan.md new file mode 100644 index 0000000..2d26253 --- /dev/null +++ b/portingplan.md @@ -0,0 +1,252 @@ +# Garth Python to Go Port Plan + +## Overview +Port the Python `garth` library to Go with feature parity. The existing Go code provides basic authentication and activity retrieval. This plan outlines the systematic porting of all Python modules. + +## Current State Analysis +**Existing Go code has:** +- Basic SSO authentication flow (`main.go`) +- OAuth1/OAuth2 token handling +- Activity retrieval +- Session persistence + +**Missing (needs porting):** +- All data models and retrieval methods +- Stats modules +- User profile/settings +- Structured error handling +- Client configuration options + +## Implementation Plan + +### 1. Project Structure Setup +``` +garth/ +├── main.go (keep existing) +├── client/ +│ ├── client.go (refactor from main.go) +│ ├── auth.go (OAuth flows) +│ └── sso.go (SSO authentication) +├── data/ +│ ├── base.go +│ ├── body_battery.go +│ ├── hrv.go +│ ├── sleep.go +│ └── weight.go +├── stats/ +│ ├── base.go +│ ├── hrv.go +│ ├── steps.go +│ ├── stress.go +│ └── [other stats].go +├── users/ +│ ├── profile.go +│ └── settings.go +├── utils/ +│ └── utils.go +└── types/ + └── tokens.go +``` + +### 2. Core Client Refactoring (Priority 1) + +**File: `client/client.go`** +- Extract client logic from `main.go` +- Port `src/garth/http.py` Client class +- Key methods to implement: + ```go + type Client struct { + Domain string + HTTPClient *http.Client + OAuth1Token *OAuth1Token + OAuth2Token *OAuth2Token + // ... other fields from Python Client + } + + func (c *Client) Configure(opts ...ConfigOption) error + func (c *Client) ConnectAPI(path, method string, data interface{}) (interface{}, error) + func (c *Client) Download(path string) ([]byte, error) + func (c *Client) Upload(filePath, uploadPath string) (map[string]interface{}, error) + ``` + +**Reference:** `src/garth/http.py` lines 23-280 + +### 3. Authentication Module (Priority 1) + +**File: `client/auth.go`** +- Port `src/garth/auth_tokens.py` token structures +- Implement token expiration checking +- Add MFA support placeholder + +**File: `client/sso.go`** +- Port SSO functions from `src/garth/sso.py` +- Extract login logic from current `main.go` +- Implement `ResumeLogin()` for MFA completion + +**Reference:** `src/garth/sso.py` and `src/garth/auth_tokens.py` + +### 4. Data Models Base (Priority 2) + +**File: `data/base.go`** +- Port `src/garth/data/_base.py` Data interface and base functionality +- Implement concurrent data fetching pattern: + ```go + type Data interface { + Get(day time.Time, client *Client) (interface{}, error) + List(end time.Time, days int, client *Client, maxWorkers int) ([]interface{}, error) + } + ``` + +**Reference:** `src/garth/data/_base.py` lines 8-40 + +### 5. Body Battery Data (Priority 2) + +**File: `data/body_battery.go`** +- Port all structs from `src/garth/data/body_battery/` directory +- Key structures to implement: + ```go + type DailyBodyBatteryStress struct { + UserProfilePK int `json:"userProfilePk"` + CalendarDate time.Time `json:"calendarDate"` + // ... all fields from Python class + } + + type BodyBatteryData struct { + Event *BodyBatteryEvent `json:"event"` + // ... other fields + } + ``` + +**Reference:** +- `src/garth/data/body_battery/daily_stress.py` +- `src/garth/data/body_battery/events.py` +- `src/garth/data/body_battery/readings.py` + +### 6. Other Data Models (Priority 2) + +**Files: `data/hrv.go`, `data/sleep.go`, `data/weight.go`** + +For each file, port the corresponding Python module: + +**HRV Data (`data/hrv.go`):** +```go +type HRVData struct { + UserProfilePK int `json:"userProfilePk"` + HRVSummary HRVSummary `json:"hrvSummary"` + HRVReadings []HRVReading `json:"hrvReadings"` + // ... rest of fields +} +``` +**Reference:** `src/garth/data/hrv.py` + +**Sleep Data (`data/sleep.go`):** +- Port `DailySleepDTO`, `SleepScores`, `SleepMovement` structs +- Implement property methods as getter functions +**Reference:** `src/garth/data/sleep.py` + +**Weight Data (`data/weight.go`):** +- Port `WeightData` struct with field validation +- Implement date range fetching logic +**Reference:** `src/garth/data/weight.py` + +### 7. Stats Modules (Priority 3) + +**File: `stats/base.go`** +- Port `src/garth/stats/_base.py` Stats base class +- Implement pagination logic for large date ranges + +**Individual Stats Files:** +Create separate files for each stat type, porting from corresponding Python files: +- `stats/hrv.go` ← `src/garth/stats/hrv.py` +- `stats/steps.go` ← `src/garth/stats/steps.py` +- `stats/stress.go` ← `src/garth/stats/stress.py` +- `stats/sleep.go` ← `src/garth/stats/sleep.py` +- `stats/hydration.go` ← `src/garth/stats/hydration.py` +- `stats/intensity_minutes.go` ← `src/garth/stats/intensity_minutes.py` + +**Reference:** All files in `src/garth/stats/` + +### 8. User Profile and Settings (Priority 3) + +**File: `users/profile.go`** +```go +type UserProfile struct { + ID int `json:"id"` + ProfileID int `json:"profileId"` + DisplayName string `json:"displayName"` + // ... all other fields from Python UserProfile +} + +func (up *UserProfile) Get(client *Client) error +``` + +**File: `users/settings.go`** +- Port all nested structs: `PowerFormat`, `FirstDayOfWeek`, `WeatherLocation`, etc. +- Implement `UserSettings.Get()` method + +**Reference:** `src/garth/users/profile.py` and `src/garth/users/settings.py` + +### 9. Utilities (Priority 3) + +**File: `utils/utils.go`** +```go +func CamelToSnake(s string) string +func CamelToSnakeDict(m map[string]interface{}) map[string]interface{} +func FormatEndDate(end interface{}) time.Time +func DateRange(end time.Time, days int) []time.Time +func GetLocalizedDateTime(gmtTimestamp, localTimestamp int64) time.Time +``` + +**Reference:** `src/garth/utils.py` + +### 10. Error Handling (Priority 4) + +**File: `errors/errors.go`** +```go +type GarthError struct { + Message string + Cause error +} + +type GarthHTTPError struct { + GarthError + StatusCode int + Response string +} +``` + +**Reference:** `src/garth/exc.py` + +### 11. CLI Tool (Priority 4) + +**File: `cmd/garth/main.go`** +- Port `src/garth/cli.py` functionality +- Support login and token output + +### 12. Testing Strategy + +For each module: +1. Create `*_test.go` files with unit tests +2. Mock HTTP responses using Python examples as expected data +3. Test error handling paths +4. Add integration tests with real API calls (optional) + +### 13. Key Implementation Notes + +1. **JSON Handling:** Use struct tags for proper JSON marshaling/unmarshaling +2. **Time Handling:** Convert Python datetime objects to Go `time.Time` +3. **Error Handling:** Wrap errors with context using `fmt.Errorf` +4. **Concurrency:** Use goroutines and channels for the concurrent data fetching in `List()` methods +5. **HTTP Client:** Reuse the existing HTTP client setup with proper timeout and retry logic + +### 14. Development Order + +1. Start with client refactoring and authentication +2. Implement base data structures and one data model (body battery) +3. Add remaining data models +4. Implement stats modules +5. Add user profile/settings +6. Complete utilities and error handling +7. Add CLI tool and tests + +This plan provides a systematic approach to achieving feature parity with the Python library while maintaining Go idioms and best practices. \ No newline at end of file