Workout Summary
" in content + assert "Minute-by-Minute Breakdown
" in html_output + assert "Minute-by-Minute Breakdown
" not in html_output_absent + + md_output_absent = report_generator.generate_workout_report( + context_absent, None, "md" + ) + assert "### Minute-by-Minute Breakdown" not in md_output_absent + + # Case 2: key is present but empty + context_empty = context.copy() + context_empty["minute_by_minute"] = [] + + html_output_empty = report_generator.generate_workout_report( + context_empty, None, "html" + ) + assert "Minute-by-Minute Breakdown
" not in html_output_empty + + md_output_empty = report_generator.generate_workout_report( + context_empty, None, "md" + ) + assert "### Minute-by-Minute Breakdown" not in md_output_empty + +================================================ +FILE: utils/__init__.py +================================================ + + +================================================ +FILE: utils/gear_estimation.py +================================================ +"""Gear estimation utilities for cycling workouts.""" + +import numpy as np +import pandas as pd +from typing import Dict, Any, Optional + +from config.settings import BikeConfig + + +def estimate_gear_series( + df: pd.DataFrame, + wheel_circumference_m: float = BikeConfig.TIRE_CIRCUMFERENCE_M, + valid_configurations: dict = BikeConfig.VALID_CONFIGURATIONS, +) -> pd.Series: + """Estimate gear per sample using speed and cadence data. + + Args: + df: DataFrame with 'speed_mps' and 'cadence_rpm' columns + wheel_circumference_m: Wheel circumference in meters + valid_configurations: Dict of chainring -> list of cogs + + Returns: + Series with gear strings (e.g., '38x16') aligned to input index + """ + pass + + +def compute_gear_summary(gear_series: pd.Series) -> dict: + """Compute summary statistics from gear series. + + Args: + gear_series: Series of gear strings + + Returns: + Dict with summary metrics + """ + pass + +================================================ +FILE: visualizers/__init__.py +================================================ +"""Visualization modules for workout data.""" + +from .chart_generator import ChartGenerator +from .report_generator import ReportGenerator + +__all__ = ['ChartGenerator', 'ReportGenerator'] + +================================================ +FILE: visualizers/chart_generator.py +================================================ +"""Chart generator for workout data visualization.""" + +import logging +import matplotlib.pyplot as plt +import seaborn as sns +import pandas as pd +import numpy as np +from pathlib import Path +from typing import Dict, Any, List, Optional, Tuple +import plotly.graph_objects as go +import plotly.express as px +from plotly.subplots import make_subplots + +from models.workout import WorkoutData +from models.zones import ZoneCalculator + +logger = logging.getLogger(__name__) + + +class ChartGenerator: + """Generate various charts and visualizations for workout data.""" + + def __init__(self, output_dir: Path = None): + """Initialize chart generator. + + Args: + output_dir: Directory to save charts + """ + self.output_dir = output_dir or Path('charts') + self.output_dir.mkdir(exist_ok=True) + self.zone_calculator = ZoneCalculator() + + # Set style + plt.style.use('seaborn-v0_8') + sns.set_palette("husl") + + def _get_avg_max_values(self, analysis: Dict[str, Any], data_type: str, workout: WorkoutData) -> Tuple[float, float]: + """Get avg and max values from analysis dict or compute from workout data. + + Args: + analysis: Analysis results from WorkoutAnalyzer + data_type: 'power', 'hr', or 'speed' + workout: WorkoutData object + + Returns: + Tuple of (avg_value, max_value) + """ + if analysis and 'summary' in analysis: + summary = analysis['summary'] + if data_type == 'power': + avg_key, max_key = 'avg_power', 'max_power' + elif data_type == 'hr': + avg_key, max_key = 'avg_hr', 'max_hr' + elif data_type == 'speed': + avg_key, max_key = 'avg_speed_kmh', 'max_speed_kmh' + else: + raise ValueError(f"Unsupported data_type: {data_type}") + + avg_val = summary.get(avg_key) + max_val = summary.get(max_key) + + if avg_val is not None and max_val is not None: + return avg_val, max_val + + # Fallback: compute from workout data + if data_type == 'power' and workout.power and workout.power.power_values: + return np.mean(workout.power.power_values), np.max(workout.power.power_values) + elif data_type == 'hr' and workout.heart_rate and workout.heart_rate.heart_rate_values: + return np.mean(workout.heart_rate.heart_rate_values), np.max(workout.heart_rate.heart_rate_values) + elif data_type == 'speed' and workout.speed and workout.speed.speed_values: + return np.mean(workout.speed.speed_values), np.max(workout.speed.speed_values) + + # Default fallback + return 0, 0 + + def _get_avg_max_labels(self, data_type: str, analysis: Dict[str, Any], workout: WorkoutData) -> Tuple[str, str]: + """Get formatted average and maximum labels for chart annotations. + + Args: + data_type: 'power', 'hr', or 'speed' + analysis: Analysis results from WorkoutAnalyzer + workout: WorkoutData object + + Returns: + Tuple of (avg_label, max_label) + """ + avg_val, max_val = self._get_avg_max_values(analysis, data_type, workout) + + if data_type == 'power': + avg_label = f'Avg: {avg_val:.0f}W' + max_label = f'Max: {max_val:.0f}W' + elif data_type == 'hr': + avg_label = f'Avg: {avg_val:.0f} bpm' + max_label = f'Max: {max_val:.0f} bpm' + elif data_type == 'speed': + avg_label = f'Avg: {avg_val:.1f} km/h' + max_label = f'Max: {max_val:.1f} km/h' + else: + avg_label = f'Avg: {avg_val:.1f}' + max_label = f'Max: {max_val:.1f}' + + return avg_label, max_label + + def generate_workout_charts(self, workout: WorkoutData, analysis: Dict[str, Any]) -> Dict[str, str]: + """Generate all workout charts. + + Args: + workout: WorkoutData object + analysis: Analysis results from WorkoutAnalyzer + + Returns: + Dictionary mapping chart names to file paths + """ + charts = {} + + # Time series charts + charts['power_time_series'] = self._create_power_time_series(workout, analysis, elevation_overlay=True, zone_shading=True) + charts['heart_rate_time_series'] = self._create_heart_rate_time_series(workout, analysis, elevation_overlay=True) + charts['speed_time_series'] = self._create_speed_time_series(workout, analysis, elevation_overlay=True) + charts['elevation_time_series'] = self._create_elevation_time_series(workout) + + # Distribution charts + charts['power_distribution'] = self._create_power_distribution(workout, analysis) + charts['heart_rate_distribution'] = self._create_heart_rate_distribution(workout, analysis) + charts['speed_distribution'] = self._create_speed_distribution(workout, analysis) + + # Zone charts + charts['power_zones'] = self._create_power_zones_chart(analysis) + charts['heart_rate_zones'] = self._create_heart_rate_zones_chart(analysis) + + # Correlation charts + charts['power_vs_heart_rate'] = self._create_power_vs_heart_rate(workout) + charts['power_vs_speed'] = self._create_power_vs_speed(workout) + + # Summary dashboard + charts['workout_dashboard'] = self._create_workout_dashboard(workout, analysis) + + return charts + + def _create_power_time_series(self, workout: WorkoutData, analysis: Dict[str, Any] = None, elevation_overlay: bool = True, zone_shading: bool = True) -> str: + """Create power vs time chart. + + Args: + workout: WorkoutData object + analysis: Analysis results from WorkoutAnalyzer + elevation_overlay: Whether to add an elevation overlay + zone_shading: Whether to add power zone shading + + Returns: + Path to saved chart + """ + if not workout.power or not workout.power.power_values: + return None + + fig, ax1 = plt.subplots(figsize=(12, 6)) + + power_values = workout.power.power_values + time_minutes = np.arange(len(power_values)) / 60 + + # Plot power + ax1.plot(time_minutes, power_values, linewidth=0.5, alpha=0.8, color='blue') + ax1.set_xlabel('Time (minutes)') + ax1.set_ylabel('Power (W)', color='blue') + ax1.tick_params(axis='y', labelcolor='blue') + + # Add avg/max annotations from analysis or fallback + avg_power_label, max_power_label = self._get_avg_max_labels('power', analysis, workout) + ax1.axhline(y=self._get_avg_max_values(analysis, 'power', workout)[0], color='red', linestyle='--', + label=avg_power_label) + ax1.axhline(y=self._get_avg_max_values(analysis, 'power', workout)[1], color='green', linestyle='--', + label=max_power_label) + + # Add power zone shading + if zone_shading and analysis and 'power_analysis' in analysis: + power_zones = self.zone_calculator.get_power_zones() + # Try to get FTP from analysis, otherwise use a default or the zone calculator's default + ftp = analysis.get('power_analysis', {}).get('ftp', 250) # Fallback to 250W if not in analysis + + # Recalculate zones based on FTP percentage + power_zones_percent = { + 'Recovery': {'min': 0, 'max': 0.5}, # <50% FTP + 'Endurance': {'min': 0.5, 'max': 0.75}, # 50-75% FTP + 'Tempo': {'min': 0.75, 'max': 0.9}, # 75-90% FTP + 'Threshold': {'min': 0.9, 'max': 1.05}, # 90-105% FTP + 'VO2 Max': {'min': 1.05, 'max': 1.2}, # 105-120% FTP + 'Anaerobic': {'min': 1.2, 'max': 10} # >120% FTP (arbitrary max for shading) + } + + for zone_name, zone_def_percent in power_zones_percent.items(): + min_power = ftp * zone_def_percent['min'] + max_power = ftp * zone_def_percent['max'] + + # Find the corresponding ZoneDefinition to get the color + zone_color = next((z.color for z_name, z in power_zones.items() if z_name == zone_name), 'grey') + + ax1.axhspan(min_power, max_power, + alpha=0.1, color=zone_color, + label=f'{zone_name} ({min_power:.0f}-{max_power:.0f}W)') + + # Add elevation overlay if available + if elevation_overlay and workout.elevation and workout.elevation.elevation_values: + # Create twin axis for elevation + ax2 = ax1.twinx() + elevation_values = workout.elevation.elevation_values + + # Apply light smoothing to elevation for visual stability + # Using a simple rolling mean, NaN-safe + elevation_smoothed = pd.Series(elevation_values).rolling(window=5, min_periods=1, center=True).mean().values + + # Align lengths (assume same sampling rate) + min_len = min(len(power_values), len(elevation_smoothed)) + elevation_aligned = elevation_smoothed[:min_len] + time_aligned = time_minutes[:min_len] + + ax2.fill_between(time_aligned, elevation_aligned, alpha=0.2, color='brown', label='Elevation') + ax2.set_ylabel('Elevation (m)', color='brown') + ax2.tick_params(axis='y', labelcolor='brown') + + # Combine legends + lines1, labels1 = ax1.get_legend_handles_labels() + lines2, labels2 = ax2.get_legend_handles_labels() + ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left') + else: + ax1.legend() + + ax1.set_title('Power Over Time') + ax1.grid(True, alpha=0.3) + + filepath = self.output_dir / 'power_time_series.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_heart_rate_time_series(self, workout: WorkoutData, analysis: Dict[str, Any] = None, elevation_overlay: bool = True) -> str: + """Create heart rate vs time chart. + + Args: + workout: WorkoutData object + analysis: Analysis results from WorkoutAnalyzer + elevation_overlay: Whether to add an elevation overlay + + Returns: + Path to saved chart + """ + if not workout.heart_rate or not workout.heart_rate.heart_rate_values: + return None + + fig, ax1 = plt.subplots(figsize=(12, 6)) + + hr_values = workout.heart_rate.heart_rate_values + time_minutes = np.arange(len(hr_values)) / 60 + + # Plot heart rate + ax1.plot(time_minutes, hr_values, linewidth=0.5, alpha=0.8, color='red') + ax1.set_xlabel('Time (minutes)') + ax1.set_ylabel('Heart Rate (bpm)', color='red') + ax1.tick_params(axis='y', labelcolor='red') + + # Add avg/max annotations from analysis or fallback + avg_hr_label, max_hr_label = self._get_avg_max_labels('hr', analysis, workout) + ax1.axhline(y=self._get_avg_max_values(analysis, 'hr', workout)[0], color='darkred', linestyle='--', + label=avg_hr_label) + ax1.axhline(y=self._get_avg_max_values(analysis, 'hr', workout)[1], color='darkgreen', linestyle='--', + label=max_hr_label) + + # Add elevation overlay if available + if elevation_overlay and workout.elevation and workout.elevation.elevation_values: + # Create twin axis for elevation + ax2 = ax1.twinx() + elevation_values = workout.elevation.elevation_values + + # Apply light smoothing to elevation for visual stability + elevation_smoothed = pd.Series(elevation_values).rolling(window=5, min_periods=1, center=True).mean().values + + # Align lengths (assume same sampling rate) + min_len = min(len(hr_values), len(elevation_smoothed)) + elevation_aligned = elevation_smoothed[:min_len] + time_aligned = time_minutes[:min_len] + + ax2.fill_between(time_aligned, elevation_aligned, alpha=0.2, color='brown', label='Elevation') + ax2.set_ylabel('Elevation (m)', color='brown') + ax2.tick_params(axis='y', labelcolor='brown') + + # Combine legends + lines1, labels1 = ax1.get_legend_handles_labels() + lines2, labels2 = ax2.get_legend_handles_labels() + ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left') + else: + ax1.legend() + + ax1.set_title('Heart Rate Over Time') + ax1.grid(True, alpha=0.3) + + filepath = self.output_dir / 'heart_rate_time_series.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_speed_time_series(self, workout: WorkoutData, analysis: Dict[str, Any] = None, elevation_overlay: bool = True) -> str: + """Create speed vs time chart. + + Args: + workout: WorkoutData object + analysis: Analysis results from WorkoutAnalyzer + elevation_overlay: Whether to add an elevation overlay + + Returns: + Path to saved chart + """ + if not workout.speed or not workout.speed.speed_values: + return None + + fig, ax1 = plt.subplots(figsize=(12, 6)) + + speed_values = workout.speed.speed_values + time_minutes = np.arange(len(speed_values)) / 60 + + # Plot speed + ax1.plot(time_minutes, speed_values, linewidth=0.5, alpha=0.8, color='blue') + ax1.set_xlabel('Time (minutes)') + ax1.set_ylabel('Speed (km/h)', color='blue') + ax1.tick_params(axis='y', labelcolor='blue') + + # Add avg/max annotations from analysis or fallback + avg_speed_label, max_speed_label = self._get_avg_max_labels('speed', analysis, workout) + ax1.axhline(y=self._get_avg_max_values(analysis, 'speed', workout)[0], color='darkblue', linestyle='--', + label=avg_speed_label) + ax1.axhline(y=self._get_avg_max_values(analysis, 'speed', workout)[1], color='darkgreen', linestyle='--', + label=max_speed_label) + + # Add elevation overlay if available + if elevation_overlay and workout.elevation and workout.elevation.elevation_values: + # Create twin axis for elevation + ax2 = ax1.twinx() + elevation_values = workout.elevation.elevation_values + + # Apply light smoothing to elevation for visual stability + elevation_smoothed = pd.Series(elevation_values).rolling(window=5, min_periods=1, center=True).mean().values + + # Align lengths (assume same sampling rate) + min_len = min(len(speed_values), len(elevation_smoothed)) + elevation_aligned = elevation_smoothed[:min_len] + time_aligned = time_minutes[:min_len] + + ax2.fill_between(time_aligned, elevation_aligned, alpha=0.2, color='brown', label='Elevation') + ax2.set_ylabel('Elevation (m)', color='brown') + ax2.tick_params(axis='y', labelcolor='brown') + + # Combine legends + lines1, labels1 = ax1.get_legend_handles_labels() + lines2, labels2 = ax2.get_legend_handles_labels() + ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper left') + else: + ax1.legend() + + ax1.set_title('Speed Over Time') + ax1.grid(True, alpha=0.3) + + filepath = self.output_dir / 'speed_time_series.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_elevation_time_series(self, workout: WorkoutData) -> str: + """Create elevation vs time chart. + + Args: + workout: WorkoutData object + + Returns: + Path to saved chart + """ + if not workout.elevation or not workout.elevation.elevation_values: + return None + + fig, ax = plt.subplots(figsize=(12, 6)) + + elevation_values = workout.elevation.elevation_values + time_minutes = np.arange(len(elevation_values)) / 60 + + ax.plot(time_minutes, elevation_values, linewidth=1, alpha=0.8, color='brown') + ax.fill_between(time_minutes, elevation_values, alpha=0.3, color='brown') + + ax.set_xlabel('Time (minutes)') + ax.set_ylabel('Elevation (m)') + ax.set_title('Elevation Profile') + ax.grid(True, alpha=0.3) + + filepath = self.output_dir / 'elevation_time_series.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_power_distribution(self, workout: WorkoutData, analysis: Dict[str, Any]) -> str: + """Create power distribution histogram. + + Args: + workout: WorkoutData object + analysis: Analysis results + + Returns: + Path to saved chart + """ + if not workout.power or not workout.power.power_values: + return None + + fig, ax = plt.subplots(figsize=(10, 6)) + + power_values = workout.power.power_values + + ax.hist(power_values, bins=50, alpha=0.7, color='orange', edgecolor='black') + ax.axvline(x=workout.power.avg_power, color='red', linestyle='--', + label=f'Avg: {workout.power.avg_power:.0f}W') + + ax.set_xlabel('Power (W)') + ax.set_ylabel('Frequency') + ax.set_title('Power Distribution') + ax.legend() + ax.grid(True, alpha=0.3) + + filepath = self.output_dir / 'power_distribution.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_heart_rate_distribution(self, workout: WorkoutData, analysis: Dict[str, Any]) -> str: + """Create heart rate distribution histogram. + + Args: + workout: WorkoutData object + analysis: Analysis results + + Returns: + Path to saved chart + """ + if not workout.heart_rate or not workout.heart_rate.heart_rate_values: + return None + + fig, ax = plt.subplots(figsize=(10, 6)) + + hr_values = workout.heart_rate.heart_rate_values + + ax.hist(hr_values, bins=30, alpha=0.7, color='red', edgecolor='black') + ax.axvline(x=workout.heart_rate.avg_hr, color='darkred', linestyle='--', + label=f'Avg: {workout.heart_rate.avg_hr:.0f} bpm') + + ax.set_xlabel('Heart Rate (bpm)') + ax.set_ylabel('Frequency') + ax.set_title('Heart Rate Distribution') + ax.legend() + ax.grid(True, alpha=0.3) + + filepath = self.output_dir / 'heart_rate_distribution.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_speed_distribution(self, workout: WorkoutData, analysis: Dict[str, Any]) -> str: + """Create speed distribution histogram. + + Args: + workout: WorkoutData object + analysis: Analysis results + + Returns: + Path to saved chart + """ + if not workout.speed or not workout.speed.speed_values: + return None + + fig, ax = plt.subplots(figsize=(10, 6)) + + speed_values = workout.speed.speed_values + + ax.hist(speed_values, bins=30, alpha=0.7, color='blue', edgecolor='black') + ax.axvline(x=workout.speed.avg_speed, color='darkblue', linestyle='--', + label=f'Avg: {workout.speed.avg_speed:.1f} km/h') + + ax.set_xlabel('Speed (km/h)') + ax.set_ylabel('Frequency') + ax.set_title('Speed Distribution') + ax.legend() + ax.grid(True, alpha=0.3) + + filepath = self.output_dir / 'speed_distribution.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_power_zones_chart(self, analysis: Dict[str, Any]) -> str: + """Create power zones pie chart. + + Args: + analysis: Analysis results + + Returns: + Path to saved chart + """ + if 'power_analysis' not in analysis or 'power_zones' not in analysis['power_analysis']: + return None + + power_zones = analysis['power_analysis']['power_zones'] + + fig, ax = plt.subplots(figsize=(8, 8)) + + labels = list(power_zones.keys()) + sizes = list(power_zones.values()) + colors = plt.cm.Set3(np.linspace(0, 1, len(labels))) + + ax.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90) + ax.set_title('Time in Power Zones') + + filepath = self.output_dir / 'power_zones.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_heart_rate_zones_chart(self, analysis: Dict[str, Any]) -> str: + """Create heart rate zones pie chart. + + Args: + analysis: Analysis results + + Returns: + Path to saved chart + """ + if 'heart_rate_analysis' not in analysis or 'hr_zones' not in analysis['heart_rate_analysis']: + return None + + hr_zones = analysis['heart_rate_analysis']['hr_zones'] + + fig, ax = plt.subplots(figsize=(8, 8)) + + labels = list(hr_zones.keys()) + sizes = list(hr_zones.values()) + colors = plt.cm.Set3(np.linspace(0, 1, len(labels))) + + ax.pie(sizes, labels=labels, colors=colors, autopct='%1.1f%%', startangle=90) + ax.set_title('Time in Heart Rate Zones') + + filepath = self.output_dir / 'heart_rate_zones.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_power_vs_heart_rate(self, workout: WorkoutData) -> str: + """Create power vs heart rate scatter plot. + + Args: + workout: WorkoutData object + + Returns: + Path to saved chart + """ + if (not workout.power or not workout.power.power_values or + not workout.heart_rate or not workout.heart_rate.heart_rate_values): + return None + + power_values = workout.power.power_values + hr_values = workout.heart_rate.heart_rate_values + + # Align arrays + min_len = min(len(power_values), len(hr_values)) + if min_len == 0: + return None + + power_values = power_values[:min_len] + hr_values = hr_values[:min_len] + + fig, ax = plt.subplots(figsize=(10, 6)) + + ax.scatter(power_values, hr_values, alpha=0.5, s=1) + + # Add trend line + z = np.polyfit(power_values, hr_values, 1) + p = np.poly1d(z) + ax.plot(power_values, p(power_values), "r--", alpha=0.8) + + ax.set_xlabel('Power (W)') + ax.set_ylabel('Heart Rate (bpm)') + ax.set_title('Power vs Heart Rate') + ax.grid(True, alpha=0.3) + + filepath = self.output_dir / 'power_vs_heart_rate.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_power_vs_speed(self, workout: WorkoutData) -> str: + """Create power vs speed scatter plot. + + Args: + workout: WorkoutData object + + Returns: + Path to saved chart + """ + if (not workout.power or not workout.power.power_values or + not workout.speed or not workout.speed.speed_values): + return None + + power_values = workout.power.power_values + speed_values = workout.speed.speed_values + + # Align arrays + min_len = min(len(power_values), len(speed_values)) + if min_len == 0: + return None + + power_values = power_values[:min_len] + speed_values = speed_values[:min_len] + + fig, ax = plt.subplots(figsize=(10, 6)) + + ax.scatter(power_values, speed_values, alpha=0.5, s=1) + + # Add trend line + z = np.polyfit(power_values, speed_values, 1) + p = np.poly1d(z) + ax.plot(power_values, p(power_values), "r--", alpha=0.8) + + ax.set_xlabel('Power (W)') + ax.set_ylabel('Speed (km/h)') + ax.set_title('Power vs Speed') + ax.grid(True, alpha=0.3) + + filepath = self.output_dir / 'power_vs_speed.png' + plt.tight_layout() + plt.savefig(filepath, dpi=300, bbox_inches='tight') + plt.close() + + return str(filepath) + + def _create_workout_dashboard(self, workout: WorkoutData, analysis: Dict[str, Any]) -> str: + """Create comprehensive workout dashboard. + + Args: + workout: WorkoutData object + analysis: Analysis results + + Returns: + Path to saved chart + """ + fig = make_subplots( + rows=3, cols=2, + subplot_titles=('Power Over Time', 'Heart Rate Over Time', + 'Speed Over Time', 'Elevation Profile', + 'Power Distribution', 'Heart Rate Distribution'), + specs=[[{"secondary_y": False}, {"secondary_y": False}], + [{"secondary_y": False}, {"secondary_y": False}], + [{"secondary_y": False}, {"secondary_y": False}]] + ) + + # Power time series + if workout.power and workout.power.power_values: + power_values = workout.power.power_values + time_minutes = np.arange(len(power_values)) / 60 + fig.add_trace( + go.Scatter(x=time_minutes, y=power_values, name='Power', line=dict(color='orange')), + row=1, col=1 + ) + + # Heart rate time series + if workout.heart_rate and workout.heart_rate.heart_rate_values: + hr_values = workout.heart_rate.heart_rate_values + time_minutes = np.arange(len(hr_values)) / 60 + fig.add_trace( + go.Scatter(x=time_minutes, y=hr_values, name='Heart Rate', line=dict(color='red')), + row=1, col=2 + ) + + # Speed time series + if workout.speed and workout.speed.speed_values: + speed_values = workout.speed.speed_values + time_minutes = np.arange(len(speed_values)) / 60 + fig.add_trace( + go.Scatter(x=time_minutes, y=speed_values, name='Speed', line=dict(color='blue')), + row=2, col=1 + ) + + # Elevation profile + if workout.elevation and workout.elevation.elevation_values: + elevation_values = workout.elevation.elevation_values + time_minutes = np.arange(len(elevation_values)) / 60 + fig.add_trace( + go.Scatter(x=time_minutes, y=elevation_values, name='Elevation', line=dict(color='brown')), + row=2, col=2 + ) + + # Power distribution + if workout.power and workout.power.power_values: + power_values = workout.power.power_values + fig.add_trace( + go.Histogram(x=power_values, name='Power Distribution', nbinsx=50), + row=3, col=1 + ) + + # Heart rate distribution + if workout.heart_rate and workout.heart_rate.heart_rate_values: + hr_values = workout.heart_rate.heart_rate_values + fig.add_trace( + go.Histogram(x=hr_values, name='HR Distribution', nbinsx=30), + row=3, col=2 + ) + + # Update layout + fig.update_layout( + height=1200, + title_text=f"Workout Dashboard - {workout.metadata.activity_name}", + showlegend=False + ) + + # Update axes labels + fig.update_xaxes(title_text="Time (minutes)", row=1, col=1) + fig.update_yaxes(title_text="Power (W)", row=1, col=1) + fig.update_xaxes(title_text="Time (minutes)", row=1, col=2) + fig.update_yaxes(title_text="Heart Rate (bpm)", row=1, col=2) + fig.update_xaxes(title_text="Time (minutes)", row=2, col=1) + fig.update_yaxes(title_text="Speed (km/h)", row=2, col=1) + fig.update_xaxes(title_text="Time (minutes)", row=2, col=2) + fig.update_yaxes(title_text="Elevation (m)", row=2, col=2) + fig.update_xaxes(title_text="Power (W)", row=3, col=1) + fig.update_xaxes(title_text="Heart Rate (bpm)", row=3, col=2) + + filepath = self.output_dir / 'workout_dashboard.html' + fig.write_html(str(filepath)) + + return str(filepath) + +================================================ +FILE: visualizers/report_generator.py +================================================ +"""Report generator for creating comprehensive workout reports.""" + +import logging +from pathlib import Path +from typing import Dict, Any, List, Optional +from datetime import datetime +import jinja2 +import pandas as pd +from markdown import markdown +from weasyprint import HTML, CSS +import json + +from models.workout import WorkoutData + +logger = logging.getLogger(__name__) + + +class ReportGenerator: + """Generate comprehensive workout reports in various formats.""" + + def __init__(self, template_dir: Path = None): + """Initialize report generator. + + Args: + template_dir: Directory containing report templates + """ + self.template_dir = template_dir or Path(__file__).parent / 'templates' + self.template_dir.mkdir(exist_ok=True) + + # Initialize Jinja2 environment + self.jinja_env = jinja2.Environment( + loader=jinja2.FileSystemLoader(self.template_dir), + autoescape=jinja2.select_autoescape(['html', 'xml']) + ) + + # Add custom filters + self.jinja_env.filters['format_duration'] = self._format_duration + self.jinja_env.filters['format_distance'] = self._format_distance + self.jinja_env.filters['format_speed'] = self._format_speed + self.jinja_env.filters['format_power'] = self._format_power + self.jinja_env.filters['format_heart_rate'] = self._format_heart_rate + + def generate_workout_report(self, workout: WorkoutData, analysis: Dict[str, Any], + format: str = 'html') -> str: + """Generate comprehensive workout report. + + Args: + workout: WorkoutData object + analysis: Analysis results from WorkoutAnalyzer + format: Report format ('html', 'pdf', 'markdown') + + Returns: + Rendered report content as a string (for html/markdown) or path to PDF file. + """ + # Prepare report data + report_data = self._prepare_report_data(workout, analysis) + + # Generate report based on format + if format == 'html': + return self._generate_html_report(report_data) + elif format == 'pdf': + return self._generate_pdf_report(report_data, workout.metadata.activity_name) + elif format == 'markdown': + return self._generate_markdown_report(report_data) + else: + raise ValueError(f"Unsupported format: {format}") + + def _prepare_report_data(self, workout: WorkoutData, analysis: Dict[str, Any]) -> Dict[str, Any]: + """Prepare data for report generation. + + Args: + workout: WorkoutData object + analysis: Analysis results + + Returns: + Dictionary with report data + """ + # Normalize and alias data for template compatibility + summary = analysis.get('summary', {}) + summary['avg_speed'] = summary.get('avg_speed_kmh') + summary['avg_heart_rate'] = summary.get('avg_hr') + + power_analysis = analysis.get('power_analysis', {}) + if 'avg_power' not in power_analysis and 'avg_power' in summary: + power_analysis['avg_power'] = summary['avg_power'] + if 'max_power' not in power_analysis and 'max_power' in summary: + power_analysis['max_power'] = summary['max_power'] + + heart_rate_analysis = analysis.get('heart_rate_analysis', {}) + if 'avg_hr' not in heart_rate_analysis and 'avg_hr' in summary: + heart_rate_analysis['avg_hr'] = summary['avg_hr'] + if 'max_hr' not in heart_rate_analysis and 'max_hr' in summary: + heart_rate_analysis['max_hr'] = summary['max_hr'] + # For templates using avg_heart_rate + heart_rate_analysis['avg_heart_rate'] = heart_rate_analysis.get('avg_hr') + heart_rate_analysis['max_heart_rate'] = heart_rate_analysis.get('max_hr') + + + speed_analysis = analysis.get('speed_analysis', {}) + speed_analysis['avg_speed'] = speed_analysis.get('avg_speed_kmh') + speed_analysis['max_speed'] = speed_analysis.get('max_speed_kmh') + + + report_context = { + "workout": { + "metadata": workout.metadata, + "summary": summary, + "power_analysis": power_analysis, + "heart_rate_analysis": heart_rate_analysis, + "speed_analysis": speed_analysis, + "elevation_analysis": analysis.get("elevation_analysis", {}), + "intervals": analysis.get("intervals", []), + "zones": analysis.get("zones", {}), + "efficiency": analysis.get("efficiency", {}), + }, + "report": { + "generated_at": datetime.now().isoformat(), + "version": "1.0.0", + "tool": "Garmin Analyser", + }, + } + + # Add minute-by-minute aggregation if data is available + if workout.df is not None and not workout.df.empty: + report_context["minute_by_minute"] = self._aggregate_minute_by_minute( + workout.df, analysis + ) + return report_context + + def _generate_html_report(self, report_data: Dict[str, Any]) -> str: + """Generate HTML report. + + Args: + report_data: Report data + + Returns: + Rendered HTML content as a string. + """ + template = self.jinja_env.get_template('workout_report.html') + html_content = template.render(**report_data) + + # In a real application, you might save this to a file or return it directly + # For testing, we return the content directly + return html_content + + def _generate_pdf_report(self, report_data: Dict[str, Any], activity_name: str) -> str: + """Generate PDF report. + + Args: + report_data: Report data + activity_name: Name of the activity for the filename. + + Returns: + Path to generated PDF report. + """ + html_content = self._generate_html_report(report_data) + + output_dir = Path('reports') + output_dir.mkdir(exist_ok=True) + + # Sanitize activity_name for filename + sanitized_activity_name = "".join( + [c if c.isalnum() or c in (' ', '-', '_') else '_' for c in activity_name] + ).replace(' ', '_') + + pdf_path = output_dir / f"{sanitized_activity_name}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf" + + HTML(string=html_content).write_pdf(str(pdf_path)) + + return str(pdf_path) + + def _generate_markdown_report(self, report_data: Dict[str, Any]) -> str: + """Generate Markdown report. + + Args: + report_data: Report data + + Returns: + Rendered Markdown content as a string. + """ + template = self.jinja_env.get_template('workout_report.md') + markdown_content = template.render(**report_data) + + # In a real application, you might save this to a file or return it directly + # For testing, we return the content directly + return markdown_content + + def generate_summary_report(self, workouts: List[WorkoutData], + analyses: List[Dict[str, Any]], + format: str = 'html') -> str: + """Generate summary report for multiple workouts. + + Args: + workouts: List of WorkoutData objects + analyses: List of analysis results + format: Report format ('html', 'pdf', 'markdown') + + Returns: + Rendered summary report content as a string (for html/markdown) or path to PDF file. + """ + # Aggregate data + summary_data = self._aggregate_workout_data(workouts, analyses) + + # Generate report based on format + if format == 'html': + template = self.jinja_env.get_template("summary_report.html") + return template.render(**summary_data) + elif format == 'pdf': + html_content = self._generate_summary_html_report(summary_data) + output_dir = Path('reports') + output_dir.mkdir(exist_ok=True) + pdf_path = output_dir / f"summary_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf" + HTML(string=html_content).write_pdf(str(pdf_path)) + return str(pdf_path) + elif format == 'markdown': + template = self.jinja_env.get_template('summary_report.md') + return template.render(**summary_data) + else: + raise ValueError(f"Unsupported format: {format}") + + def _generate_summary_html_report(self, report_data: Dict[str, Any]) -> str: + """Helper to generate HTML for summary report, used by PDF generation.""" + template = self.jinja_env.get_template('summary_report.html') + return template.render(**report_data) + + def _aggregate_workout_data(self, workouts: List[WorkoutData], + analyses: List[Dict[str, Any]]) -> Dict[str, Any]: + """Aggregate data from multiple workouts. + + Args: + workouts: List of WorkoutData objects + analyses: List of analysis results + + Returns: + Dictionary with aggregated data + """ + # Create DataFrame for analysis + workout_data = [] + + for workout, analysis in zip(workouts, analyses): + data = { + 'date': workout.metadata.start_time, + 'activity_type': workout.metadata.sport or workout.metadata.activity_type, + 'duration_minutes': analysis.get('summary', {}).get('duration_minutes', 0), + 'distance_km': analysis.get('summary', {}).get('distance_km', 0), + 'avg_power': analysis.get('summary', {}).get('avg_power', 0), + 'avg_heart_rate': analysis.get('summary', {}).get('avg_hr', 0), + 'avg_speed': analysis.get('summary', {}).get('avg_speed_kmh', 0), + 'elevation_gain': analysis.get('summary', {}).get('elevation_gain_m', 0), + 'calories': analysis.get('summary', {}).get('calories', 0), + 'tss': analysis.get('summary', {}).get('training_stress_score', 0) + } + workout_data.append(data) + + df = pd.DataFrame(workout_data) + + # Calculate aggregations + aggregations = { + 'total_workouts': len(workouts), + 'total_duration_hours': df['duration_minutes'].sum() / 60, + 'total_distance_km': df['distance_km'].sum(), + 'total_elevation_m': df['elevation_gain'].sum(), + 'total_calories': df['calories'].sum(), + 'avg_workout_duration': df['duration_minutes'].mean(), + 'avg_power': df['avg_power'].mean(), + 'avg_heart_rate': df['avg_heart_rate'].mean(), + 'avg_speed': df['avg_speed'].mean(), + 'total_tss': df['tss'].sum(), + 'weekly_tss': df['tss'].sum() / 4, # Assuming 4 weeks + 'workouts_by_type': df['activity_type'].value_counts().to_dict(), + 'weekly_volume': df.groupby(pd.Grouper(key='date', freq='W'))['duration_minutes'].sum().to_dict() + } + + return { + 'workouts': workouts, + 'analyses': analyses, + 'aggregations': aggregations, + 'report': { + 'generated_at': datetime.now().isoformat(), + 'version': '1.0.0', + 'tool': 'Garmin Analyser' + } + } + + def _aggregate_minute_by_minute( + self, df: pd.DataFrame, analysis: Dict[str, Any] + ) -> List[Dict[str, Any]]: + """Aggregate workout data into minute-by-minute summaries. + + Args: + df: Workout DataFrame. + analysis: Analysis results. + + Returns: + A list of dictionaries, each representing one minute of the workout. + """ + if "timestamp" not in df.columns: + return [] + + df = df.copy() + df["elapsed_time"] = ( + df["timestamp"] - df["timestamp"].iloc[0] + ).dt.total_seconds() + df["minute_index"] = (df["elapsed_time"] // 60).astype(int) + + agg_rules = {} + if "speed" in df.columns: + agg_rules["avg_speed_kmh"] = ("speed", "mean") + if "cadence" in df.columns: + agg_rules["avg_cadence"] = ("cadence", "mean") + if "heart_rate" in df.columns: + agg_rules["avg_hr"] = ("heart_rate", "mean") + agg_rules["max_hr"] = ("heart_rate", "max") + if "power" in df.columns: + agg_rules["avg_real_power"] = ("power", "mean") + elif "estimated_power" in df.columns: + agg_rules["avg_power_estimate"] = ("estimated_power", "mean") + + if not agg_rules: + return [] + + minute_stats = df.groupby("minute_index").agg(**agg_rules).reset_index() + + # Distance and elevation require special handling + if "distance" in df.columns: + minute_stats["distance_km"] = ( + df.groupby("minute_index")["distance"] + .apply(lambda x: (x.max() - x.min()) / 1000.0) + .values + ) + if "altitude" in df.columns: + minute_stats["elevation_change"] = ( + df.groupby("minute_index")["altitude"] + .apply(lambda x: x.iloc[-1] - x.iloc[0] if not x.empty else 0) + .values + ) + if "gradient" in df.columns: + minute_stats["avg_gradient"] = ( + df.groupby("minute_index")["gradient"].mean().values + ) + + # Convert to km/h if speed is in m/s + if "avg_speed_kmh" in minute_stats.columns: + minute_stats["avg_speed_kmh"] *= 3.6 + + # Round and format + for col in minute_stats.columns: + if minute_stats[col].dtype == "float64": + minute_stats[col] = minute_stats[col].round(2) + + return minute_stats.to_dict("records") + + def _format_duration(self, seconds: float) -> str: + """Format duration in seconds to human-readable format. + + Args: + seconds: Duration in seconds + + Returns: + Formatted duration string + """ + if pd.isna(seconds): + return "" + hours = int(seconds // 3600) + minutes = int((seconds % 3600) // 60) + seconds = int(seconds % 60) + + if hours > 0: + return f"{hours}h {minutes}m {seconds}s" + elif minutes > 0: + return f"{minutes}m {seconds}s" + else: + return f"{seconds}s" + + def _format_distance(self, meters: float) -> str: + """Format distance in meters to human-readable format. + + Args: + meters: Distance in meters + + Returns: + Formatted distance string + """ + if meters >= 1000: + return f"{meters/1000:.2f} km" + else: + return f"{meters:.0f} m" + + def _format_speed(self, kmh: float) -> str: + """Format speed in km/h to human-readable format. + + Args: + kmh: Speed in km/h + + Returns: + Formatted speed string + """ + return f"{kmh:.1f} km/h" + + def _format_power(self, watts: float) -> str: + """Format power in watts to human-readable format. + + Args: + watts: Power in watts + + Returns: + Formatted power string + """ + return f"{watts:.0f} W" + + def _format_heart_rate(self, bpm: float) -> str: + """Format heart rate in bpm to human-readable format. + + Args: + bpm: Heart rate in bpm + + Returns: + Formatted heart rate string + """ + return f"{bpm:.0f} bpm" + + def create_report_templates(self): + """Create default report templates.""" + self.template_dir.mkdir(exist_ok=True) + + # HTML template + html_template = """ + + + + +
+
+
+
+
+
+
+
+
+
+ {% if minute_by_minute %}
+
+
+
+ {% endif %}
+
+
+
+
+"""
+
+ with open(self.template_dir / 'workout_report.html', 'w') as f:
+ f.write(html_template)
+
+ # Markdown template
+ md_template = """# Workout Report: {{ workout.metadata.activity_name }}
+
+**Date:** {{ workout.metadata.start_time }}
+**Activity Type:** {{ workout.metadata.activity_type }}
+
+## Summary
+
+| Metric | Value |
+|--------|--------|
+| Duration | {{ workout.summary.duration_minutes|format_duration }} |
+| Distance | {{ workout.summary.distance_km|format_distance }} |
+| Average Power | {{ workout.summary.avg_power|format_power }} |
+| Average Heart Rate | {{ workout.summary.avg_heart_rate|format_heart_rate }} |
+| Average Speed | {{ workout.summary.avg_speed_kmh|format_speed }} |
+| Calories | {{ workout.summary.calories|int }} |
+
+## Detailed Analysis
+
+### Power Analysis
+
+- **Average Power:** {{ workout.power_analysis.avg_power|format_power }}
+- **Maximum Power:** {{ workout.power_analysis.max_power|format_power }}
+- **Normalized Power:** {{ workout.summary.normalized_power|format_power }}
+- **Intensity Factor:** {{ "%.2f"|format(workout.summary.intensity_factor) }}
+
+### Heart Rate Analysis
+
+- **Average Heart Rate:** {{ workout.heart_rate_analysis.avg_heart_rate|format_heart_rate }}
+- **Maximum Heart Rate:** {{ workout.heart_rate_analysis.max_heart_rate|format_heart_rate }}
+
+### Speed Analysis
+
+- **Average Speed:** {{ workout.speed_analysis.avg_speed|format_speed }}
+- **Maximum Speed:** {{ workout.speed_analysis.max_speed|format_speed }}
+
+{% if minute_by_minute %}
+### Minute-by-Minute Analysis
+
+| Minute | Dist (km) | Speed (km/h) | Cadence | HR | Max HR | Grad (%) | Elev (m) | Power (W) |
+|--------|-----------|--------------|---------|----|--------|----------|----------|-----------|
+{% for row in minute_by_minute -%}
+| {{ row.minute_index }} | {{ "%.2f"|format(row.distance_km) if row.distance_km is not none }} | {{ "%.1f"|format(row.avg_speed_kmh) if row.avg_speed_kmh is not none }} | {{ "%.0f"|format(row.avg_cadence) if row.avg_cadence is not none }} | {{ "%.0f"|format(row.avg_hr) if row.avg_hr is not none }} | {{ "%.0f"|format(row.max_hr) if row.max_hr is not none }} | {{ "%.1f"|format(row.avg_gradient) if row.avg_gradient is not none }} | {{ "%.1f"|format(row.elevation_change) if row.elevation_change is not none }} | {{ "%.0f"|format(row.avg_real_power or row.avg_power_estimate) if (row.avg_real_power or row.avg_power_estimate) is not none }} |
+{% endfor %}
+{% endif %}
+
+---
+
+*Report generated on {{ report.generated_at }} using {{ report.tool }} v{{ report.version }}*"""
+
+ with open(self.template_dir / 'workout_report.md', 'w') as f:
+ f.write(md_template)
+
+ logger.info("Report templates created successfully")
+
+================================================
+FILE: visualizers/templates/summary_report.html
+================================================
+
+
+
+
+
+ Workout Report: {{ workout.metadata.activity_name }}
+Date: {{ workout.metadata.start_time }}
+Activity Type: {{ workout.metadata.activity_type }}
+ +Summary
+
+
+
+
+
+ Duration
+{{ workout.summary.duration_minutes|format_duration }}
+
+
+ Distance
+{{ workout.summary.distance_km|format_distance }}
+
+
+ Avg Power
+{{ workout.summary.avg_power|format_power }}
+
+
+ Avg Heart Rate
+{{ workout.summary.avg_heart_rate|format_heart_rate }}
+
+
+ Avg Speed
+{{ workout.summary.avg_speed_kmh|format_speed }}
+
+
+ Calories
+{{ workout.summary.calories|int }}
+ Detailed Analysis
+ +Power Analysis
+| Metric | +Value | +
|---|---|
| Average Power | +{{ workout.power_analysis.avg_power|format_power }} | +
| Maximum Power | +{{ workout.power_analysis.max_power|format_power }} | +
| Normalized Power | +{{ workout.summary.normalized_power|format_power }} | +
| Intensity Factor | +{{ "%.2f"|format(workout.summary.intensity_factor) }} | +
Heart Rate Analysis
+| Metric | +Value | +
|---|---|
| Average Heart Rate | +{{ workout.heart_rate_analysis.avg_heart_rate|format_heart_rate }} | +
| Maximum Heart Rate | +{{ workout.heart_rate_analysis.max_heart_rate|format_heart_rate }} | +
Speed Analysis
+| Metric | +Value | +
|---|---|
| Average Speed | +{{ workout.speed_analysis.avg_speed|format_speed }} | +
| Maximum Speed | +{{ workout.speed_analysis.max_speed|format_speed }} | +
Minute-by-Minute Analysis
+| Minute | +Distance (km) | +Avg Speed (km/h) | +Avg Cadence | +Avg HR | +Max HR | +Avg Gradient (%) | +Elevation Change (m) | +Avg Power (W) | +
|---|---|---|---|---|---|---|---|---|
| {{ row.minute_index }} | +{{ "%.2f"|format(row.distance_km) if row.distance_km is not none }} | +{{ "%.1f"|format(row.avg_speed_kmh) if row.avg_speed_kmh is not none }} | +{{ "%.0f"|format(row.avg_cadence) if row.avg_cadence is not none }} | +{{ "%.0f"|format(row.avg_hr) if row.avg_hr is not none }} | +{{ "%.0f"|format(row.max_hr) if row.max_hr is not none }} | +{{ "%.1f"|format(row.avg_gradient) if row.avg_gradient is not none }} | +{{ "%.1f"|format(row.elevation_change) if row.elevation_change is not none }} | +{{ "%.0f"|format(row.avg_real_power or row.avg_power_estimate) if (row.avg_real_power or row.avg_power_estimate) is not none }} | +
+
+
+
+
+
+
+
+
+
+================================================
+FILE: visualizers/templates/workout_report.html
+================================================
+
+
+
+
+
+ Workout Summary Report
+ +All Workouts
+| Date | +Sport | +Duration | +Distance (km) | +Avg Speed (km/h) | +Avg HR | +NP | +IF | +TSS | +
|---|---|---|---|---|---|---|---|---|
| {{ analysis.summary.start_time.strftime('%Y-%m-%d') if analysis.summary.start_time else 'N/A' }} | +{{ analysis.summary.sport if analysis.summary.sport else 'N/A' }} | +{{ analysis.summary.duration_minutes|format_duration if analysis.summary.duration_minutes else 'N/A' }} | +{{ "%.2f"|format(analysis.summary.distance_km) if analysis.summary.distance_km else 'N/A' }} | +{{ "%.1f"|format(analysis.summary.avg_speed_kmh) if analysis.summary.avg_speed_kmh else 'N/A' }} | +{{ "%.0f"|format(analysis.summary.avg_hr) if analysis.summary.avg_hr else 'N/A' }} | +{{ "%.0f"|format(analysis.summary.normalized_power) if analysis.summary.normalized_power else 'N/A' }} | +{{ "%.2f"|format(analysis.summary.intensity_factor) if analysis.summary.intensity_factor else 'N/A' }} | +{{ "%.1f"|format(analysis.summary.training_stress_score) if analysis.summary.training_stress_score else 'N/A' }} | +
+
+
+
+
+
+
+
+
+
+ {% if minute_by_minute %}
+
+
+
+ {% endif %}
+
+
+
+
+
+
+================================================
+FILE: visualizers/templates/workout_report.md
+================================================
+# Workout Report: {{ workout.metadata.activity_name }}
+
+**Date:** {{ workout.metadata.start_time }}
+**Activity Type:** {{ workout.metadata.activity_type }}
+
+## Summary
+
+| Metric | Value |
+|--------|--------|
+| Duration | {{ workout.summary.duration_minutes|format_duration }} |
+| Distance | {{ workout.summary.distance_km|format_distance }} |
+| Average Power | {{ workout.summary.avg_power|format_power }} |
+| Average Heart Rate | {{ workout.summary.avg_heart_rate|format_heart_rate }} |
+| Average Speed | {{ workout.summary.avg_speed_kmh|format_speed }} |
+| Calories | {{ workout.summary.calories|int }} |
+
+## Detailed Analysis
+
+### Power Analysis
+
+- **Average Power:** {{ workout.power_analysis.avg_power|format_power }}
+- **Maximum Power:** {{ workout.power_analysis.max_power|format_power }}
+- **Normalized Power:** {{ workout.summary.normalized_power|format_power }}
+- **Intensity Factor:** {{ "%.2f"|format(workout.summary.intensity_factor) }}
+
+### Heart Rate Analysis
+
+- **Average Heart Rate:** {{ workout.heart_rate_analysis.avg_heart_rate|format_heart_rate }}
+- **Maximum Heart Rate:** {{ workout.heart_rate_analysis.max_heart_rate|format_heart_rate }}
+
+### Speed Analysis
+
+- **Average Speed:** {{ workout.speed_analysis.avg_speed|format_speed }}
+- **Maximum Speed:** {{ workout.speed_analysis.max_speed|format_speed }}
+
+{% if minute_by_minute %}
+### Minute-by-Minute Analysis
+
+| Minute | Dist (km) | Speed (km/h) | Cadence | HR | Max HR | Grad (%) | Elev (m) | Power (W) |
+|--------|-----------|--------------|---------|----|--------|----------|----------|-----------|
+{% for row in minute_by_minute -%}
+| {{ row.minute_index }} | {{ "%.2f"|format(row.distance_km) if row.distance_km is not none }} | {{ "%.1f"|format(row.avg_speed_kmh) if row.avg_speed_kmh is not none }} | {{ "%.0f"|format(row.avg_cadence) if row.avg_cadence is not none }} | {{ "%.0f"|format(row.avg_hr) if row.avg_hr is not none }} | {{ "%.0f"|format(row.max_hr) if row.max_hr is not none }} | {{ "%.1f"|format(row.avg_gradient) if row.avg_gradient is not none }} | {{ "%.1f"|format(row.elevation_change) if row.elevation_change is not none }} | {{ "%.0f"|format(row.avg_real_power or row.avg_power_estimate) if (row.avg_real_power or row.avg_power_estimate) is not none }} |
+{% endfor %}
+{% endif %}
+
+---
+
+*Report generated on {{ report.generated_at }} using {{ report.tool }} v{{ report.version }}*
\ No newline at end of file
diff --git a/git_scape_garth_digest (1).txt b/git_scape_garth_digest (1).txt
new file mode 100644
index 0000000..1ccd115
--- /dev/null
+++ b/git_scape_garth_digest (1).txt
@@ -0,0 +1,4741 @@
+Repository: https://github.com/matin/garth
+Files analyzed: 47
+
+Directory structure:
+└── matin-garth/
+ ├── .devcontainer
+ │ ├── Dockerfile
+ │ └── noop.txt
+ ├── .github
+ │ ├── workflows
+ │ │ ├── ci.yml
+ │ │ └── publish.yml
+ │ └── dependabot.yml
+ ├── colabs
+ │ ├── chatgpt_analysis_of_stats.ipynb
+ │ ├── sleep.ipynb
+ │ └── stress.ipynb
+ ├── src
+ │ └── garth
+ │ ├── data
+ │ │ ├── body_battery
+ │ │ │ ├── __init__.py
+ │ │ │ ├── daily_stress.py
+ │ │ │ ├── events.py
+ │ │ │ └── readings.py
+ │ │ ├── __init__.py
+ │ │ ├── _base.py
+ │ │ ├── hrv.py
+ │ │ ├── sleep.py
+ │ │ └── weight.py
+ │ ├── stats
+ │ │ ├── __init__.py
+ │ │ ├── _base.py
+ │ │ ├── hrv.py
+ │ │ ├── hydration.py
+ │ │ ├── intensity_minutes.py
+ │ │ ├── sleep.py
+ │ │ ├── steps.py
+ │ │ └── stress.py
+ │ ├── users
+ │ │ ├── __init__.py
+ │ │ ├── profile.py
+ │ │ └── settings.py
+ │ ├── __init__.py
+ │ ├── auth_tokens.py
+ │ ├── cli.py
+ │ ├── exc.py
+ │ ├── http.py
+ │ ├── py.typed
+ │ ├── sso.py
+ │ ├── utils.py
+ │ └── version.py
+ ├── tests
+ │ ├── cassettes
+ │ ├── data
+ │ │ ├── cassettes
+ │ │ ├── test_body_battery_data.py
+ │ │ ├── test_hrv_data.py
+ │ │ ├── test_sleep_data.py
+ │ │ └── test_weight_data.py
+ │ ├── stats
+ │ │ ├── cassettes
+ │ │ ├── test_hrv.py
+ │ │ ├── test_hydration.py
+ │ │ ├── test_intensity_minutes.py
+ │ │ ├── test_sleep_stats.py
+ │ │ ├── test_steps.py
+ │ │ └── test_stress.py
+ │ ├── 12129115726_ACTIVITY.fit
+ │ ├── conftest.py
+ │ ├── test_auth_tokens.py
+ │ ├── test_cli.py
+ │ ├── test_http.py
+ │ ├── test_sso.py
+ │ ├── test_users.py
+ │ └── test_utils.py
+ ├── .gitattributes
+ ├── .gitignore
+ ├── LICENSE
+ ├── Makefile
+ ├── pyproject.toml
+ └── README.md
+
+
+================================================
+FILE: README.md
+================================================
+# Garth
+
+[](
+ https://github.com/matin/garth/actions/workflows/ci.yml?query=event%3Apush+branch%3Amain+workflow%3ACI)
+[](
+ https://codecov.io/gh/matin/garth)
+[](
+ https://pypi.org/project/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.
+
+
+
+### [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.
+
+
+
+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.
+
+
+
+### [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?
+
+Workout Report: {{ workout.metadata.activity_name }}
+Date: {{ workout.metadata.start_time }}
+Activity Type: {{ workout.metadata.activity_type }}
+ +Summary
+
+
+
+
+
+ Duration
+{{ workout.summary.duration_minutes|format_duration }}
+
+
+ Distance
+{{ workout.summary.distance_km|format_distance }}
+
+
+ Avg Power
+{{ workout.summary.avg_power|format_power }}
+
+
+ Avg Heart Rate
+{{ workout.summary.avg_heart_rate|format_heart_rate }}
+
+
+ Avg Speed
+{{ workout.summary.avg_speed_kmh|format_speed }}
+
+
+ Calories
+{{ workout.summary.calories|int }}
+ Detailed Analysis
+ +Power Analysis
+| Metric | +Value | +
|---|---|
| Average Power | +{{ workout.power_analysis.avg_power|format_power }} | +
| Maximum Power | +{{ workout.power_analysis.max_power|format_power }} | +
| Normalized Power | +{{ workout.summary.normalized_power|format_power }} | +
| Intensity Factor | +{{ "%.2f"|format(workout.summary.intensity_factor) }} | +
Heart Rate Analysis
+| Metric | +Value | +
|---|---|
| Average Heart Rate | +{{ workout.heart_rate_analysis.avg_heart_rate|format_heart_rate }} | +
| Maximum Heart Rate | +{{ workout.heart_rate_analysis.max_heart_rate|format_heart_rate }} | +
Speed Analysis
+| Metric | +Value | +
|---|---|
| Average Speed | +{{ workout.speed_analysis.avg_speed|format_speed }} | +
| Maximum Speed | +{{ workout.speed_analysis.max_speed|format_speed }} | +
Minute-by-Minute Analysis
+| Minute | +Distance (km) | +Avg Speed (km/h) | +Avg Cadence | +Avg HR | +Max HR | +Avg Gradient (%) | +Elevation Change (m) | +Avg Power (W) | +
|---|---|---|---|---|---|---|---|---|
| {{ row.minute_index }} | +{{ "%.2f"|format(row.distance_km) if row.distance_km is not none }} | +{{ "%.1f"|format(row.avg_speed_kmh) if row.avg_speed_kmh is not none }} | +{{ "%.0f"|format(row.avg_cadence) if row.avg_cadence is not none }} | +{{ "%.0f"|format(row.avg_hr) if row.avg_hr is not none }} | +{{ "%.0f"|format(row.max_hr) if row.max_hr is not none }} | +{{ "%.1f"|format(row.avg_gradient) if row.avg_gradient is not none }} | +{{ "%.1f"|format(row.elevation_change) if row.elevation_change is not none }} | +{{ "%.0f"|format(row.avg_real_power or row.avg_power_estimate) if (row.avg_real_power or row.avg_power_estimate) is not none }} | +
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
+ + + """ + assert sso.get_title(html) == "Success" + + +def test_get_title_fail(): + html = """ + + + + +Success
+ + + """ + with pytest.raises(GarthException): + sso.get_title(html) + + +================================================ +FILE: tests/test_users.py +================================================ +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") + + +================================================ +FILE: tests/test_utils.py +================================================ +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/git_scape_python_garminconnect_digest (1).txt b/git_scape_python_garminconnect_digest (1).txt new file mode 100644 index 0000000..7c344ea --- /dev/null +++ b/git_scape_python_garminconnect_digest (1).txt @@ -0,0 +1,31241 @@ +Repository: https://github.com/cyberjunky/python-garminconnect +Files analyzed: 8 + +Directory structure: +└── cyberjunky-python-garminconnect/ + ├── .github + │ ├── workflows + │ │ └── ci.yml + │ ├── dependabot.yml + │ └── FUNDING.yml + ├── docs + │ ├── graphql_queries.txt + │ └── reference.ipynb + ├── garminconnect + │ ├── __init__.py + │ └── fit.py + ├── test_data + │ └── sample_activity.gpx + ├── tests + │ ├── cassettes + │ ├── 12129115726_ACTIVITY.fit + │ ├── conftest.py + │ └── test_garmin.py + ├── .editorconfig + ├── .gitignore + ├── demo.py + ├── example.py + ├── LICENSE + ├── pyproject.toml + └── README.md + + +================================================ +FILE: README.md +================================================ +# Python: Garmin Connect + +The Garmin Connect API library comes with two examples: + +- **`example.py`** - Simple getting-started example showing authentication, token storage, and basic API calls +- **`demo.py`** - Comprehensive demo providing access to **100+ API methods** organized into **11 categories** for easy navigation + +Note: The demo menu is generated dynamically; exact options may change between releases. + +```bash +$ ./demo.py +🏃♂️ Full-blown Garmin Connect API Demo - Main Menu +================================================== +Select a category: + + [1] 👤 User & Profile + [2] 📊 Daily Health & Activity + [3] 🔬 Advanced Health Metrics + [4] 📈 Historical Data & Trends + [5] 🏃 Activities & Workouts + [6] ⚖️ Body Composition & Weight + [7] 🏆 Goals & Achievements + [8] ⌚ Device & Technical + [9] 🎽 Gear & Equipment + [0] 💧 Hydration & Wellness + [a] 🔧 System & Export + + [q] Exit program + +Make your selection: +``` + +## API Coverage Statistics + +- **Total API Methods**: 100+ unique endpoints (snapshot) +- **Categories**: 11 organized sections +- **User & Profile**: 4 methods (basic user info, settings) +- **Daily Health & Activity**: 8 methods (today's health data) +- **Advanced Health Metrics**: 10 methods (fitness metrics, HRV, VO2) +- **Historical Data & Trends**: 6 methods (date range queries) +- **Activities & Workouts**: 20 methods (comprehensive activity management) +- **Body Composition & Weight**: 8 methods (weight tracking, body composition) +- **Goals & Achievements**: 15 methods (challenges, badges, goals) +- **Device & Technical**: 7 methods (device info, settings) +- **Gear & Equipment**: 6 methods (gear management, tracking) +- **Hydration & Wellness**: 9 methods (hydration, blood pressure, menstrual) +- **System & Export**: 4 methods (reporting, logout, GraphQL) + +### Interactive Features + +- **Enhanced User Experience**: Categorized navigation with emoji indicators +- **Smart Data Management**: Interactive weigh-in deletion with search capabilities +- **Comprehensive Coverage**: All major Garmin Connect features are accessible +- **Error Handling**: Robust error handling with user-friendly prompts +- **Data Export**: JSON export functionality for all data types + +[](https://www.paypal.me/cyberjunkynl/) +[](https://github.com/sponsors/cyberjunky) + +A comprehensive Python3 API wrapper for Garmin Connect, providing access to health, fitness, and device data. + +## 📖 About + +This library enables developers to programmatically access Garmin Connect data including: + +- **Health Metrics**: Heart rate, sleep, stress, body composition, SpO2, HRV +- **Activity Data**: Workouts, exercises, training status, performance metrics +- **Device Information**: Connected devices, settings, alarms, solar data +- **Goals & Achievements**: Personal records, badges, challenges, race predictions +- **Historical Data**: Trends, progress tracking, date range queries + +Compatible with all Garmin Connect accounts. See
+
+
+
+"""
+
+ # Save HTML file
+ html_filepath = config.export_dir / html_filename
+ with open(html_filepath, "w", encoding="utf-8") as f:
+ f.write(html_content)
+
+ return str(html_filepath)
+
+
+def safe_api_call(api_method, *args, method_name: str = None, **kwargs):
+ """
+ Centralized API call wrapper with comprehensive error handling.
+
+ This function provides unified error handling for all Garmin Connect API calls.
+ It handles common HTTP errors (400, 401, 403, 404, 429, 500, 503) with
+ user-friendly messages and provides consistent error reporting.
+
+ Usage:
+ success, result, error_msg = safe_api_call(api.get_user_summary)
+
+ Args:
+ api_method: The API method to call
+ *args: Positional arguments for the API method
+ method_name: Human-readable name for the API method (optional)
+ **kwargs: Keyword arguments for the API method
+
+ Returns:
+ tuple: (success: bool, result: Any, error_message: str|None)
+ """
+ if method_name is None:
+ method_name = getattr(api_method, "__name__", str(api_method))
+
+ try:
+ result = api_method(*args, **kwargs)
+ return True, result, None
+
+ except GarthHTTPError as e:
+ # Handle specific HTTP errors more gracefully
+ error_str = str(e)
+
+ # Extract status code more reliably
+ status_code = None
+ if hasattr(e, "response") and hasattr(e.response, "status_code"):
+ status_code = e.response.status_code
+
+ # Handle specific status codes
+ if status_code == 400 or ("400" in error_str and "Bad Request" in error_str):
+ error_msg = "Endpoint not available (400 Bad Request) - This feature may not be enabled for your account or region"
+ # Don't print for 400 errors as they're often expected for unavailable features
+ elif status_code == 401 or "401" in error_str:
+ error_msg = (
+ "Authentication required (401 Unauthorized) - Please re-authenticate"
+ )
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ elif status_code == 403 or "403" in error_str:
+ error_msg = "Access denied (403 Forbidden) - Your account may not have permission for this feature"
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ elif status_code == 404 or "404" in error_str:
+ error_msg = (
+ "Endpoint not found (404) - This feature may have been moved or removed"
+ )
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ elif status_code == 429 or "429" in error_str:
+ error_msg = (
+ "Rate limit exceeded (429) - Please wait before making more requests"
+ )
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ elif status_code == 500 or "500" in error_str:
+ error_msg = "Server error (500) - Garmin's servers are experiencing issues"
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ elif status_code == 503 or "503" in error_str:
+ error_msg = "Service unavailable (503) - Garmin's servers are temporarily unavailable"
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ else:
+ error_msg = f"HTTP error: {e}"
+
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ return False, None, error_msg
+
+ except GarminConnectAuthenticationError as e:
+ error_msg = f"Authentication issue: {e}"
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ return False, None, error_msg
+
+ except GarminConnectConnectionError as e:
+ error_msg = f"Connection issue: {e}"
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ return False, None, error_msg
+
+ except Exception as e:
+ error_msg = f"Unexpected error: {e}"
+ print(f"⚠️ {method_name} failed: {error_msg}")
+ return False, None, error_msg
+
+
+def call_and_display(
+ api_method=None,
+ *args,
+ method_name: str = None,
+ api_call_desc: str = None,
+ group_name: str = None,
+ api_responses: list = None,
+ **kwargs,
+):
+ """
+ Unified wrapper that calls API methods safely and displays results.
+ Can handle both single API calls and grouped API responses.
+
+ For single API calls:
+ call_and_display(api.get_user_summary, "2024-01-01")
+
+ For grouped responses:
+ call_and_display(group_name="User Data", api_responses=[("api.get_user", data)])
+
+ Args:
+ api_method: The API method to call (for single calls)
+ *args: Positional arguments for the API method
+ method_name: Human-readable name for the API method (optional)
+ api_call_desc: Description for display purposes (optional)
+ group_name: Name for grouped display (when displaying multiple responses)
+ api_responses: List of (api_call_desc, result) tuples for grouped display
+ **kwargs: Keyword arguments for the API method
+
+ Returns:
+ For single calls: tuple: (success: bool, result: Any)
+ For grouped calls: None
+ """
+ # Handle grouped display mode
+ if group_name is not None and api_responses is not None:
+ return _display_group(group_name, api_responses)
+
+ # Handle single API call mode
+ if api_method is None:
+ raise ValueError(
+ "Either api_method or (group_name + api_responses) must be provided"
+ )
+
+ if method_name is None:
+ method_name = getattr(api_method, "__name__", str(api_method))
+
+ if api_call_desc is None:
+ # Try to construct a reasonable description
+ args_str = ", ".join(str(arg) for arg in args)
+ kwargs_str = ", ".join(f"{k}={v}" for k, v in kwargs.items())
+ all_args = ", ".join(filter(None, [args_str, kwargs_str]))
+ api_call_desc = f"{method_name}({all_args})"
+
+ success, result, error_msg = safe_api_call(
+ api_method, *args, method_name=method_name, **kwargs
+ )
+
+ if success:
+ _display_single(api_call_desc, result)
+ return True, result
+ else:
+ # Display error in a consistent format
+ _display_single(f"{api_call_desc} [ERROR]", {"error": error_msg})
+ return False, None
+
+
+def _display_single(api_call: str, output: Any):
+ """Internal function to display single API response."""
+ print(f"\n📡 API Call: {api_call}")
+ print("-" * 50)
+
+ if output is None:
+ print("No data returned")
+ # Save empty JSON to response.json in the export directory
+ response_file = config.export_dir / "response.json"
+ with open(response_file, "w", encoding="utf-8") as f:
+ f.write(f"{'-' * 20} {api_call} {'-' * 20}\n{{}}\n{'-' * 77}\n")
+ return
+
+ try:
+ # Format the output
+ if isinstance(output, int | str | dict | list):
+ formatted_output = json.dumps(output, indent=2, default=str)
+ else:
+ formatted_output = str(output)
+
+ # Save to response.json in the export directory
+ response_content = (
+ f"{'-' * 20} {api_call} {'-' * 20}\n{formatted_output}\n{'-' * 77}\n"
+ )
+
+ response_file = config.export_dir / "response.json"
+ with open(response_file, "w", encoding="utf-8") as f:
+ f.write(response_content)
+
+ print(formatted_output)
+ print("-" * 77)
+
+ except Exception as e:
+ print(f"Error formatting output: {e}")
+ print(output)
+
+
+def _display_group(group_name: str, api_responses: list[tuple[str, Any]]):
+ """Internal function to display grouped API responses."""
+ print(f"\n📡 API Group: {group_name}")
+
+ # Collect all responses for saving
+ all_responses = {}
+ response_content_parts = []
+
+ for api_call, output in api_responses:
+ print(f"\n📋 {api_call}")
+ print("-" * 50)
+
+ if output is None:
+ print("No data returned")
+ formatted_output = "{}"
+ else:
+ try:
+ if isinstance(output, int | str | dict | list):
+ formatted_output = json.dumps(output, indent=2, default=str)
+ else:
+ formatted_output = str(output)
+ print(formatted_output)
+ except Exception as e:
+ print(f"Error formatting output: {e}")
+ formatted_output = str(output)
+ print(output)
+
+ # Store for grouped response file
+ all_responses[api_call] = output
+ response_content_parts.append(
+ f"{'-' * 20} {api_call} {'-' * 20}\n{formatted_output}"
+ )
+ print("-" * 50)
+
+ # Save grouped responses to file
+ try:
+ response_file = config.export_dir / "response.json"
+ grouped_content = f"""{'=' * 20} {group_name} {'=' * 20}
+{chr(10).join(response_content_parts)}
+{'=' * 77}
+"""
+ with open(response_file, "w", encoding="utf-8") as f:
+ f.write(grouped_content)
+
+ print(f"\n✅ Grouped responses saved to: {response_file}")
+ print("=" * 77)
+
+ except Exception as e:
+ print(f"Error saving grouped responses: {e}")
+
+
+# Legacy function aliases removed - all calls now use the unified call_and_display function
+
+
+def format_timedelta(td):
+ minutes, seconds = divmod(td.seconds + td.days * 86400, 60)
+ hours, minutes = divmod(minutes, 60)
+ return f"{hours:d}:{minutes:02d}:{seconds:02d}"
+
+
+def safe_call_for_group(
+ api_method, *args, method_name: str = None, api_call_desc: str = None, **kwargs
+):
+ """
+ Safe API call wrapper that returns result suitable for grouped display.
+
+ Args:
+ api_method: The API method to call
+ *args: Positional arguments for the API method
+ method_name: Human-readable name for the API method (optional)
+ api_call_desc: Description for display purposes (optional)
+ **kwargs: Keyword arguments for the API method
+
+ Returns:
+ tuple: (api_call_description: str, result: Any) - suitable for grouped display
+ """
+ if method_name is None:
+ method_name = getattr(api_method, "__name__", str(api_method))
+
+ if api_call_desc is None:
+ # Try to construct a reasonable description
+ args_str = ", ".join(str(arg) for arg in args)
+ kwargs_str = ", ".join(f"{k}={v}" for k, v in kwargs.items())
+ all_args = ", ".join(filter(None, [args_str, kwargs_str]))
+ api_call_desc = f"{method_name}({all_args})"
+
+ success, result, error_msg = safe_api_call(
+ api_method, *args, method_name=method_name, **kwargs
+ )
+
+ if success:
+ return api_call_desc, result
+ else:
+ return f"{api_call_desc} [ERROR]", {"error": error_msg}
+
+
+def get_solar_data(api: Garmin) -> None:
+ """Get solar data from all Garmin devices using centralized error handling."""
+ print("☀️ Getting solar data from devices...")
+
+ # Collect all API responses for grouped display
+ api_responses = []
+
+ # Get all devices using centralized wrapper
+ api_responses.append(
+ safe_call_for_group(
+ api.get_devices,
+ method_name="get_devices",
+ api_call_desc="api.get_devices()",
+ )
+ )
+
+ # Get device last used using centralized wrapper
+ api_responses.append(
+ safe_call_for_group(
+ api.get_device_last_used,
+ method_name="get_device_last_used",
+ api_call_desc="api.get_device_last_used()",
+ )
+ )
+
+ # Get the device list to process solar data
+ devices_success, devices, _ = safe_api_call(
+ api.get_devices, method_name="get_devices"
+ )
+
+ # Get solar data for each device
+ if devices_success and devices:
+ for device in devices:
+ device_id = device.get("deviceId")
+ if device_id:
+ device_name = device.get("displayName", f"Device {device_id}")
+ print(
+ f"\n☀️ Getting solar data for device: {device_name} (ID: {device_id})"
+ )
+
+ # Use centralized wrapper for each device's solar data
+ api_responses.append(
+ safe_call_for_group(
+ api.get_device_solar_data,
+ device_id,
+ config.today.isoformat(),
+ method_name="get_device_solar_data",
+ api_call_desc=f"api.get_device_solar_data({device_id}, '{config.today.isoformat()}')",
+ )
+ )
+ else:
+ print("ℹ️ No devices found or error retrieving devices")
+
+ # Display all responses as a group
+ call_and_display(group_name="Solar Data Collection", api_responses=api_responses)
+
+
+def upload_activity_file(api: Garmin) -> None:
+ """Upload activity data from file."""
+ try:
+ # Default activity file from config
+ print(f"📤 Uploading activity from file: {config.activityfile}")
+
+ # Check if file exists
+ import os
+
+ if not os.path.exists(config.activityfile):
+ print(f"❌ File not found: {config.activityfile}")
+ print(
+ "ℹ️ Please place your activity file (.fit, .gpx, or .tcx) under the 'test_data' directory or update config.activityfile"
+ )
+ print("ℹ️ Supported formats: FIT, GPX, TCX")
+ return
+
+ # Upload the activity
+ result = api.upload_activity(config.activityfile)
+
+ if result:
+ print("✅ Activity uploaded successfully!")
+ call_and_display(
+ api.upload_activity,
+ config.activityfile,
+ method_name="upload_activity",
+ api_call_desc=f"api.upload_activity({config.activityfile})",
+ )
+ else:
+ print(f"❌ Failed to upload activity from {config.activityfile}")
+
+ except FileNotFoundError:
+ print(f"❌ File not found: {config.activityfile}")
+ print("ℹ️ Please ensure the activity file exists in the current directory")
+ except requests.exceptions.HTTPError as e:
+ if e.response.status_code == 409:
+ print(
+ "⚠️ Activity already exists: This activity has already been uploaded to Garmin Connect"
+ )
+ print("ℹ️ Garmin Connect prevents duplicate activities from being uploaded")
+ print(
+ "💡 Try modifying the activity timestamps or creating a new activity file"
+ )
+ elif e.response.status_code == 413:
+ print(
+ "❌ File too large: The activity file exceeds Garmin Connect's size limit"
+ )
+ print("💡 Try compressing the file or reducing the number of data points")
+ elif e.response.status_code == 422:
+ print(
+ "❌ Invalid file format: The activity file format is not supported or corrupted"
+ )
+ print("ℹ️ Supported formats: FIT, GPX, TCX")
+ print("💡 Try converting to a different format or check file integrity")
+ elif e.response.status_code == 400:
+ print("❌ Bad request: Invalid activity data or malformed file")
+ print(
+ "💡 Check if the activity file contains valid GPS coordinates and timestamps"
+ )
+ elif e.response.status_code == 401:
+ print("❌ Authentication failed: Please login again")
+ print("💡 Your session may have expired")
+ elif e.response.status_code == 429:
+ print("❌ Rate limit exceeded: Too many upload requests")
+ print("💡 Please wait a few minutes before trying again")
+ else:
+ print(f"❌ HTTP Error {e.response.status_code}: {e}")
+ except GarminConnectAuthenticationError as e:
+ print(f"❌ Authentication error: {e}")
+ print("💡 Please check your login credentials and try again")
+ except GarminConnectConnectionError as e:
+ print(f"❌ Connection error: {e}")
+ print("💡 Please check your internet connection and try again")
+ except GarminConnectTooManyRequestsError as e:
+ print(f"❌ Too many requests: {e}")
+ print("💡 Please wait a few minutes before trying again")
+ except Exception as e:
+ # Check if this is a wrapped HTTP error from the Garmin library
+ error_str = str(e)
+ if "409 Client Error: Conflict" in error_str:
+ print(
+ "⚠️ Activity already exists: This activity has already been uploaded to Garmin Connect"
+ )
+ print("ℹ️ Garmin Connect prevents duplicate activities from being uploaded")
+ print(
+ "💡 Try modifying the activity timestamps or creating a new activity file"
+ )
+ elif "413" in error_str and "Request Entity Too Large" in error_str:
+ print(
+ "❌ File too large: The activity file exceeds Garmin Connect's size limit"
+ )
+ print("💡 Try compressing the file or reducing the number of data points")
+ elif "422" in error_str and "Unprocessable Entity" in error_str:
+ print(
+ "❌ Invalid file format: The activity file format is not supported or corrupted"
+ )
+ print("ℹ️ Supported formats: FIT, GPX, TCX")
+ print("💡 Try converting to a different format or check file integrity")
+ elif "400" in error_str and "Bad Request" in error_str:
+ print("❌ Bad request: Invalid activity data or malformed file")
+ print(
+ "💡 Check if the activity file contains valid GPS coordinates and timestamps"
+ )
+ elif "401" in error_str and "Unauthorized" in error_str:
+ print("❌ Authentication failed: Please login again")
+ print("💡 Your session may have expired")
+ elif "429" in error_str and "Too Many Requests" in error_str:
+ print("❌ Rate limit exceeded: Too many upload requests")
+ print("💡 Please wait a few minutes before trying again")
+ else:
+ print(f"❌ Unexpected error uploading activity: {e}")
+ print("💡 Please check the file format and try again")
+
+
+def download_activities_by_date(api: Garmin) -> None:
+ """Download activities by date range in multiple formats."""
+ try:
+ print(
+ f"📥 Downloading activities by date range ({config.week_start.isoformat()} to {config.today.isoformat()})..."
+ )
+
+ # Get activities for the date range (last 7 days as default)
+ activities = api.get_activities_by_date(
+ config.week_start.isoformat(), config.today.isoformat()
+ )
+
+ if not activities:
+ print("ℹ️ No activities found in the specified date range")
+ return
+
+ print(f"📊 Found {len(activities)} activities to download")
+
+ # Download each activity in multiple formats
+ for activity in activities:
+ activity_id = activity.get("activityId")
+ activity_name = activity.get("activityName", "Unknown")
+ start_time = activity.get("startTimeLocal", "").replace(":", "-")
+
+ if not activity_id:
+ continue
+
+ print(f"📥 Downloading: {activity_name} (ID: {activity_id})")
+
+ # Download formats: GPX, TCX, ORIGINAL, CSV
+ formats = ["GPX", "TCX", "ORIGINAL", "CSV"]
+
+ for fmt in formats:
+ try:
+ filename = f"{start_time}_{activity_id}_ACTIVITY.{fmt.lower()}"
+ if fmt == "ORIGINAL":
+ filename = f"{start_time}_{activity_id}_ACTIVITY.zip"
+
+ filepath = config.export_dir / filename
+
+ if fmt == "CSV":
+ # Get activity details for CSV export
+ activity_details = api.get_activity_details(activity_id)
+ with open(filepath, "w", encoding="utf-8") as f:
+ import json
+
+ json.dump(activity_details, f, indent=2, ensure_ascii=False)
+ print(f" ✅ {fmt}: {filename}")
+ else:
+ # Download the file from Garmin using proper enum values
+ format_mapping = {
+ "GPX": api.ActivityDownloadFormat.GPX,
+ "TCX": api.ActivityDownloadFormat.TCX,
+ "ORIGINAL": api.ActivityDownloadFormat.ORIGINAL,
+ }
+
+ dl_fmt = format_mapping[fmt]
+ content = api.download_activity(activity_id, dl_fmt=dl_fmt)
+
+ if content:
+ with open(filepath, "wb") as f:
+ f.write(content)
+ print(f" ✅ {fmt}: {filename}")
+ else:
+ print(f" ❌ {fmt}: No content available")
+
+ except Exception as e:
+ print(f" ❌ {fmt}: Error downloading - {e}")
+
+ print(f"✅ Activity downloads completed! Files saved to: {config.export_dir}")
+
+ except Exception as e:
+ print(f"❌ Error downloading activities: {e}")
+
+
+def add_weigh_in_data(api: Garmin) -> None:
+ """Add a weigh-in with timestamps."""
+ try:
+ # Get weight input from user
+ print("⚖️ Adding weigh-in entry")
+ print("-" * 30)
+
+ # Weight input with validation
+ while True:
+ try:
+ weight_str = input("Enter weight (30-300, default: 85.1): ").strip()
+ if not weight_str:
+ weight = 85.1
+ break
+ weight = float(weight_str)
+ if 30 <= weight <= 300:
+ break
+ else:
+ print("❌ Weight must be between 30 and 300")
+ except ValueError:
+ print("❌ Please enter a valid number")
+
+ # Unit selection
+ while True:
+ unit_input = input("Enter unit (kg/lbs, default: kg): ").strip().lower()
+ if not unit_input:
+ weight_unit = "kg"
+ break
+ elif unit_input in ["kg", "lbs"]:
+ weight_unit = unit_input
+ break
+ else:
+ print("❌ Please enter 'kg' or 'lbs'")
+
+ print(f"⚖️ Adding weigh-in: {weight} {weight_unit}")
+
+ # Collect all API responses for grouped display
+ api_responses = []
+
+ # Add a simple weigh-in
+ result1 = api.add_weigh_in(weight=weight, unitKey=weight_unit)
+ api_responses.append(
+ (f"api.add_weigh_in(weight={weight}, unitKey={weight_unit})", result1)
+ )
+
+ # Add a weigh-in with timestamps for yesterday
+ import datetime
+ from datetime import timezone
+
+ yesterday = config.today - datetime.timedelta(days=1) # Get yesterday's date
+ weigh_in_date = datetime.datetime.strptime(yesterday.isoformat(), "%Y-%m-%d")
+ local_timestamp = weigh_in_date.strftime("%Y-%m-%dT%H:%M:%S")
+ gmt_timestamp = weigh_in_date.astimezone(timezone.utc).strftime(
+ "%Y-%m-%dT%H:%M:%S"
+ )
+
+ result2 = api.add_weigh_in_with_timestamps(
+ weight=weight,
+ unitKey=weight_unit,
+ dateTimestamp=local_timestamp,
+ gmtTimestamp=gmt_timestamp,
+ )
+ api_responses.append(
+ (
+ f"api.add_weigh_in_with_timestamps(weight={weight}, unitKey={weight_unit}, dateTimestamp={local_timestamp}, gmtTimestamp={gmt_timestamp})",
+ result2,
+ )
+ )
+
+ # Display all responses as a group
+ call_and_display(group_name="Weigh-in Data Entry", api_responses=api_responses)
+
+ print("✅ Weigh-in data added successfully!")
+
+ except Exception as e:
+ print(f"❌ Error adding weigh-in: {e}")
+
+
+# Helper functions for the new API methods
+def get_lactate_threshold_data(api: Garmin) -> None:
+ """Get lactate threshold data."""
+ try:
+ # Collect all API responses for grouped display
+ api_responses = []
+
+ # Get latest lactate threshold
+ latest = api.get_lactate_threshold(latest=True)
+ api_responses.append(("api.get_lactate_threshold(latest=True)", latest))
+
+ # Get historical lactate threshold for past four weeks
+ four_weeks_ago = config.today - datetime.timedelta(days=28)
+ historical = api.get_lactate_threshold(
+ latest=False,
+ start_date=four_weeks_ago.isoformat(),
+ end_date=config.today.isoformat(),
+ aggregation="daily",
+ )
+ api_responses.append(
+ (
+ f"api.get_lactate_threshold(latest=False, start_date='{four_weeks_ago.isoformat()}', end_date='{config.today.isoformat()}', aggregation='daily')",
+ historical,
+ )
+ )
+
+ # Display all responses as a group
+ call_and_display(
+ group_name="Lactate Threshold Data", api_responses=api_responses
+ )
+
+ except Exception as e:
+ print(f"❌ Error getting lactate threshold data: {e}")
+
+
+def get_activity_splits_data(api: Garmin) -> None:
+ """Get activity splits for the last activity."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ call_and_display(
+ api.get_activity_splits,
+ activity_id,
+ method_name="get_activity_splits",
+ api_call_desc=f"api.get_activity_splits({activity_id})",
+ )
+ else:
+ print("ℹ️ No activities found")
+ except Exception as e:
+ print(f"❌ Error getting activity splits: {e}")
+
+
+def get_activity_typed_splits_data(api: Garmin) -> None:
+ """Get activity typed splits for the last activity."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ call_and_display(
+ api.get_activity_typed_splits,
+ activity_id,
+ method_name="get_activity_typed_splits",
+ api_call_desc=f"api.get_activity_typed_splits({activity_id})",
+ )
+ else:
+ print("ℹ️ No activities found")
+ except Exception as e:
+ print(f"❌ Error getting activity typed splits: {e}")
+
+
+def get_activity_split_summaries_data(api: Garmin) -> None:
+ """Get activity split summaries for the last activity."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ call_and_display(
+ api.get_activity_split_summaries,
+ activity_id,
+ method_name="get_activity_split_summaries",
+ api_call_desc=f"api.get_activity_split_summaries({activity_id})",
+ )
+ else:
+ print("ℹ️ No activities found")
+ except Exception as e:
+ print(f"❌ Error getting activity split summaries: {e}")
+
+
+def get_activity_weather_data(api: Garmin) -> None:
+ """Get activity weather data for the last activity."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ call_and_display(
+ api.get_activity_weather,
+ activity_id,
+ method_name="get_activity_weather",
+ api_call_desc=f"api.get_activity_weather({activity_id})",
+ )
+ else:
+ print("ℹ️ No activities found")
+ except Exception as e:
+ print(f"❌ Error getting activity weather: {e}")
+
+
+def get_activity_hr_timezones_data(api: Garmin) -> None:
+ """Get activity heart rate timezones for the last activity."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ call_and_display(
+ api.get_activity_hr_in_timezones,
+ activity_id,
+ method_name="get_activity_hr_in_timezones",
+ api_call_desc=f"api.get_activity_hr_in_timezones({activity_id})",
+ )
+ else:
+ print("ℹ️ No activities found")
+ except Exception as e:
+ print(f"❌ Error getting activity HR timezones: {e}")
+
+
+def get_activity_details_data(api: Garmin) -> None:
+ """Get detailed activity information for the last activity."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ call_and_display(
+ api.get_activity_details,
+ activity_id,
+ method_name="get_activity_details",
+ api_call_desc=f"api.get_activity_details({activity_id})",
+ )
+ else:
+ print("ℹ️ No activities found")
+ except Exception as e:
+ print(f"❌ Error getting activity details: {e}")
+
+
+def get_activity_gear_data(api: Garmin) -> None:
+ """Get activity gear information for the last activity."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ call_and_display(
+ api.get_activity_gear,
+ activity_id,
+ method_name="get_activity_gear",
+ api_call_desc=f"api.get_activity_gear({activity_id})",
+ )
+ else:
+ print("ℹ️ No activities found")
+ except Exception as e:
+ print(f"❌ Error getting activity gear: {e}")
+
+
+def get_single_activity_data(api: Garmin) -> None:
+ """Get single activity data for the last activity."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ call_and_display(
+ api.get_activity,
+ activity_id,
+ method_name="get_activity",
+ api_call_desc=f"api.get_activity({activity_id})",
+ )
+ else:
+ print("ℹ️ No activities found")
+ except Exception as e:
+ print(f"❌ Error getting single activity: {e}")
+
+
+def get_activity_exercise_sets_data(api: Garmin) -> None:
+ """Get exercise sets for strength training activities."""
+ try:
+ activities = api.get_activities(
+ 0, 20
+ ) # Get more activities to find a strength training one
+ strength_activity = None
+
+ # Find strength training activities
+ for activity in activities:
+ activity_type = activity.get("activityType", {})
+ type_key = activity_type.get("typeKey", "")
+ if "strength" in type_key.lower() or "training" in type_key.lower():
+ strength_activity = activity
+ break
+
+ if strength_activity:
+ activity_id = strength_activity["activityId"]
+ call_and_display(
+ api.get_activity_exercise_sets,
+ activity_id,
+ method_name="get_activity_exercise_sets",
+ api_call_desc=f"api.get_activity_exercise_sets({activity_id})",
+ )
+ else:
+ # Return empty JSON response
+ print("ℹ️ No strength training activities found")
+ except Exception:
+ print("ℹ️ No activity exercise sets available")
+
+
+def get_workout_by_id_data(api: Garmin) -> None:
+ """Get workout by ID for the last workout."""
+ try:
+ workouts = api.get_workouts()
+ if workouts:
+ workout_id = workouts[-1]["workoutId"]
+ workout_name = workouts[-1]["workoutName"]
+ call_and_display(
+ api.get_workout_by_id,
+ workout_id,
+ method_name="get_workout_by_id",
+ api_call_desc=f"api.get_workout_by_id({workout_id}) - {workout_name}",
+ )
+ else:
+ print("ℹ️ No workouts found")
+ except Exception as e:
+ print(f"❌ Error getting workout by ID: {e}")
+
+
+def download_workout_data(api: Garmin) -> None:
+ """Download workout to .FIT file."""
+ try:
+ workouts = api.get_workouts()
+ if workouts:
+ workout_id = workouts[-1]["workoutId"]
+ workout_name = workouts[-1]["workoutName"]
+
+ print(f"📥 Downloading workout: {workout_name}")
+ workout_data = api.download_workout(workout_id)
+
+ if workout_data:
+ output_file = config.export_dir / f"{workout_name}_{workout_id}.fit"
+ with open(output_file, "wb") as f:
+ f.write(workout_data)
+ print(f"✅ Workout downloaded to: {output_file}")
+ else:
+ print("❌ No workout data available")
+ else:
+ print("ℹ️ No workouts found")
+ except Exception as e:
+ print(f"❌ Error downloading workout: {e}")
+
+
+def upload_workout_data(api: Garmin) -> None:
+ """Upload workout from JSON file."""
+ try:
+ print(f"📤 Uploading workout from file: {config.workoutfile}")
+
+ # Check if file exists
+ if not os.path.exists(config.workoutfile):
+ print(f"❌ File not found: {config.workoutfile}")
+ print(
+ "ℹ️ Please ensure the workout JSON file exists in the test_data directory"
+ )
+ return
+
+ # Load the workout JSON data
+ import json
+
+ with open(config.workoutfile, encoding="utf-8") as f:
+ workout_data = json.load(f)
+
+ # Get current timestamp in Garmin format
+ current_time = datetime.datetime.now()
+ garmin_timestamp = current_time.strftime("%Y-%m-%dT%H:%M:%S.0")
+
+ # Remove IDs that shouldn't be included when uploading a new workout
+ fields_to_remove = ["workoutId", "ownerId", "updatedDate", "createdDate"]
+ for field in fields_to_remove:
+ if field in workout_data:
+ del workout_data[field]
+
+ # Add current timestamps
+ workout_data["createdDate"] = garmin_timestamp
+ workout_data["updatedDate"] = garmin_timestamp
+
+ # Remove step IDs to ensure new ones are generated
+ def clean_step_ids(workout_segments):
+ """Recursively remove step IDs from workout structure."""
+ if isinstance(workout_segments, list):
+ for segment in workout_segments:
+ clean_step_ids(segment)
+ elif isinstance(workout_segments, dict):
+ # Remove stepId if present
+ if "stepId" in workout_segments:
+ del workout_segments["stepId"]
+
+ # Recursively clean nested structures
+ if "workoutSteps" in workout_segments:
+ clean_step_ids(workout_segments["workoutSteps"])
+
+ # Handle any other nested lists or dicts
+ for _key, value in workout_segments.items():
+ if isinstance(value, list | dict):
+ clean_step_ids(value)
+
+ # Clean step IDs from workout segments
+ if "workoutSegments" in workout_data:
+ clean_step_ids(workout_data["workoutSegments"])
+
+ # Update workout name to indicate it's uploaded with current timestamp
+ original_name = workout_data.get("workoutName", "Workout")
+ workout_data["workoutName"] = (
+ f"Uploaded {original_name} - {current_time.strftime('%Y-%m-%d %H:%M:%S')}"
+ )
+
+ print(f"📤 Uploading workout: {workout_data['workoutName']}")
+
+ # Upload the workout
+ result = api.upload_workout(workout_data)
+
+ if result:
+ print("✅ Workout uploaded successfully!")
+ call_and_display(
+ lambda: result, # Use a lambda to pass the result
+ method_name="upload_workout",
+ api_call_desc="api.upload_workout(workout_data)",
+ )
+ else:
+ print(f"❌ Failed to upload workout from {config.workoutfile}")
+
+ except FileNotFoundError:
+ print(f"❌ File not found: {config.workoutfile}")
+ print("ℹ️ Please ensure the workout JSON file exists in the test_data directory")
+ except json.JSONDecodeError as e:
+ print(f"❌ Invalid JSON format in {config.workoutfile}: {e}")
+ print("ℹ️ Please check the JSON file format")
+ except Exception as e:
+ print(f"❌ Error uploading workout: {e}")
+ # Check for common upload errors
+ error_str = str(e)
+ if "400" in error_str:
+ print("💡 The workout data may be invalid or malformed")
+ elif "401" in error_str:
+ print("💡 Authentication failed - please login again")
+ elif "403" in error_str:
+ print("💡 Permission denied - check account permissions")
+ elif "409" in error_str:
+ print("💡 Workout may already exist")
+ elif "422" in error_str:
+ print("💡 Workout data validation failed")
+
+
+def set_body_composition_data(api: Garmin) -> None:
+ """Set body composition data."""
+ try:
+ print(f"⚖️ Setting body composition data for {config.today.isoformat()}")
+ print("-" * 50)
+
+ # Get weight input from user
+ while True:
+ try:
+ weight_str = input(
+ "Enter weight in kg (30-300, default: 85.1): "
+ ).strip()
+ if not weight_str:
+ weight = 85.1
+ break
+ weight = float(weight_str)
+ if 30 <= weight <= 300:
+ break
+ else:
+ print("❌ Weight must be between 30 and 300 kg")
+ except ValueError:
+ print("❌ Please enter a valid number")
+
+ call_and_display(
+ api.set_body_composition,
+ timestamp=config.today.isoformat(),
+ weight=weight,
+ percent_fat=15.4,
+ percent_hydration=54.8,
+ bone_mass=2.9,
+ muscle_mass=55.2,
+ method_name="set_body_composition",
+ api_call_desc=f"api.set_body_composition({config.today.isoformat()}, weight={weight}, ...)",
+ )
+ print("✅ Body composition data set successfully!")
+ except Exception as e:
+ print(f"❌ Error setting body composition: {e}")
+
+
+def add_body_composition_data(api: Garmin) -> None:
+ """Add body composition data."""
+ try:
+ print(f"⚖️ Adding body composition data for {config.today.isoformat()}")
+ print("-" * 50)
+
+ # Get weight input from user
+ while True:
+ try:
+ weight_str = input(
+ "Enter weight in kg (30-300, default: 85.1): "
+ ).strip()
+ if not weight_str:
+ weight = 85.1
+ break
+ weight = float(weight_str)
+ if 30 <= weight <= 300:
+ break
+ else:
+ print("❌ Weight must be between 30 and 300 kg")
+ except ValueError:
+ print("❌ Please enter a valid number")
+
+ call_and_display(
+ api.add_body_composition,
+ config.today.isoformat(),
+ weight=weight,
+ percent_fat=15.4,
+ percent_hydration=54.8,
+ visceral_fat_mass=10.8,
+ bone_mass=2.9,
+ muscle_mass=55.2,
+ basal_met=1454.1,
+ active_met=None,
+ physique_rating=None,
+ metabolic_age=33.0,
+ visceral_fat_rating=None,
+ bmi=22.2,
+ method_name="add_body_composition",
+ api_call_desc=f"api.add_body_composition({config.today.isoformat()}, weight={weight}, ...)",
+ )
+ print("✅ Body composition data added successfully!")
+ except Exception as e:
+ print(f"❌ Error adding body composition: {e}")
+
+
+def delete_weigh_ins_data(api: Garmin) -> None:
+ """Delete all weigh-ins for today."""
+ try:
+ call_and_display(
+ api.delete_weigh_ins,
+ config.today.isoformat(),
+ delete_all=True,
+ method_name="delete_weigh_ins",
+ api_call_desc=f"api.delete_weigh_ins({config.today.isoformat()}, delete_all=True)",
+ )
+ print("✅ Weigh-ins deleted successfully!")
+ except Exception as e:
+ print(f"❌ Error deleting weigh-ins: {e}")
+
+
+def delete_weigh_in_data(api: Garmin) -> None:
+ """Delete a specific weigh-in."""
+ try:
+ all_weigh_ins = []
+
+ # Find weigh-ins
+ print(f"🔍 Checking daily weigh-ins for today ({config.today.isoformat()})...")
+ try:
+ daily_weigh_ins = api.get_daily_weigh_ins(config.today.isoformat())
+
+ if daily_weigh_ins and "dateWeightList" in daily_weigh_ins:
+ weight_list = daily_weigh_ins["dateWeightList"]
+ for weigh_in in weight_list:
+ if isinstance(weigh_in, dict):
+ all_weigh_ins.append(weigh_in)
+ print(f"📊 Found {len(all_weigh_ins)} weigh-in(s) for today")
+ else:
+ print("📊 No weigh-in data found in response")
+ except Exception as e:
+ print(f"⚠️ Could not fetch daily weigh-ins: {e}")
+
+ if not all_weigh_ins:
+ print("ℹ️ No weigh-ins found for today")
+ print("💡 You can add a test weigh-in using menu option [4]")
+ return
+
+ print(f"\n⚖️ Found {len(all_weigh_ins)} weigh-in(s) available for deletion:")
+ print("-" * 70)
+
+ # Display weigh-ins for user selection
+ for i, weigh_in in enumerate(all_weigh_ins):
+ # Extract weight data - Garmin API uses different field names
+ weight = weigh_in.get("weight")
+ if weight is None:
+ weight = weigh_in.get("weightValue", "Unknown")
+
+ # Convert weight from grams to kg if it's a number
+ if isinstance(weight, int | float) and weight > 1000:
+ weight = weight / 1000 # Convert from grams to kg
+ weight = round(weight, 1) # Round to 1 decimal place
+
+ unit = weigh_in.get("unitKey", "kg")
+ date = weigh_in.get("calendarDate", config.today.isoformat())
+
+ # Try different timestamp fields
+ timestamp = (
+ weigh_in.get("timestampGMT")
+ or weigh_in.get("timestamp")
+ or weigh_in.get("date")
+ )
+
+ # Format timestamp for display
+ if timestamp:
+ try:
+ import datetime as dt
+
+ if isinstance(timestamp, str):
+ # Handle ISO format strings
+ datetime_obj = dt.datetime.fromisoformat(
+ timestamp.replace("Z", "+00:00")
+ )
+ else:
+ # Handle millisecond timestamps
+ datetime_obj = dt.datetime.fromtimestamp(timestamp / 1000)
+ time_str = datetime_obj.strftime("%H:%M:%S")
+ except Exception:
+ time_str = "Unknown time"
+ else:
+ time_str = "Unknown time"
+
+ print(f" [{i}] {weight} {unit} on {date} at {time_str}")
+
+ print()
+ try:
+ selection = input(
+ "Enter the index of the weigh-in to delete (or 'q' to cancel): "
+ ).strip()
+
+ if selection.lower() == "q":
+ print("❌ Delete cancelled")
+ return
+
+ weigh_in_index = int(selection)
+ if 0 <= weigh_in_index < len(all_weigh_ins):
+ selected_weigh_in = all_weigh_ins[weigh_in_index]
+
+ # Get the weigh-in ID (Garmin uses 'samplePk' as the primary key)
+ weigh_in_id = (
+ selected_weigh_in.get("samplePk")
+ or selected_weigh_in.get("id")
+ or selected_weigh_in.get("weightPk")
+ or selected_weigh_in.get("pk")
+ or selected_weigh_in.get("weightId")
+ or selected_weigh_in.get("uuid")
+ )
+
+ if weigh_in_id:
+ weight = selected_weigh_in.get("weight", "Unknown")
+
+ # Convert weight from grams to kg if it's a number
+ if isinstance(weight, int | float) and weight > 1000:
+ weight = weight / 1000 # Convert from grams to kg
+ weight = round(weight, 1) # Round to 1 decimal place
+
+ unit = selected_weigh_in.get("unitKey", "kg")
+ date = selected_weigh_in.get(
+ "calendarDate", config.today.isoformat()
+ )
+
+ # Confirm deletion
+ confirm = input(
+ f"Delete weigh-in {weight} {unit} from {date}? (yes/no): "
+ ).lower()
+ if confirm == "yes":
+ call_and_display(
+ api.delete_weigh_in,
+ weigh_in_id,
+ config.today.isoformat(),
+ method_name="delete_weigh_in",
+ api_call_desc=f"api.delete_weigh_in({weigh_in_id}, {config.today.isoformat()})",
+ )
+ print("✅ Weigh-in deleted successfully!")
+ else:
+ print("❌ Delete cancelled")
+ else:
+ print("❌ No weigh-in ID found for selected entry")
+ else:
+ print("❌ Invalid selection")
+
+ except ValueError:
+ print("❌ Invalid input - please enter a number")
+
+ except Exception as e:
+ print(f"❌ Error deleting weigh-in: {e}")
+
+
+def get_device_settings_data(api: Garmin) -> None:
+ """Get device settings for all devices."""
+ try:
+ devices = api.get_devices()
+ if devices:
+ for device in devices:
+ device_id = device["deviceId"]
+ device_name = device.get("displayName", f"Device {device_id}")
+ try:
+ call_and_display(
+ api.get_device_settings,
+ device_id,
+ method_name="get_device_settings",
+ api_call_desc=f"api.get_device_settings({device_id}) - {device_name}",
+ )
+ except Exception as e:
+ print(f"❌ Error getting settings for device {device_name}: {e}")
+ else:
+ print("ℹ️ No devices found")
+ except Exception as e:
+ print(f"❌ Error getting device settings: {e}")
+
+
+def get_gear_data(api: Garmin) -> None:
+ """Get user gear list."""
+ print("🔄 Fetching user gear list...")
+
+ api_responses = []
+
+ # Get device info first
+ api_responses.append(
+ safe_call_for_group(
+ api.get_device_last_used,
+ method_name="get_device_last_used",
+ api_call_desc="api.get_device_last_used()",
+ )
+ )
+
+ # Get user profile number from the first call
+ device_success, device_data, _ = safe_api_call(
+ api.get_device_last_used, method_name="get_device_last_used"
+ )
+
+ if device_success and device_data:
+ user_profile_number = device_data.get("userProfileNumber")
+ if user_profile_number:
+ api_responses.append(
+ safe_call_for_group(
+ api.get_gear,
+ user_profile_number,
+ method_name="get_gear",
+ api_call_desc=f"api.get_gear({user_profile_number})",
+ )
+ )
+ else:
+ print("❌ Could not get user profile number")
+
+ call_and_display(group_name="User Gear List", api_responses=api_responses)
+
+
+def get_gear_defaults_data(api: Garmin) -> None:
+ """Get gear defaults."""
+ print("🔄 Fetching gear defaults...")
+
+ api_responses = []
+
+ # Get device info first
+ api_responses.append(
+ safe_call_for_group(
+ api.get_device_last_used,
+ method_name="get_device_last_used",
+ api_call_desc="api.get_device_last_used()",
+ )
+ )
+
+ # Get user profile number from the first call
+ device_success, device_data, _ = safe_api_call(
+ api.get_device_last_used, method_name="get_device_last_used"
+ )
+
+ if device_success and device_data:
+ user_profile_number = device_data.get("userProfileNumber")
+ if user_profile_number:
+ api_responses.append(
+ safe_call_for_group(
+ api.get_gear_defaults,
+ user_profile_number,
+ method_name="get_gear_defaults",
+ api_call_desc=f"api.get_gear_defaults({user_profile_number})",
+ )
+ )
+ else:
+ print("❌ Could not get user profile number")
+
+ call_and_display(group_name="Gear Defaults", api_responses=api_responses)
+
+
+def get_gear_stats_data(api: Garmin) -> None:
+ """Get gear statistics."""
+ print("🔄 Fetching comprehensive gear statistics...")
+
+ api_responses = []
+
+ # Get device info first
+ api_responses.append(
+ safe_call_for_group(
+ api.get_device_last_used,
+ method_name="get_device_last_used",
+ api_call_desc="api.get_device_last_used()",
+ )
+ )
+
+ # Get user profile number and gear list
+ device_success, device_data, _ = safe_api_call(
+ api.get_device_last_used, method_name="get_device_last_used"
+ )
+
+ if device_success and device_data:
+ user_profile_number = device_data.get("userProfileNumber")
+ if user_profile_number:
+ # Get gear list
+ api_responses.append(
+ safe_call_for_group(
+ api.get_gear,
+ user_profile_number,
+ method_name="get_gear",
+ api_call_desc=f"api.get_gear({user_profile_number})",
+ )
+ )
+
+ # Get gear data to extract UUIDs for stats
+ gear_success, gear_data, _ = safe_api_call(
+ api.get_gear, user_profile_number, method_name="get_gear"
+ )
+
+ if gear_success and gear_data:
+ # Get stats for each gear item (limit to first 3)
+ for gear_item in gear_data[:3]:
+ gear_uuid = gear_item.get("uuid")
+ gear_name = gear_item.get("displayName", "Unknown")
+ if gear_uuid:
+ api_responses.append(
+ safe_call_for_group(
+ api.get_gear_stats,
+ gear_uuid,
+ method_name="get_gear_stats",
+ api_call_desc=f"api.get_gear_stats('{gear_uuid}') - {gear_name}",
+ )
+ )
+ else:
+ print("ℹ️ No gear found")
+ else:
+ print("❌ Could not get user profile number")
+
+ call_and_display(group_name="Gear Statistics", api_responses=api_responses)
+
+
+def get_gear_activities_data(api: Garmin) -> None:
+ """Get gear activities."""
+ print("🔄 Fetching gear activities...")
+
+ api_responses = []
+
+ # Get device info first
+ api_responses.append(
+ safe_call_for_group(
+ api.get_device_last_used,
+ method_name="get_device_last_used",
+ api_call_desc="api.get_device_last_used()",
+ )
+ )
+
+ # Get user profile number and gear list
+ device_success, device_data, _ = safe_api_call(
+ api.get_device_last_used, method_name="get_device_last_used"
+ )
+
+ if device_success and device_data:
+ user_profile_number = device_data.get("userProfileNumber")
+ if user_profile_number:
+ # Get gear list
+ api_responses.append(
+ safe_call_for_group(
+ api.get_gear,
+ user_profile_number,
+ method_name="get_gear",
+ api_call_desc=f"api.get_gear({user_profile_number})",
+ )
+ )
+
+ # Get gear data to extract UUID for activities
+ gear_success, gear_data, _ = safe_api_call(
+ api.get_gear, user_profile_number, method_name="get_gear"
+ )
+
+ if gear_success and gear_data and len(gear_data) > 0:
+ # Get activities for the first gear item
+ gear_uuid = gear_data[0].get("uuid")
+ gear_name = gear_data[0].get("displayName", "Unknown")
+
+ if gear_uuid:
+ api_responses.append(
+ safe_call_for_group(
+ api.get_gear_activities,
+ gear_uuid,
+ method_name="get_gear_activities",
+ api_call_desc=f"api.get_gear_activities('{gear_uuid}') - {gear_name}",
+ )
+ )
+ else:
+ print("❌ No gear UUID found")
+ else:
+ print("ℹ️ No gear found")
+ else:
+ print("❌ Could not get user profile number")
+
+ call_and_display(group_name="Gear Activities", api_responses=api_responses)
+
+
+def set_gear_default_data(api: Garmin) -> None:
+ """Set gear default."""
+ try:
+ device_last_used = api.get_device_last_used()
+ user_profile_number = device_last_used.get("userProfileNumber")
+ if user_profile_number:
+ gear = api.get_gear(user_profile_number)
+ if gear:
+ gear_uuid = gear[0].get("uuid")
+ gear_name = gear[0].get("displayName", "Unknown")
+ if gear_uuid:
+ # Set as default for running (activity type ID 1)
+ # Correct method signature: set_gear_default(activityType, gearUUID, defaultGear=True)
+ activity_type = 1 # Running
+ call_and_display(
+ api.set_gear_default,
+ activity_type,
+ gear_uuid,
+ True,
+ method_name="set_gear_default",
+ api_call_desc=f"api.set_gear_default({activity_type}, '{gear_uuid}', True) - {gear_name} for running",
+ )
+ print("✅ Gear default set successfully!")
+ else:
+ print("❌ No gear UUID found")
+ else:
+ print("ℹ️ No gear found")
+ else:
+ print("❌ Could not get user profile number")
+ except Exception as e:
+ print(f"❌ Error setting gear default: {e}")
+
+
+def set_activity_name_data(api: Garmin) -> None:
+ """Set activity name."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ print(f"Current name of fetched activity: {activities[0]['activityName']}")
+ new_name = input("Enter new activity name: (or 'q' to cancel): ").strip()
+
+ if new_name.lower() == "q":
+ print("❌ Rename cancelled")
+ return
+
+ if new_name:
+ call_and_display(
+ api.set_activity_name,
+ activity_id,
+ new_name,
+ method_name="set_activity_name",
+ api_call_desc=f"api.set_activity_name({activity_id}, '{new_name}')",
+ )
+ print("✅ Activity name updated!")
+ else:
+ print("❌ No name provided")
+ else:
+ print("❌ No activities found")
+ except Exception as e:
+ print(f"❌ Error setting activity name: {e}")
+
+
+def set_activity_type_data(api: Garmin) -> None:
+ """Set activity type."""
+ try:
+ activities = api.get_activities(0, 1)
+ if activities:
+ activity_id = activities[0]["activityId"]
+ activity_types = api.get_activity_types()
+
+ # Show available types
+ print("\nAvailable activity types: (limit=10)")
+ for i, activity_type in enumerate(activity_types[:10]): # Show first 10
+ print(
+ f"{i}: {activity_type.get('typeKey', 'Unknown')} - {activity_type.get('display', 'No description')}"
+ )
+
+ try:
+ print(
+ f"Current type of fetched activity '{activities[0]['activityName']}': {activities[0]['activityType']['typeKey']}"
+ )
+ type_index = input(
+ "Enter activity type index: (or 'q' to cancel): "
+ ).strip()
+
+ if type_index.lower() == "q":
+ print("❌ Type change cancelled")
+ return
+
+ type_index = int(type_index)
+ if 0 <= type_index < len(activity_types):
+ selected_type = activity_types[type_index]
+ type_id = selected_type["typeId"]
+ type_key = selected_type["typeKey"]
+ parent_type_id = selected_type.get(
+ "parentTypeId", selected_type["typeId"]
+ )
+
+ call_and_display(
+ api.set_activity_type,
+ activity_id,
+ type_id,
+ type_key,
+ parent_type_id,
+ method_name="set_activity_type",
+ api_call_desc=f"api.set_activity_type({activity_id}, {type_id}, '{type_key}', {parent_type_id})",
+ )
+ print("✅ Activity type updated!")
+ else:
+ print("❌ Invalid index")
+ except ValueError:
+ print("❌ Invalid input")
+ else:
+ print("❌ No activities found")
+ except Exception as e:
+ print(f"❌ Error setting activity type: {e}")
+
+
+def create_manual_activity_data(api: Garmin) -> None:
+ """Create manual activity."""
+ try:
+ print("Creating manual activity...")
+ print("Enter activity details (press Enter for defaults):")
+
+ activity_name = (
+ input("Activity name [Manual Activity]: ").strip() or "Manual Activity"
+ )
+ type_key = input("Activity type key [running]: ").strip() or "running"
+ duration_min = input("Duration in minutes [60]: ").strip() or "60"
+ distance_km = input("Distance in kilometers [5]: ").strip() or "5"
+ timezone = input("Timezone [UTC]: ").strip() or "UTC"
+
+ try:
+ duration_min = float(duration_min)
+ distance_km = float(distance_km)
+
+ # Use the current time as start time
+ import datetime
+
+ start_datetime = datetime.datetime.now().strftime("%Y-%m-%dT%H:%M:%S.00")
+
+ call_and_display(
+ api.create_manual_activity,
+ start_datetime=start_datetime,
+ time_zone=timezone,
+ type_key=type_key,
+ distance_km=distance_km,
+ duration_min=duration_min,
+ activity_name=activity_name,
+ method_name="create_manual_activity",
+ api_call_desc=f"api.create_manual_activity(start_datetime='{start_datetime}', time_zone='{timezone}', type_key='{type_key}', distance_km={distance_km}, duration_min={duration_min}, activity_name='{activity_name}')",
+ )
+ print("✅ Manual activity created!")
+ except ValueError:
+ print("❌ Invalid numeric input")
+ except Exception as e:
+ print(f"❌ Error creating manual activity: {e}")
+
+
+def delete_activity_data(api: Garmin) -> None:
+ """Delete activity."""
+ try:
+ activities = api.get_activities(0, 5)
+ if activities:
+ print("\nRecent activities:")
+ for i, activity in enumerate(activities):
+ activity_name = activity.get("activityName", "Unnamed")
+ activity_id = activity.get("activityId")
+ start_time = activity.get("startTimeLocal", "Unknown time")
+ print(f"{i}: {activity_name} ({activity_id}) - {start_time}")
+
+ try:
+ activity_index = input(
+ "Enter activity index to delete: (or 'q' to cancel): "
+ ).strip()
+
+ if activity_index.lower() == "q":
+ print("❌ Delete cancelled")
+ return
+ activity_index = int(activity_index)
+ if 0 <= activity_index < len(activities):
+ activity_id = activities[activity_index]["activityId"]
+ activity_name = activities[activity_index].get(
+ "activityName", "Unnamed"
+ )
+
+ confirm = input(f"Delete '{activity_name}'? (yes/no): ").lower()
+ if confirm == "yes":
+ call_and_display(
+ api.delete_activity,
+ activity_id,
+ method_name="delete_activity",
+ api_call_desc=f"api.delete_activity({activity_id})",
+ )
+ print("✅ Activity deleted!")
+ else:
+ print("❌ Delete cancelled")
+ else:
+ print("❌ Invalid index")
+ except ValueError:
+ print("❌ Invalid input")
+ else:
+ print("❌ No activities found")
+ except Exception as e:
+ print(f"❌ Error deleting activity: {e}")
+
+
+def delete_blood_pressure_data(api: Garmin) -> None:
+ """Delete blood pressure entry."""
+ try:
+ # Get recent blood pressure entries
+ bp_data = api.get_blood_pressure(
+ config.week_start.isoformat(), config.today.isoformat()
+ )
+ entry_list = []
+
+ # Parse the actual blood pressure data structure
+ if bp_data and bp_data.get("measurementSummaries"):
+ for summary in bp_data["measurementSummaries"]:
+ if summary.get("measurements"):
+ for measurement in summary["measurements"]:
+ # Use 'version' as the identifier (this is what Garmin uses)
+ entry_id = measurement.get("version")
+ systolic = measurement.get("systolic")
+ diastolic = measurement.get("diastolic")
+ pulse = measurement.get("pulse")
+ timestamp = measurement.get("measurementTimestampLocal")
+ notes = measurement.get("notes", "")
+
+ # Extract date for deletion API (format: YYYY-MM-DD)
+ measurement_date = None
+ if timestamp:
+ try:
+ measurement_date = timestamp.split("T")[
+ 0
+ ] # Get just the date part
+ except Exception:
+ measurement_date = summary.get(
+ "startDate"
+ ) # Fallback to summary date
+ else:
+ measurement_date = summary.get(
+ "startDate"
+ ) # Fallback to summary date
+
+ if entry_id and systolic and diastolic and measurement_date:
+ # Format display text with more details
+ display_parts = [f"{systolic}/{diastolic}"]
+ if pulse:
+ display_parts.append(f"pulse {pulse}")
+ if timestamp:
+ display_parts.append(f"at {timestamp}")
+ if notes:
+ display_parts.append(f"({notes})")
+
+ display_text = " ".join(display_parts)
+ # Store both entry_id and measurement_date for deletion
+ entry_list.append(
+ (entry_id, display_text, measurement_date)
+ )
+
+ if entry_list:
+ print(f"\n📊 Found {len(entry_list)} blood pressure entries:")
+ print("-" * 70)
+ for i, (entry_id, display_text, _measurement_date) in enumerate(entry_list):
+ print(f" [{i}] {display_text} (ID: {entry_id})")
+
+ try:
+ entry_index = input(
+ "\nEnter entry index to delete: (or 'q' to cancel): "
+ ).strip()
+
+ if entry_index.lower() == "q":
+ print("❌ Entry deletion cancelled")
+ return
+
+ entry_index = int(entry_index)
+ if 0 <= entry_index < len(entry_list):
+ entry_id, display_text, measurement_date = entry_list[entry_index]
+ confirm = input(
+ f"Delete entry '{display_text}'? (yes/no): "
+ ).lower()
+ if confirm == "yes":
+ call_and_display(
+ api.delete_blood_pressure,
+ entry_id,
+ measurement_date,
+ method_name="delete_blood_pressure",
+ api_call_desc=f"api.delete_blood_pressure('{entry_id}', '{measurement_date}')",
+ )
+ print("✅ Blood pressure entry deleted!")
+ else:
+ print("❌ Delete cancelled")
+ else:
+ print("❌ Invalid index")
+ except ValueError:
+ print("❌ Invalid input")
+ else:
+ print("❌ No blood pressure entries found for past week")
+ print("💡 You can add a test measurement using menu option [3]")
+
+ except Exception as e:
+ print(f"❌ Error deleting blood pressure: {e}")
+
+
+def query_garmin_graphql_data(api: Garmin) -> None:
+ """Execute GraphQL query with a menu of available queries."""
+ try:
+ print("Available GraphQL queries:")
+ print(" [1] Activities (recent activities with details)")
+ print(" [2] Health Snapshot (comprehensive health data)")
+ print(" [3] Weight Data (weight measurements)")
+ print(" [4] Blood Pressure (blood pressure data)")
+ print(" [5] Sleep Summaries (sleep analysis)")
+ print(" [6] Heart Rate Variability (HRV data)")
+ print(" [7] User Daily Summary (comprehensive daily stats)")
+ print(" [8] Training Readiness (training readiness metrics)")
+ print(" [9] Training Status (training status data)")
+ print(" [10] Activity Stats (aggregated activity statistics)")
+ print(" [11] VO2 Max (VO2 max data)")
+ print(" [12] Endurance Score (endurance scoring)")
+ print(" [13] User Goals (current goals)")
+ print(" [14] Stress Data (epoch chart with stress)")
+ print(" [15] Badge Challenges (available challenges)")
+ print(" [16] Adhoc Challenges (adhoc challenges)")
+ print(" [c] Custom query")
+
+ choice = input("\nEnter choice (1-16, c): ").strip()
+
+ # Use today's date and date range for queries that need them
+ today = config.today.isoformat()
+ week_start = config.week_start.isoformat()
+ start_datetime = f"{today}T00:00:00.00"
+ end_datetime = f"{today}T23:59:59.999"
+
+ if choice == "1":
+ query = f'query{{activitiesScalar(displayName:"{api.display_name}", startTimestampLocal:"{start_datetime}", endTimestampLocal:"{end_datetime}", limit:10)}}'
+ elif choice == "2":
+ query = f'query{{healthSnapshotScalar(startDate:"{week_start}", endDate:"{today}")}}'
+ elif choice == "3":
+ query = (
+ f'query{{weightScalar(startDate:"{week_start}", endDate:"{today}")}}'
+ )
+ elif choice == "4":
+ query = f'query{{bloodPressureScalar(startDate:"{week_start}", endDate:"{today}")}}'
+ elif choice == "5":
+ query = f'query{{sleepSummariesScalar(startDate:"{week_start}", endDate:"{today}")}}'
+ elif choice == "6":
+ query = f'query{{heartRateVariabilityScalar(startDate:"{week_start}", endDate:"{today}")}}'
+ elif choice == "7":
+ query = f'query{{userDailySummaryV2Scalar(startDate:"{week_start}", endDate:"{today}")}}'
+ elif choice == "8":
+ query = f'query{{trainingReadinessRangeScalar(startDate:"{week_start}", endDate:"{today}")}}'
+ elif choice == "9":
+ query = f'query{{trainingStatusDailyScalar(calendarDate:"{today}")}}'
+ elif choice == "10":
+ query = f'query{{activityStatsScalar(aggregation:"daily", startDate:"{week_start}", endDate:"{today}", metrics:["duration", "distance"], groupByParentActivityType:true, standardizedUnits:true)}}'
+ elif choice == "11":
+ query = (
+ f'query{{vo2MaxScalar(startDate:"{week_start}", endDate:"{today}")}}'
+ )
+ elif choice == "12":
+ query = f'query{{enduranceScoreScalar(startDate:"{week_start}", endDate:"{today}", aggregation:"weekly")}}'
+ elif choice == "13":
+ query = "query{userGoalsScalar}"
+ elif choice == "14":
+ query = f'query{{epochChartScalar(date:"{today}", include:["stress"])}}'
+ elif choice == "15":
+ query = "query{badgeChallengesScalar}"
+ elif choice == "16":
+ query = "query{adhocChallengesScalar}"
+ elif choice.lower() == "c":
+ print("\nEnter your custom GraphQL query:")
+ print("Example: query{userGoalsScalar}")
+ query = input("Query: ").strip()
+ else:
+ print("❌ Invalid choice")
+ return
+
+ if query:
+ # GraphQL API expects a dictionary with the query as a string value
+ graphql_payload = {"query": query}
+ call_and_display(
+ api.query_garmin_graphql,
+ graphql_payload,
+ method_name="query_garmin_graphql",
+ api_call_desc=f"api.query_garmin_graphql({graphql_payload})",
+ )
+ else:
+ print("❌ No query provided")
+ except Exception as e:
+ print(f"❌ Error executing GraphQL query: {e}")
+
+
+def get_virtual_challenges_data(api: Garmin) -> None:
+ """Get virtual challenges data with centralized error handling."""
+ print("🏆 Attempting to get virtual challenges data...")
+
+ # Try in-progress virtual challenges - this endpoint often returns 400 for accounts
+ # that don't have virtual challenges enabled, so handle it quietly
+ try:
+ challenges = api.get_inprogress_virtual_challenges(
+ config.start, config.default_limit
+ )
+ if challenges:
+ print("✅ Virtual challenges data retrieved successfully")
+ call_and_display(
+ api.get_inprogress_virtual_challenges,
+ config.start,
+ config.default_limit,
+ method_name="get_inprogress_virtual_challenges",
+ api_call_desc=f"api.get_inprogress_virtual_challenges({config.start}, {config.default_limit})",
+ )
+ return
+ else:
+ print("ℹ️ No in-progress virtual challenges found")
+ return
+ except GarminConnectConnectionError as e:
+ # Handle the common 400 error case quietly - this is expected for many accounts
+ error_str = str(e)
+ if "400" in error_str and (
+ "Bad Request" in error_str or "API client error" in error_str
+ ):
+ print("ℹ️ Virtual challenges are not available for your account")
+ else:
+ # For unexpected connection errors, show them
+ print(f"⚠️ Connection error accessing virtual challenges: {error_str}")
+ except Exception as e:
+ print(f"⚠️ Unexpected error accessing virtual challenges: {e}")
+
+ # Since virtual challenges failed or returned no data, suggest alternatives
+ print("💡 You can try other challenge-related endpoints instead:")
+ print(" - Badge challenges (menu option 7-8)")
+ print(" - Available badge challenges (menu option 7-4)")
+ print(" - Adhoc challenges (menu option 7-3)")
+
+
+def add_hydration_data_entry(api: Garmin) -> None:
+ """Add hydration data entry."""
+ try:
+ import datetime
+
+ value_in_ml = 240
+ raw_date = config.today
+ cdate = str(raw_date)
+ raw_ts = datetime.datetime.now()
+ timestamp = datetime.datetime.strftime(raw_ts, "%Y-%m-%dT%H:%M:%S.%f")
+
+ call_and_display(
+ api.add_hydration_data,
+ value_in_ml=value_in_ml,
+ cdate=cdate,
+ timestamp=timestamp,
+ method_name="add_hydration_data",
+ api_call_desc=f"api.add_hydration_data(value_in_ml={value_in_ml}, cdate='{cdate}', timestamp='{timestamp}')",
+ )
+ print("✅ Hydration data added successfully!")
+ except Exception as e:
+ print(f"❌ Error adding hydration data: {e}")
+
+
+def set_blood_pressure_data(api: Garmin) -> None:
+ """Set blood pressure (and pulse) data."""
+ try:
+ print("🩸 Adding blood pressure (and pulse) measurement")
+ print("Enter blood pressure values (press Enter for defaults):")
+
+ # Get systolic pressure
+ systolic_input = input("Systolic pressure [120]: ").strip()
+ systolic = int(systolic_input) if systolic_input else 120
+
+ # Get diastolic pressure
+ diastolic_input = input("Diastolic pressure [80]: ").strip()
+ diastolic = int(diastolic_input) if diastolic_input else 80
+
+ # Get pulse
+ pulse_input = input("Pulse rate [60]: ").strip()
+ pulse = int(pulse_input) if pulse_input else 60
+
+ # Get notes (optional)
+ notes = input("Notes (optional): ").strip() or "Added via demo.py"
+
+ # Validate ranges
+ if not (50 <= systolic <= 300):
+ print("❌ Invalid systolic pressure (should be between 50-300)")
+ return
+ if not (30 <= diastolic <= 200):
+ print("❌ Invalid diastolic pressure (should be between 30-200)")
+ return
+ if not (30 <= pulse <= 250):
+ print("❌ Invalid pulse rate (should be between 30-250)")
+ return
+
+ print(f"📊 Recording: {systolic}/{diastolic} mmHg, pulse {pulse} bpm")
+
+ call_and_display(
+ api.set_blood_pressure,
+ systolic,
+ diastolic,
+ pulse,
+ notes=notes,
+ method_name="set_blood_pressure",
+ api_call_desc=f"api.set_blood_pressure({systolic}, {diastolic}, {pulse}, notes='{notes}')",
+ )
+ print("✅ Blood pressure data set successfully!")
+
+ except ValueError:
+ print("❌ Invalid input - please enter numeric values")
+ except Exception as e:
+ print(f"❌ Error setting blood pressure: {e}")
+
+
+def track_gear_usage_data(api: Garmin) -> None:
+ """Calculate total time of use of a piece of gear by going through all activities where said gear has been used."""
+ try:
+ device_last_used = api.get_device_last_used()
+ user_profile_number = device_last_used.get("userProfileNumber")
+ if user_profile_number:
+ gear_list = api.get_gear(user_profile_number)
+ # call_and_display(api.get_gear, user_profile_number, method_name="get_gear", api_call_desc=f"api.get_gear({user_profile_number})")
+ if gear_list and isinstance(gear_list, list):
+ first_gear = gear_list[0]
+ gear_uuid = first_gear.get("uuid")
+ gear_name = first_gear.get("displayName", "Unknown")
+ print(f"Tracking usage for gear: {gear_name} (UUID: {gear_uuid})")
+ activityList = api.get_gear_activities(gear_uuid)
+ if len(activityList) == 0:
+ print("No activities found for the given gear uuid.")
+ else:
+ print("Found " + str(len(activityList)) + " activities.")
+
+ D = 0
+ for a in activityList:
+ print(
+ "Activity: "
+ + a["startTimeLocal"]
+ + (" | " + a["activityName"] if a["activityName"] else "")
+ )
+ print(
+ " Duration: "
+ + format_timedelta(datetime.timedelta(seconds=a["duration"]))
+ )
+ D += a["duration"]
+ print("")
+ print(
+ "Total Duration: " + format_timedelta(datetime.timedelta(seconds=D))
+ )
+ print("")
+ else:
+ print("No gear found for this user.")
+ else:
+ print("❌ Could not get user profile number")
+ except Exception as e:
+ print(f"❌ Error getting gear for track_gear_usage_data: {e}")
+
+
+def execute_api_call(api: Garmin, key: str) -> None:
+ """Execute an API call based on the key."""
+ if not api:
+ print("API not available")
+ return
+
+ try:
+ # Map of keys to API methods - this can be extended as needed
+ api_methods = {
+ # User & Profile
+ "get_full_name": lambda: call_and_display(
+ api.get_full_name,
+ method_name="get_full_name",
+ api_call_desc="api.get_full_name()",
+ ),
+ "get_unit_system": lambda: call_and_display(
+ api.get_unit_system,
+ method_name="get_unit_system",
+ api_call_desc="api.get_unit_system()",
+ ),
+ "get_user_profile": lambda: call_and_display(
+ api.get_user_profile,
+ method_name="get_user_profile",
+ api_call_desc="api.get_user_profile()",
+ ),
+ "get_userprofile_settings": lambda: call_and_display(
+ api.get_userprofile_settings,
+ method_name="get_userprofile_settings",
+ api_call_desc="api.get_userprofile_settings()",
+ ),
+ # Daily Health & Activity
+ "get_stats": lambda: call_and_display(
+ api.get_stats,
+ config.today.isoformat(),
+ method_name="get_stats",
+ api_call_desc=f"api.get_stats('{config.today.isoformat()}')",
+ ),
+ "get_user_summary": lambda: call_and_display(
+ api.get_user_summary,
+ config.today.isoformat(),
+ method_name="get_user_summary",
+ api_call_desc=f"api.get_user_summary('{config.today.isoformat()}')",
+ ),
+ "get_stats_and_body": lambda: call_and_display(
+ api.get_stats_and_body,
+ config.today.isoformat(),
+ method_name="get_stats_and_body",
+ api_call_desc=f"api.get_stats_and_body('{config.today.isoformat()}')",
+ ),
+ "get_steps_data": lambda: call_and_display(
+ api.get_steps_data,
+ config.today.isoformat(),
+ method_name="get_steps_data",
+ api_call_desc=f"api.get_steps_data('{config.today.isoformat()}')",
+ ),
+ "get_heart_rates": lambda: call_and_display(
+ api.get_heart_rates,
+ config.today.isoformat(),
+ method_name="get_heart_rates",
+ api_call_desc=f"api.get_heart_rates('{config.today.isoformat()}')",
+ ),
+ "get_resting_heart_rate": lambda: call_and_display(
+ api.get_rhr_day,
+ config.today.isoformat(),
+ method_name="get_rhr_day",
+ api_call_desc=f"api.get_rhr_day('{config.today.isoformat()}')",
+ ),
+ "get_sleep_data": lambda: call_and_display(
+ api.get_sleep_data,
+ config.today.isoformat(),
+ method_name="get_sleep_data",
+ api_call_desc=f"api.get_sleep_data('{config.today.isoformat()}')",
+ ),
+ "get_all_day_stress": lambda: call_and_display(
+ api.get_all_day_stress,
+ config.today.isoformat(),
+ method_name="get_all_day_stress",
+ api_call_desc=f"api.get_all_day_stress('{config.today.isoformat()}')",
+ ),
+ # Advanced Health Metrics
+ "get_training_readiness": lambda: call_and_display(
+ api.get_training_readiness,
+ config.today.isoformat(),
+ method_name="get_training_readiness",
+ api_call_desc=f"api.get_training_readiness('{config.today.isoformat()}')",
+ ),
+ "get_training_status": lambda: call_and_display(
+ api.get_training_status,
+ config.today.isoformat(),
+ method_name="get_training_status",
+ api_call_desc=f"api.get_training_status('{config.today.isoformat()}')",
+ ),
+ "get_respiration_data": lambda: call_and_display(
+ api.get_respiration_data,
+ config.today.isoformat(),
+ method_name="get_respiration_data",
+ api_call_desc=f"api.get_respiration_data('{config.today.isoformat()}')",
+ ),
+ "get_spo2_data": lambda: call_and_display(
+ api.get_spo2_data,
+ config.today.isoformat(),
+ method_name="get_spo2_data",
+ api_call_desc=f"api.get_spo2_data('{config.today.isoformat()}')",
+ ),
+ "get_max_metrics": lambda: call_and_display(
+ api.get_max_metrics,
+ config.today.isoformat(),
+ method_name="get_max_metrics",
+ api_call_desc=f"api.get_max_metrics('{config.today.isoformat()}')",
+ ),
+ "get_hrv_data": lambda: call_and_display(
+ api.get_hrv_data,
+ config.today.isoformat(),
+ method_name="get_hrv_data",
+ api_call_desc=f"api.get_hrv_data('{config.today.isoformat()}')",
+ ),
+ "get_fitnessage_data": lambda: call_and_display(
+ api.get_fitnessage_data,
+ config.today.isoformat(),
+ method_name="get_fitnessage_data",
+ api_call_desc=f"api.get_fitnessage_data('{config.today.isoformat()}')",
+ ),
+ "get_stress_data": lambda: call_and_display(
+ api.get_stress_data,
+ config.today.isoformat(),
+ method_name="get_stress_data",
+ api_call_desc=f"api.get_stress_data('{config.today.isoformat()}')",
+ ),
+ "get_lactate_threshold": lambda: get_lactate_threshold_data(api),
+ "get_intensity_minutes_data": lambda: call_and_display(
+ api.get_intensity_minutes_data,
+ config.today.isoformat(),
+ method_name="get_intensity_minutes_data",
+ api_call_desc=f"api.get_intensity_minutes_data('{config.today.isoformat()}')",
+ ),
+ # Historical Data & Trends
+ "get_daily_steps": lambda: call_and_display(
+ api.get_daily_steps,
+ config.week_start.isoformat(),
+ config.today.isoformat(),
+ method_name="get_daily_steps",
+ api_call_desc=f"api.get_daily_steps('{config.week_start.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ "get_body_battery": lambda: call_and_display(
+ api.get_body_battery,
+ config.week_start.isoformat(),
+ config.today.isoformat(),
+ method_name="get_body_battery",
+ api_call_desc=f"api.get_body_battery('{config.week_start.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ "get_floors": lambda: call_and_display(
+ api.get_floors,
+ config.week_start.isoformat(),
+ method_name="get_floors",
+ api_call_desc=f"api.get_floors('{config.week_start.isoformat()}')",
+ ),
+ "get_blood_pressure": lambda: call_and_display(
+ api.get_blood_pressure,
+ config.week_start.isoformat(),
+ config.today.isoformat(),
+ method_name="get_blood_pressure",
+ api_call_desc=f"api.get_blood_pressure('{config.week_start.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ "get_progress_summary_between_dates": lambda: call_and_display(
+ api.get_progress_summary_between_dates,
+ config.week_start.isoformat(),
+ config.today.isoformat(),
+ method_name="get_progress_summary_between_dates",
+ api_call_desc=f"api.get_progress_summary_between_dates('{config.week_start.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ "get_body_battery_events": lambda: call_and_display(
+ api.get_body_battery_events,
+ config.week_start.isoformat(),
+ method_name="get_body_battery_events",
+ api_call_desc=f"api.get_body_battery_events('{config.week_start.isoformat()}')",
+ ),
+ # Activities & Workouts
+ "get_activities": lambda: call_and_display(
+ api.get_activities,
+ config.start,
+ config.default_limit,
+ method_name="get_activities",
+ api_call_desc=f"api.get_activities({config.start}, {config.default_limit})",
+ ),
+ "get_last_activity": lambda: call_and_display(
+ api.get_last_activity,
+ method_name="get_last_activity",
+ api_call_desc="api.get_last_activity()",
+ ),
+ "get_activities_fordate": lambda: call_and_display(
+ api.get_activities_fordate,
+ config.today.isoformat(),
+ method_name="get_activities_fordate",
+ api_call_desc=f"api.get_activities_fordate('{config.today.isoformat()}')",
+ ),
+ "get_activity_types": lambda: call_and_display(
+ api.get_activity_types,
+ method_name="get_activity_types",
+ api_call_desc="api.get_activity_types()",
+ ),
+ "get_workouts": lambda: call_and_display(
+ api.get_workouts,
+ method_name="get_workouts",
+ api_call_desc="api.get_workouts()",
+ ),
+ "upload_activity": lambda: upload_activity_file(api),
+ "download_activities": lambda: download_activities_by_date(api),
+ "get_activity_splits": lambda: get_activity_splits_data(api),
+ "get_activity_typed_splits": lambda: get_activity_typed_splits_data(api),
+ "get_activity_split_summaries": lambda: get_activity_split_summaries_data(
+ api
+ ),
+ "get_activity_weather": lambda: get_activity_weather_data(api),
+ "get_activity_hr_in_timezones": lambda: get_activity_hr_timezones_data(api),
+ "get_activity_details": lambda: get_activity_details_data(api),
+ "get_activity_gear": lambda: get_activity_gear_data(api),
+ "get_activity": lambda: get_single_activity_data(api),
+ "get_activity_exercise_sets": lambda: get_activity_exercise_sets_data(api),
+ "get_workout_by_id": lambda: get_workout_by_id_data(api),
+ "download_workout": lambda: download_workout_data(api),
+ "upload_workout": lambda: upload_workout_data(api),
+ # Body Composition & Weight
+ "get_body_composition": lambda: call_and_display(
+ api.get_body_composition,
+ config.today.isoformat(),
+ method_name="get_body_composition",
+ api_call_desc=f"api.get_body_composition('{config.today.isoformat()}')",
+ ),
+ "get_weigh_ins": lambda: call_and_display(
+ api.get_weigh_ins,
+ config.week_start.isoformat(),
+ config.today.isoformat(),
+ method_name="get_weigh_ins",
+ api_call_desc=f"api.get_weigh_ins('{config.week_start.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ "get_daily_weigh_ins": lambda: call_and_display(
+ api.get_daily_weigh_ins,
+ config.today.isoformat(),
+ method_name="get_daily_weigh_ins",
+ api_call_desc=f"api.get_daily_weigh_ins('{config.today.isoformat()}')",
+ ),
+ "add_weigh_in": lambda: add_weigh_in_data(api),
+ "set_body_composition": lambda: set_body_composition_data(api),
+ "add_body_composition": lambda: add_body_composition_data(api),
+ "delete_weigh_ins": lambda: delete_weigh_ins_data(api),
+ "delete_weigh_in": lambda: delete_weigh_in_data(api),
+ # Goals & Achievements
+ "get_personal_records": lambda: call_and_display(
+ api.get_personal_record,
+ method_name="get_personal_record",
+ api_call_desc="api.get_personal_record()",
+ ),
+ "get_earned_badges": lambda: call_and_display(
+ api.get_earned_badges,
+ method_name="get_earned_badges",
+ api_call_desc="api.get_earned_badges()",
+ ),
+ "get_adhoc_challenges": lambda: call_and_display(
+ api.get_adhoc_challenges,
+ config.start,
+ config.default_limit,
+ method_name="get_adhoc_challenges",
+ api_call_desc=f"api.get_adhoc_challenges({config.start}, {config.default_limit})",
+ ),
+ "get_available_badge_challenges": lambda: call_and_display(
+ api.get_available_badge_challenges,
+ config.start_badge,
+ config.default_limit,
+ method_name="get_available_badge_challenges",
+ api_call_desc=f"api.get_available_badge_challenges({config.start_badge}, {config.default_limit})",
+ ),
+ "get_active_goals": lambda: call_and_display(
+ api.get_goals,
+ status="active",
+ start=config.start,
+ limit=config.default_limit,
+ method_name="get_goals",
+ api_call_desc=f"api.get_goals(status='active', start={config.start}, limit={config.default_limit})",
+ ),
+ "get_future_goals": lambda: call_and_display(
+ api.get_goals,
+ status="future",
+ start=config.start,
+ limit=config.default_limit,
+ method_name="get_goals",
+ api_call_desc=f"api.get_goals(status='future', start={config.start}, limit={config.default_limit})",
+ ),
+ "get_past_goals": lambda: call_and_display(
+ api.get_goals,
+ status="past",
+ start=config.start,
+ limit=config.default_limit,
+ method_name="get_goals",
+ api_call_desc=f"api.get_goals(status='past', start={config.start}, limit={config.default_limit})",
+ ),
+ "get_badge_challenges": lambda: call_and_display(
+ api.get_badge_challenges,
+ config.start_badge,
+ config.default_limit,
+ method_name="get_badge_challenges",
+ api_call_desc=f"api.get_badge_challenges({config.start_badge}, {config.default_limit})",
+ ),
+ "get_non_completed_badge_challenges": lambda: call_and_display(
+ api.get_non_completed_badge_challenges,
+ config.start_badge,
+ config.default_limit,
+ method_name="get_non_completed_badge_challenges",
+ api_call_desc=f"api.get_non_completed_badge_challenges({config.start_badge}, {config.default_limit})",
+ ),
+ "get_inprogress_virtual_challenges": lambda: get_virtual_challenges_data(
+ api
+ ),
+ "get_race_predictions": lambda: call_and_display(
+ api.get_race_predictions,
+ method_name="get_race_predictions",
+ api_call_desc="api.get_race_predictions()",
+ ),
+ "get_hill_score": lambda: call_and_display(
+ api.get_hill_score,
+ config.week_start.isoformat(),
+ config.today.isoformat(),
+ method_name="get_hill_score",
+ api_call_desc=f"api.get_hill_score('{config.week_start.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ "get_endurance_score": lambda: call_and_display(
+ api.get_endurance_score,
+ config.week_start.isoformat(),
+ config.today.isoformat(),
+ method_name="get_endurance_score",
+ api_call_desc=f"api.get_endurance_score('{config.week_start.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ "get_available_badges": lambda: call_and_display(
+ api.get_available_badges,
+ method_name="get_available_badges",
+ api_call_desc="api.get_available_badges()",
+ ),
+ "get_in_progress_badges": lambda: call_and_display(
+ api.get_in_progress_badges,
+ method_name="get_in_progress_badges",
+ api_call_desc="api.get_in_progress_badges()",
+ ),
+ # Device & Technical
+ "get_devices": lambda: call_and_display(
+ api.get_devices,
+ method_name="get_devices",
+ api_call_desc="api.get_devices()",
+ ),
+ "get_device_alarms": lambda: call_and_display(
+ api.get_device_alarms,
+ method_name="get_device_alarms",
+ api_call_desc="api.get_device_alarms()",
+ ),
+ "get_solar_data": lambda: get_solar_data(api),
+ "request_reload": lambda: call_and_display(
+ api.request_reload,
+ config.today.isoformat(),
+ method_name="request_reload",
+ api_call_desc=f"api.request_reload('{config.today.isoformat()}')",
+ ),
+ "get_device_settings": lambda: get_device_settings_data(api),
+ "get_device_last_used": lambda: call_and_display(
+ api.get_device_last_used,
+ method_name="get_device_last_used",
+ api_call_desc="api.get_device_last_used()",
+ ),
+ "get_primary_training_device": lambda: call_and_display(
+ api.get_primary_training_device,
+ method_name="get_primary_training_device",
+ api_call_desc="api.get_primary_training_device()",
+ ),
+ # Gear & Equipment
+ "get_gear": lambda: get_gear_data(api),
+ "get_gear_defaults": lambda: get_gear_defaults_data(api),
+ "get_gear_stats": lambda: get_gear_stats_data(api),
+ "get_gear_activities": lambda: get_gear_activities_data(api),
+ "set_gear_default": lambda: set_gear_default_data(api),
+ "track_gear_usage": lambda: track_gear_usage_data(api),
+ # Hydration & Wellness
+ "get_hydration_data": lambda: call_and_display(
+ api.get_hydration_data,
+ config.today.isoformat(),
+ method_name="get_hydration_data",
+ api_call_desc=f"api.get_hydration_data('{config.today.isoformat()}')",
+ ),
+ "get_pregnancy_summary": lambda: call_and_display(
+ api.get_pregnancy_summary,
+ method_name="get_pregnancy_summary",
+ api_call_desc="api.get_pregnancy_summary()",
+ ),
+ "get_all_day_events": lambda: call_and_display(
+ api.get_all_day_events,
+ config.week_start.isoformat(),
+ method_name="get_all_day_events",
+ api_call_desc=f"api.get_all_day_events('{config.week_start.isoformat()}')",
+ ),
+ "add_hydration_data": lambda: add_hydration_data_entry(api),
+ "set_blood_pressure": lambda: set_blood_pressure_data(api),
+ "get_menstrual_data_for_date": lambda: call_and_display(
+ api.get_menstrual_data_for_date,
+ config.today.isoformat(),
+ method_name="get_menstrual_data_for_date",
+ api_call_desc=f"api.get_menstrual_data_for_date('{config.today.isoformat()}')",
+ ),
+ "get_menstrual_calendar_data": lambda: call_and_display(
+ api.get_menstrual_calendar_data,
+ config.week_start.isoformat(),
+ config.today.isoformat(),
+ method_name="get_menstrual_calendar_data",
+ api_call_desc=f"api.get_menstrual_calendar_data('{config.week_start.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ # Blood Pressure Management
+ "delete_blood_pressure": lambda: delete_blood_pressure_data(api),
+ # Activity Management
+ "set_activity_name": lambda: set_activity_name_data(api),
+ "set_activity_type": lambda: set_activity_type_data(api),
+ "create_manual_activity": lambda: create_manual_activity_data(api),
+ "delete_activity": lambda: delete_activity_data(api),
+ "get_activities_by_date": lambda: call_and_display(
+ api.get_activities_by_date,
+ config.today.isoformat(),
+ config.today.isoformat(),
+ method_name="get_activities_by_date",
+ api_call_desc=f"api.get_activities_by_date('{config.today.isoformat()}', '{config.today.isoformat()}')",
+ ),
+ # System & Export
+ "create_health_report": lambda: DataExporter.create_health_report(api),
+ "remove_tokens": lambda: remove_stored_tokens(),
+ "disconnect": lambda: disconnect_api(api),
+ # GraphQL Queries
+ "query_garmin_graphql": lambda: query_garmin_graphql_data(api),
+ }
+
+ if key in api_methods:
+ print(f"\n🔄 Executing: {key}")
+ api_methods[key]()
+ else:
+ print(f"❌ API method '{key}' not implemented yet. You can add it later!")
+
+ except Exception as e:
+ print(f"❌ Error executing {key}: {e}")
+
+
+def remove_stored_tokens():
+ """Remove stored login tokens."""
+ try:
+ import os
+ import shutil
+
+ token_path = os.path.expanduser(config.tokenstore)
+ if os.path.isdir(token_path):
+ shutil.rmtree(token_path)
+ print("✅ Stored login tokens directory removed")
+ else:
+ print("ℹ️ No stored login tokens found")
+ except Exception as e:
+ print(f"❌ Error removing stored login tokens: {e}")
+
+
+def disconnect_api(api: Garmin):
+ """Disconnect from Garmin Connect."""
+ api.logout()
+ print("✅ Disconnected from Garmin Connect")
+
+
+def init_api(email: str | None = None, password: str | None = None) -> Garmin | None:
+ """Initialize Garmin API with smart error handling and recovery."""
+ # First try to login with stored tokens
+ try:
+ print(f"Attempting to login using stored tokens from: {config.tokenstore}")
+
+ garmin = Garmin()
+ garmin.login(config.tokenstore)
+ print("Successfully logged in using stored tokens!")
+ return garmin
+
+ except (
+ FileNotFoundError,
+ GarthHTTPError,
+ GarminConnectAuthenticationError,
+ GarminConnectConnectionError,
+ ):
+ print("No valid tokens found. Requesting fresh login credentials.")
+
+ # Loop for credential entry with retry on auth failure
+ while True:
+ try:
+ # Get credentials if not provided
+ if not email or not password:
+ email = input("Email address: ").strip()
+ password = getpass("Password: ")
+
+ print("Logging in with credentials...")
+ garmin = Garmin(
+ email=email, password=password, is_cn=False, return_on_mfa=True
+ )
+ result1, result2 = garmin.login()
+
+ if result1 == "needs_mfa":
+ print("Multi-factor authentication required")
+
+ mfa_code = get_mfa()
+ print("🔄 Submitting MFA code...")
+
+ try:
+ garmin.resume_login(result2, mfa_code)
+ print("✅ MFA authentication successful!")
+
+ except GarthHTTPError as garth_error:
+ # Handle specific HTTP errors from MFA
+ error_str = str(garth_error)
+ print(f"🔍 Debug: MFA error details: {error_str}")
+
+ if "429" in error_str and "Too Many Requests" in error_str:
+ print("❌ Too many MFA attempts")
+ print("💡 Please wait 30 minutes before trying again")
+ sys.exit(1)
+ elif "401" in error_str or "403" in error_str:
+ print("❌ Invalid MFA code")
+ print("💡 Please verify your MFA code and try again")
+ continue
+ else:
+ # Other HTTP errors - don't retry
+ print(f"❌ MFA authentication failed: {garth_error}")
+ sys.exit(1)
+
+ except GarthException as garth_error:
+ print(f"❌ MFA authentication failed: {garth_error}")
+ print("💡 Please verify your MFA code and try again")
+ continue
+
+ # Save tokens for future use
+ garmin.garth.dump(config.tokenstore)
+ print(f"Login successful! Tokens saved to: {config.tokenstore}")
+
+ return garmin
+
+ except GarminConnectAuthenticationError:
+ print("❌ Authentication failed:")
+ print("💡 Please check your username and password and try again")
+ # Clear the provided credentials to force re-entry
+ email = None
+ password = None
+ continue
+
+ except (
+ FileNotFoundError,
+ GarthHTTPError,
+ GarthException,
+ GarminConnectConnectionError,
+ requests.exceptions.HTTPError,
+ ) as err:
+ print(f"❌ Connection error: {err}")
+ print("💡 Please check your internet connection and try again")
+ return None
+
+ except KeyboardInterrupt:
+ print("\nLogin cancelled by user")
+ return None
+
+
+def main():
+ """Main program loop with funny health status in menu prompt."""
+ # Display export directory information on startup
+ print(f"📁 Exported data will be saved to the directory: '{config.export_dir}'")
+ print("📄 All API responses are written to: 'response.json'")
+
+ api_instance = init_api(config.email, config.password)
+ current_category = None
+
+ while True:
+ try:
+ if api_instance:
+ # Add health status in menu prompt
+ try:
+ summary = api_instance.get_user_summary(config.today.isoformat())
+ hydration_data = None
+ with suppress(Exception):
+ hydration_data = api_instance.get_hydration_data(
+ config.today.isoformat()
+ )
+
+ if summary:
+ steps = summary.get("totalSteps", 0)
+ calories = summary.get("totalKilocalories", 0)
+
+ # Build stats string with hydration if available
+ stats_parts = [f"{steps:,} steps", f"{calories} kcal"]
+
+ if hydration_data and hydration_data.get("valueInML"):
+ hydration_ml = int(hydration_data.get("valueInML", 0))
+ hydration_cups = round(hydration_ml / 240, 1)
+ hydration_goal = hydration_data.get("goalInML", 0)
+
+ if hydration_goal > 0:
+ hydration_percent = round(
+ (hydration_ml / hydration_goal) * 100
+ )
+ stats_parts.append(
+ f"{hydration_ml}ml water ({hydration_percent}% of goal)"
+ )
+ else:
+ stats_parts.append(
+ f"{hydration_ml}ml water ({hydration_cups} cups)"
+ )
+
+ stats_string = " | ".join(stats_parts)
+ print(f"\n📊 Your Stats Today: {stats_string}")
+
+ if steps < 5000:
+ print("🐌 Time to get those legs moving!")
+ elif steps > 15000:
+ print("🏃♂️ You're crushing it today!")
+ else:
+ print("👍 Nice progress! Keep it up!")
+ except Exception as e:
+ print(
+ f"Unable to fetch stats for display: {e}"
+ ) # Silently skip if stats can't be fetched
+
+ # Display appropriate menu
+ if current_category is None:
+ print_main_menu()
+ option = readchar.readkey()
+
+ # Handle main menu options
+ if option == "q":
+ print(
+ "Be active, generate some data to play with next time ;-) Bye!"
+ )
+ break
+ elif option in menu_categories:
+ current_category = option
+ else:
+ print(
+ f"❌ Invalid selection. Use {', '.join(menu_categories.keys())} for categories or 'q' to quit"
+ )
+ else:
+ # In a category - show category menu
+ print_category_menu(current_category)
+ option = readchar.readkey()
+
+ # Handle category menu options
+ if option == "q":
+ current_category = None # Back to main menu
+ elif option in "0123456789abcdefghijklmnopqrstuvwxyz":
+ try:
+ category_data = menu_categories[current_category]
+ category_options = category_data["options"]
+ if option in category_options:
+ api_key = category_options[option]["key"]
+ execute_api_call(api_instance, api_key)
+ else:
+ valid_keys = ", ".join(category_options.keys())
+ print(
+ f"❌ Invalid option selection. Valid options: {valid_keys}"
+ )
+ except Exception as e:
+ print(f"❌ Error processing option {option}: {e}")
+ else:
+ print(
+ "❌ Invalid selection. Use numbers/letters for options or 'q' to go back/quit"
+ )
+
+ except KeyboardInterrupt:
+ print("\nInterrupted by user. Press q to quit.")
+ except Exception as e:
+ print(f"Unexpected error: {e}")
+
+
+if __name__ == "__main__":
+ main()
+
+
+================================================
+FILE: example.py
+================================================
+#!/usr/bin/env python3
+"""
+🏃♂️ Simple Garmin Connect API Example
+=====================================
+
+This example demonstrates the basic usage of python-garminconnect:
+- Authentication with email/password
+- Token storage and automatic reuse
+- MFA (Multi-Factor Authentication) support
+- Comprehensive error handling for all API calls
+- Basic API calls for user stats
+
+For a comprehensive demo of all available API calls, see demo.py
+
+Dependencies:
+pip3 install garth requests
+
+Environment Variables (optional):
+export EMAIL=
+
+
+
+"""
+
+ # Today's Summary Section
+ today_summary = report_data.get("today_summary", {})
+ if today_summary:
+ steps = today_summary.get("totalSteps", 0)
+ calories = today_summary.get("totalKilocalories", 0)
+ distance = (
+ round(today_summary.get("totalDistanceMeters", 0) / 1000, 2)
+ if today_summary.get("totalDistanceMeters")
+ else 0
+ )
+ active_calories = today_summary.get("activeKilocalories", 0)
+
+ html_content += f"""
+ 🏃 Garmin Health Report
+{user_name}
+
+
+"""
+ else:
+ html_content += """
+ 📈 Today's Activity Summary
+
+
+
+
+ 👟 Steps
+{steps:,} steps
+
+
+ 🔥 Calories
+{calories:,} total
+ {active_calories:,} active
+
+
+ 📏 Distance
+{distance} km
+
+
+"""
+
+ # Health Metrics Section
+ health_metrics = report_data.get("health_metrics", {})
+ if health_metrics and any(health_metrics.values()):
+ html_content += """
+ 📈 Today's Activity Summary
+No activity data available for today
+
+
\n"
+ else:
+ html_content += """
+ ❤️ Health Metrics
+
+"""
+
+ # Heart Rate
+ heart_rate = health_metrics.get("heart_rate", {})
+ if heart_rate and isinstance(heart_rate, dict):
+ resting_hr = heart_rate.get("restingHeartRate", "N/A")
+ max_hr = heart_rate.get("maxHeartRate", "N/A")
+ html_content += f"""
+
\n
+
+"""
+
+ # Sleep Data
+ sleep_data = health_metrics.get("sleep", {})
+ if (
+ sleep_data
+ and isinstance(sleep_data, dict)
+ and "dailySleepDTO" in sleep_data
+ ):
+ sleep_seconds = sleep_data["dailySleepDTO"].get("sleepTimeSeconds", 0)
+ sleep_hours = round(sleep_seconds / 3600, 1) if sleep_seconds else 0
+ deep_sleep = sleep_data["dailySleepDTO"].get("deepSleepSeconds", 0)
+ deep_hours = round(deep_sleep / 3600, 1) if deep_sleep else 0
+
+ html_content += f"""
+ 💓 Heart Rate
+{resting_hr} bpm (resting)
+ Max: {max_hr} bpm
+
+
+"""
+
+ # Steps
+ steps_data = health_metrics.get("steps", {})
+ if steps_data and isinstance(steps_data, dict):
+ total_steps = steps_data.get("totalSteps", 0)
+ goal = steps_data.get("dailyStepGoal", 10000)
+ html_content += f"""
+ 😴 Sleep
+{sleep_hours} hours
+ Deep Sleep: {deep_hours} hours
+
+
+"""
+
+ # Stress Data
+ stress_data = health_metrics.get("stress", {})
+ if stress_data and isinstance(stress_data, dict):
+ avg_stress = stress_data.get("avgStressLevel", "N/A")
+ max_stress = stress_data.get("maxStressLevel", "N/A")
+ html_content += f"""
+ 🎯 Step Goal
+{total_steps:,} of {goal:,}
+ Goal: {round((total_steps/goal)*100) if goal else 0}%
+
+
+"""
+
+ # Body Battery
+ body_battery = health_metrics.get("body_battery", [])
+ if body_battery and isinstance(body_battery, list) and body_battery:
+ latest_bb = body_battery[-1] if body_battery else {}
+ charged = latest_bb.get("charged", "N/A")
+ drained = latest_bb.get("drained", "N/A")
+ html_content += f"""
+ 😰 Stress Level
+{avg_stress} avg
+ Max: {max_stress}
+
+
+"""
+
+ html_content += " 🔋 Body Battery
++{charged} charged
+ -{drained} drained
+
+
+"""
+
+ # Weekly Trends Section
+ weekly_data = report_data.get("weekly_data", [])
+ if weekly_data:
+ html_content += """
+ ❤️ Health Metrics
+No health metrics data available
+
+
\n"
+
+ # Recent Activities Section
+ activities = report_data.get("recent_activities", [])
+ if activities:
+ html_content += """
+ 📊 Weekly Trends (Last 7 Days)
+
+"""
+ for daily in weekly_data[:7]: # Show last 7 days
+ date = daily.get("date", "Unknown")
+ steps = daily.get("totalSteps", 0)
+ calories = daily.get("totalKilocalories", 0)
+ distance = (
+ round(daily.get("totalDistanceMeters", 0) / 1000, 2)
+ if daily.get("totalDistanceMeters")
+ else 0
+ )
+
+ html_content += f"""
+
\n
+
+"""
+ html_content += " 📅 {date}
+{steps:,} steps
+
+
+ {calories:,} kcal
+ {distance} km
+
+
\n"
+ else:
+ html_content += """
+ 🏃 Recent Activities
+""" + for activity in activities[:5]: # Show last 5 activities + name = activity.get("activityName", "Unknown Activity") + activity_type = activity.get("activityType", {}).get( + "typeKey", "Unknown" + ) + date = ( + activity.get("startTimeLocal", "").split("T")[0] + if activity.get("startTimeLocal") + else "Unknown" + ) + duration = activity.get("duration", 0) + duration_min = round(duration / 60, 1) if duration else 0 + distance = ( + round(activity.get("distance", 0) / 1000, 2) + if activity.get("distance") + else 0 + ) + calories = activity.get("calories", 0) + avg_hr = activity.get("avgHR", 0) + + html_content += f""" +
+
+"""
+ html_content += " {name} ({activity_type})
+
+
+ Date: {date}
+ Duration: {duration_min} min
+ Distance: {distance} km
+ Calories: {calories}
+ Avg HR: {avg_hr} bpm
+
+
+"""
+
+ # Device Information
+ device_info = report_data.get("device_info", [])
+ if device_info:
+ html_content += """
+ 🏃 Recent Activities
+No recent activities found
+
+
\n"
+
+ # Footer
+ html_content += f"""
+
+ ⌚ Device Information
+
+"""
+ for device in device_info:
+ device_name = device.get("displayName", "Unknown Device")
+ model = device.get("productDisplayName", "Unknown Model")
+ version = device.get("softwareVersion", "Unknown")
+
+ html_content += f"""
+
\n
+
+"""
+ html_content += " {device_name}
+Model: {model}
+ Software: {version}
+