### Command Line Interface for GarminDB Data Management (Bash)

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This section provides examples of using the `garmindb_cli.py` script for various data management tasks. It covers initial setup, daily updates, selective data downloads, database rebuilding, backups, and exporting activities to TCX format or viewing them in mapping software.

```bash
# Initial setup: Download all data and create database
garmindb_cli.py --all --download --import --analyze

# Daily incremental update: Get latest data only
garmindb_cli.py --all --download --import --analyze --latest

# Download and import specific data types
garmindb_cli.py --activities --monitoring --download --import
garmindb_cli.py --sleep --weight --rhr --download --import --latest

# Rebuild database from previously downloaded files
garmindb_cli.py --rebuild_db

# Backup database files
garmindb_cli.py --backup

# Export an activity to TCX format by activity ID
garmindb_cli.py --export-activity 12345678

# Open activity in Google Earth or BaseCamp
garmindb_cli.py --google-earth-activity 12345678
garmindb_cli.py --basecamp-activity 12345678
```

--------------------------------

### GarminDB Configuration File Setup

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This JSON configuration file sets up credentials, data download parameters, and enabled statistics for the GarminDB project. It specifies user credentials for Garmin Connect, data retention policies, and the types of health statistics to be tracked and downloaded.

```json
{
  "credentials": {
    "user": "your_garmin_email@example.com",
    "password": "your_garmin_password"
  },
  "data": {
    "download_days": 365,
    "monitoring_start_date": "2020-01-01",
    "sleep_start_date": "2020-01-01",
    "weight_start_date": "2020-01-01",
    "rhr_start_date": "2020-01-01"
  },
  "settings": {
    "activities": {
      "latest_activity_count": 10,
      "all_activity_count": 1000
    },
    "enabled_stats": [
      "monitoring",
      "steps",
      "itime",
      "sleep",
      "rhr",
      "weight",
      "activities"
    ]
  },
  "course_views": {
    "steps": [12345, 67890]
  }
}
```

--------------------------------

### Display Course Activity Summary using Python

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/course.ipynb

This Python script fetches and displays a summary of all activities for a given course ID from the garmindb. It utilizes libraries like snakemd for documentation generation and fitfile for unit conversions. The output includes the total number of activities, fastest and slowest activities, and a table detailing activity type, start time, ID, name, distance, time, pace, and speed.

```python
from IPython.display import display, Markdown
import snakemd

import fitfile
from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminDb, Attributes, ActivitiesDb, Activities, ActivityLaps, ActivityRecords, StepsActivities

from jupyter_funcs import format_number


doc = snakemd.new_doc()

course_id = input('Enter the id of a course to summarize')

doc.add_heading(f"Analysis for Course {course_id}", 2)

gc_config = GarminConnectConfigManager()
db_params_dict = gc_config.get_db_params()

garmin_db = GarminDb(db_params_dict)
measurement_system = Attributes.measurements_type(garmin_db)
unit_strings = fitfile.units.unit_strings[measurement_system]
distance_units = unit_strings[fitfile.units.UnitTypes.distance_long]

activity_db = ActivitiesDb(db_params_dict)

activities = Activities.get_by_course_id(activity_db, course_id)

activities_count = len(activities)
fastest_activity = Activities.get_fastest_by_course_id(activity_db, course_id)
slowest_activity = Activities.get_slowest_by_course_id(activity_db, course_id)

doc.add_paragraph(f'{activities_count} activities using this course')

def __activity_data(activity, title):
    if activity.is_steps_activity():
        steps_activity = StepsActivities.get(activity_db, activity.activity_id)
        return [title, activity.start_time, activity.activity_id, activity.name, format_number(activity.distance), activity.elapsed_time, steps_activity.avg_pace, format_number(activity.avg_speed)]
    return [title, activity.start_time, activity.activity_id, activity.name, format_number(activity.distance), activity.elapsed_time, '', format_number(activity.avg_speed)]

doc.add_table(
    ['Type', 'On', 'Id', 'Name', f'Distance ({unit_strings[fitfile.units.UnitTypes.distance_long]})', 'Time', f'Pace ({unit_strings[fitfile.units.UnitTypes.pace]})', f'Speed ({unit_strings[fitfile.units.UnitTypes.speed]})'],
    [
        __activity_data(activities[0], "First"),
        __activity_data(activities[-1], "Latest"),
        __activity_data(fastest_activity, "Fastest"),
        __activity_data(slowest_activity, "Slowest")
    ])

display(Markdown(str(doc)))

```

--------------------------------

### Download Health Data from Garmin Connect (Python)

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This Python script demonstrates how to download daily monitoring data, sleep data, weight data, and activities from Garmin Connect. It utilizes the `garmindb` library, requiring configuration setup and login. The script downloads data for a specified date range and allows for overwriting existing files.

```python
from garmindb import Download, GarminConnectConfigManager

# Initialize with configuration file
config = GarminConnectConfigManager()
download = Download(config)

# Login to Garmin Connect
if download.login():
    # Download the last 30 days of monitoring data
    import datetime
    end_date = datetime.date.today()
    start_date = end_date - datetime.timedelta(days=30)

    # Get daily summaries (steps, calories, distance, etc.)
    monitoring_dir = config.get_monitoring_dir(end_date.year)
    download.get_daily_summaries(
        config.get_monitoring_dir,
        start_date,
        30,
        overwrite=False
    )

    # Get sleep data
    sleep_dir = config.get_sleep_dir()
    download.get_sleep(sleep_dir, start_date, 30, overwrite=False)

    # Get weight data
    weight_dir = config.get_weight_dir()
    download.get_weight(weight_dir, start_date, 30, overwrite=False)

    # Get activities (last 100)
    activities_dir = config.get_activities_dir()
    download.get_activity_types(activities_dir, overwrite=False)
    download.get_activities(activities_dir, activity_count=100, overwrite=False)
```

--------------------------------

### Add Heading and Get Distinct Course IDs - Python

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/activities.ipynb

This Python code snippet demonstrates how to add a heading to a document, retrieve distinct course IDs from a Garmin activity database using the Activities.get_col_distinct function, and then display the results as Markdown. It requires the 'garmin_act_db' object and the Activities module.

```python
doc.add_heading("Courses", 3)
courses = Activities.get_col_distinct(garmin_act_db, Activities.course_id)
doc.add_paragraph(str(courses))

display(Markdown(str(doc)))
```

--------------------------------

### Analyze Garmin Data and Generate Summary Tables

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This snippet shows how to initialize an analyzer with configuration and then generate various summary tables for Garmin data. It aggregates metrics like heart rate, activity data, sleep details, intensity minutes, and training effects. It also demonstrates creating dynamic database views for course comparisons.

```python
from garmindb import Analyze, GarminConnectConfigManager

# Initialize analyzer with configuration
config = GarminConnectConfigManager()
analyze = Analyze(config, debug=0)

# Generate daily, weekly, monthly, and yearly summaries
# This creates summary tables aggregating:
# - Heart rate statistics (resting, average, max)
# - Activity metrics (steps, distance, calories)
# - Sleep data (total sleep, deep sleep, REM, awake time)
# - Intensity minutes and floors climbed
# - Weight trends
# - Training effects and VO2 max
analyze.summary()

# Create dynamic database views for specific courses
# Allows comparison of all activities on the same course
analyze.create_dynamic_views()
```

--------------------------------

### Initialize Garmin Data Fetching and Graphing

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/summary.ipynb

Initializes the necessary components for fetching Garmin activity data and generating graphs. It sets up the configuration manager, database connection, and graph utility. Dependencies include IPython, snakemd, datetime, and custom modules like garmindb, jupyter_funcs, and graphs.

```python
from IPython.display import display, Markdown
import snakemd
import datetime

from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminSummaryDb, YearsSummary

from jupyter_funcs import format_number
from graphs import Graph

years_to_display = 4
days_to_display = (years_to_display * 365)

gc_config = GarminConnectConfigManager()
db_params_dict = gc_config.get_db_params()
garmin_sum_db = GarminSummaryDb(db_params_dict)

graph = Graph()

```

--------------------------------

### Initialize Garmin Database Connection and Retrieve Data

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/daily_trends.ipynb

Sets up the date range for data retrieval, initializes the GarminConnectConfigManager and GarminDb objects, and fetches daily summary and sleep data for the specified period. The fetched data is stored in 'data' and 'sleep' variables.

```python
# start date
start_ts = datetime.datetime.combine(datetime.date(year=2022, month=5, day=1), datetime.datetime.min.time())
# end date (today)
end_ts = datetime.datetime.combine(datetime.date.today(), datetime.datetime.max.time())

gc_config = GarminConnectConfigManager()
db_params = gc_config.get_db_params()

garmin_db = GarminDb(db_params)
sum_db = SummaryDb(db_params, False)
data = DaysSummary.get_for_period(sum_db, start_ts, end_ts, DaysSummary)
sleep = Sleep.get_for_period(garmin_db, start_ts, end_ts)

time = [entry.day for entry in data]
```

--------------------------------

### Initialize GarminDB and Retrieve Activities

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/exercise_over_time.ipynb

Initializes the GarminDb and ActivitiesDb objects using configuration from GarminConnectConfigManager. It then retrieves the latest activities from the database. This snippet sets up the necessary objects and data for subsequent analysis and visualization.

```python
%matplotlib inline
from IPython.display import display, Markdown
from datetime import time, datetime, date, timedelta
import snakemd
import matplotlib
import matplotlib.pyplot as plt
import matplotlib.dates as dates

import fitfile
from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminDb, Attributes, ActivitiesDb, Activities, StepsActivities, ActivityLaps, ActivityRecords
from idbutils.list_and_dict import list_not_none

from jupyter_funcs import format_number

gc_config = GarminConnectConfigManager()
db_params_dict = gc_config.get_db_params()

garmin_db = GarminDb(db_params_dict)
garmin_act_db = ActivitiesDb(db_params_dict)
measurement_system = Attributes.measurements_type(garmin_db)
unit_strings = fitfile.units.unit_strings[measurement_system]
distance_units = {"kilometers": "km"}[unit_strings[fitfile.units.UnitTypes.distance_long]]

def __format_activity(activity):
    if activity:
        return [activity.activity_id, activity.name, activity.start_time.strftime("%y%m%d"), activity.sport, format_number(activity.distance, 1), activity.elapsed_time, activity.moving_time, format_number(activity.avg_speed, 1), format_number(activity.calories), activity.training_load, activity.training_effect, activity.anaerobic_training_effect]
    return ['', '', '', '', '', '', '', '', '', '', '', '']


activities = Activities.get_latest(garmin_act_db, Activities.row_count(garmin_act_db))
```

--------------------------------

### Import Downloaded Data into SQLite Database (Python)

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This Python script illustrates how to import downloaded Garmin data into a SQLite database. It covers importing user settings, personal information, weight data, and monitoring data. The script uses the `garmindb` library and requires configuration to be set up. It also handles measurement system detection for data processing.

```python
from garmindb import GarminConnectConfigManager
from garmindb import (
    GarminUserSettings, GarminPersonalInformation, GarminSocialProfile,
    GarminWeightData, GarminSummaryData, GarminMonitoringFitData,
    GarminSleepData, GarminRhrData, GarminActivitiesFitData,
    GarminJsonSummaryData, GarminJsonDetailsData
)
from garmindb import (
    FitFileProcessor, ActivityFitFileProcessor,
    MonitoringFitFileProcessor, PluginManager
)
from garmindb.garmindb import GarminDb, Attributes

# Setup configuration and database parameters
config = GarminConnectConfigManager()
db_params = config.get_db_params()
plugin_manager = PluginManager(config.get_plugins_dir(), db_params)

# Import user profile and settings (do this first)
fit_files_dir = config.get_fit_files_dir()
gus = GarminUserSettings(db_params, fit_files_dir, debug=0)
if gus.file_count() > 0:
    gus.process()

gpi = GarminPersonalInformation(db_params, fit_files_dir, debug=0)
if gpi.file_count() > 0:
    gpi.process()

# Get measurement system (metric vs imperial)
gdb = GarminDb(db_params)
measurement_system = Attributes.measurements_type(gdb)

# Import weight data from JSON files
weight_dir = config.get_weight_dir()
gwd = GarminWeightData(db_params, weight_dir, latest=True,
                       measurement_system=measurement_system, debug=0)
if gwd.file_count() > 0:
    gwd.process()

# Import monitoring data (steps, heart rate, intensity minutes)
monitoring_dir = config.get_monitoring_base_dir()
gsd = GarminSummaryData(db_params, monitoring_dir, latest=True,
                        measurement_system=measurement_system, debug=0)
if gsd.file_count() > 0:
    gsd.process()
```

--------------------------------

### Initialize Garmindb Components and Unit Conversions

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/activities_dashboard.ipynb

Initializes Garmindb components and performs unit conversions based on the measurement system. This snippet sets up database connections, retrieves measurement units, and converts distance values.

```python
gc_config = GarminConnectConfigManager()
db_params_dict = gc_config.get_db_params()
garmin_db = GarminDb(db_params_dict)
garmin_act_db = ActivitiesDb(db_params_dict)
measurement_system = Attributes.measurements_type(garmin_db)
unit_strings = fitfile.units.unit_strings[measurement_system]
distance_units = unit_strings[fitfile.units.UnitTypes.distance_long]
altitude_units = unit_strings[fitfile.units.UnitTypes.altitude]
temp_units = unit_strings[fitfile.units.UnitTypes.tempurature]
group_activities_by_lap_distance_converted = [Distance.from_meters_or_feet(distance).kms_or_miles() for distance in group_activities_by_lap_distance]
activities_dict = {key: [] for key in group_activities_by_name + group_activities_by_lap_distance}
current_selected_lap = "None"
current_selected_pace = "None"
Treino = ['All'] + list(activities_dict.keys())
activities_list = []
complete_laps_list = []
custom_layout = Layout(width='max-content')
custom_style = {'description_width': '100px'}
lap_distance_precision = Distance.from_meters_or_feet(lap_distance_precision).kms_or_miles()
```

--------------------------------

### Query Garmin Activities from Database

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This snippet illustrates how to query activity data from a Garmin database. It demonstrates fetching all running activities, finding the fastest, longest, and most recent activities for a specific sport, and retrieving activities associated with a particular course ID. Requires database connection parameters and fitfile definitions.

```python
from garmindb.garmindb import ActivitiesDb, Activities
from garmindb import GarminConnectConfigManager
import fitfile

# Connect to activities database
config = GarminConnectConfigManager()
db_params = config.get_db_params()
act_db = ActivitiesDb(db_params)

# Get all running activities
running_activities = Activities.get_by_sport(act_db, 'running')
for activity in running_activities:
    print(f"{activity.start_time}: {activity.name}")
    print(f"  Distance: {activity.distance} km")
    print(f"  Duration: {activity.elapsed_time}")
    print(f"  Avg HR: {activity.avg_hr} bpm")
    print(f"  Calories: {activity.calories}")

# Get fastest activity for a sport
sport = fitfile.Sport.running
fastest = Activities.get_fastest_by_sport(act_db, sport)
if fastest:
    print(f"Fastest run: {fastest.name} at {fastest.avg_speed} km/h")

# Get longest activity for a sport
longest = Activities.get_longest_by_sport(act_db, sport)
if longest:
    print(f"Longest run: {longest.name} - {longest.distance} km")

# Get activities for a specific course
course_activities = Activities.get_by_course_id(act_db, course_id=12345)
for activity in course_activities:
    print(f"{activity.start_time}: {activity.avg_speed} km/h")

# Get most recent activity for a sport
latest = Activities.get_latest_by_sport(act_db, sport)
if latest:
    print(f"Latest run: {latest.name} on {latest.start_time}")
```

--------------------------------

### Import Garmindb Libraries

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/activities_dashboard.ipynb

Imports essential libraries from garmindb and other Python packages for data handling, configuration management, and activity analysis. Dependencies include datetime, ipywidgets, pandas, and fitfile.

```python
import datetime
from ipywidgets import fixed, Layout, interactive
from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminDb, Attributes, ActivitiesDb, Activities, ActivityLaps, ActivityRecords
from maps import ActivityMap
from collections import ChainMap
import fitfile
from fitfile import Distance
import pandas as pd
import datetime
import math
```

--------------------------------

### Import Garmin Data (FIT, JSON, Sleep)

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This snippet demonstrates how to import various types of data from a Garmin device, including monitoring FIT files, sleep data, and activities from both JSON and FIT files. It utilizes different classes from the garmindb library to handle each data type and processes them if new files are detected.

```python
from garmindb import GarminMonitoringFitData, GarminSleepData, GarminJsonSummaryData, GarminJsonDetailsData, GarminActivitiesFitData
from garmindb.processors import MonitoringFitFileProcessor, ActivityFitFileProcessor

# Assuming db_params, config, and plugin_manager are already defined

# Import monitoring FIT files
gfd = GarminMonitoringFitData(monitoring_dir, latest=True,
                              measurement_system=measurement_system, debug=0)
if gfd.file_count() > 0:
    gfd.process_files(
        MonitoringFitFileProcessor(db_params, plugin_manager, debug=0)
    )

# Import sleep data
gsd = GarminSleepData(db_params, config.get_sleep_dir(), latest=True, debug=0)
if gsd.file_count() > 0:
    gsd.process()

# Import activities from JSON files
activities_dir = config.get_activities_dir()
gjsd = GarminJsonSummaryData(db_params, activities_dir, latest=True,
                             measurement_system=measurement_system, debug=0)
if gjsd.file_count() > 0:
    gjsd.process()

gdjd = GarminJsonDetailsData(db_params, activities_dir, latest=True,
                             measurement_system=measurement_system, debug=0)
if gdjd.file_count() > 0:
    gdjd.process()

# Import activity FIT files
gfd = GarminActivitiesFitData(activities_dir, latest=True,
                              measurement_system=measurement_system, debug=0)
if gfd.file_count() > 0:
    gfd.process_files(
        ActivityFitFileProcessor(db_params, plugin_manager, debug=0)
    )
```

--------------------------------

### Query Garmin Weight Data with SQLAlchemy

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This Python snippet demonstrates how to query weight data from the GarminDB using SQLAlchemy. It connects to the database, filters weight entries for the last 30 days, and prints the date and weight in kilograms. This requires the `garmindb` library and a configured database connection.

```python
from garmindb.garmindb import GarminDb, Weight
from garmindb import GarminConnectConfigManager
import datetime

config = GarminConnectConfigManager()
db_params = config.get_db_params()

garmin_db = GarminDb(db_params)
with garmin_db.managed_session() as session:
    # Get weight entries for last 30 days
    start_date = datetime.date.today() - datetime.timedelta(days=30)
    weights = session.query(Weight)
        .filter(Weight.day >= start_date)
        .order_by(Weight.day.desc())
        .all()

    for w in weights:
        print(f"{w.day}: {w.weight} kg")
```

--------------------------------

### Generate Steps Summary Graph

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/summary.ipynb

Creates a summary table and graph for daily steps over multiple years. It includes the total steps, daily steps goal, and the percentage of the goal achieved. The data is formatted and presented using snakemd for tables and a custom Graph object for visualization. This snippet requires the initialized Garmin database connection and graph object.

```python
years_data = []
current_year = datetime.date.today().year
for year in range(current_year - years_to_display, current_year + 1):
    year_data = YearsSummary.get_year(garmin_sum_db, year)
    years_data.append([year, year_data.steps, year_data.steps_goal, format_number((year_data.steps_goal / year_data.steps) * 100.0)])

doc = snakemd.new_doc()
doc.add_heading("Steps", 3)
doc.add_table(['Year', 'Steps', 'Steaps Goal', 'Steps Goal %'], years_data)
display(Markdown(str(doc)))
graph.graph_activity('steps')

```

--------------------------------

### Format and Display Activities Table

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/exercise_over_time.ipynb

Formats a list of Garmin activities into a markdown table using snakemd. It can filter activities by name if provided. The table includes activity ID, name, date, sport, distance, time metrics, speed, calories, and training load.

```python
def debug(name=None):
    doc = snakemd.new_doc()
    if (name is None):
        rows = [__format_activity(activity) for activity in activities]
    else:
        rows = [__format_activity(activity) for activity in activities if ((activity.name is not None) and (name in activity.name.lower()))]
    doc.add_heading("All Recorded Activities", 3)
    doc.add_table(['Id', 'Name', 'Date', 'Sport', f'Dist ({distance_units})', 'Elapsed Time', f'Moving Time', f'Speed ({unit_strings[fitfile.units.UnitTypes.speed]})', 'Calories', 'Exercise Load', 'Aerobic effect', 'Anaerobic effect'], rows)
    display(Markdown(str(doc)))
```

--------------------------------

### Copy Data from USB-Mounted Garmin Device

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This snippet provides Python code to copy various types of data from a USB-mounted Garmin device. It includes functions to copy device settings, activities, monitoring data (daily metrics), and sleep data to specified directories on the computer. Requires configuration manager.

```python
from garmindb import Copy, GarminConnectConfigManager, Statistics
import datetime

# Initialize with configuration
config = GarminConnectConfigManager()
copy = Copy(config)

# Copy device settings files
settings_dir = config.get_fit_files_dir()
copy.copy_settings(settings_dir)

# Copy activities from device
activities_dir = config.get_activities_dir()
copy.copy_activities(activities_dir, latest=True)

# Copy monitoring data (daily metrics)
current_year = datetime.datetime.now().year
monitoring_dir = config.get_monitoring_dir(current_year)
copy.copy_monitoring(monitoring_dir, latest=True)

# Copy sleep data
copy.copy_sleep(monitoring_dir, latest=True)
```

--------------------------------

### Query Garmin Heart Rate Monitoring Data with SQLAlchemy

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This Python snippet demonstrates querying continuous heart rate monitoring data for a specific day from the `MonitoringDb` using SQLAlchemy. It filters records by timestamp within a given day and prints the timestamp and heart rate in beats per minute. This requires the `garmindb` library.

```python
from garmindb.garmindb import MonitoringDb, MonitoringHeartRate
from garmindb import GarminConnectConfigManager
import datetime

config = GarminConnectConfigManager()
db_params = config.get_db_params()

mon_db = MonitoringDb(db_params)
with mon_db.managed_session() as session:
    # Get heart rate data for a day
    day_start = datetime.datetime(2024, 1, 15, 0, 0, 0)
    day_end = datetime.datetime(2024, 1, 15, 23, 59, 59)

    hr_data = session.query(MonitoringHeartRate)
        .filter(MonitoringHeartRate.timestamp >= day_start)
        .filter(MonitoringHeartRate.timestamp <= day_end)
        .order_by(MonitoringHeartRate.timestamp)
        .all()

    for hr in hr_data:
        print(f"{hr.timestamp}: {hr.heart_rate} bpm")
```

--------------------------------

### Import Libraries for Garmin Data Analysis

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/daily_trends.ipynb

Imports necessary Python libraries for data manipulation, date handling, plotting, and interaction with the garmindb library. Ensures all required modules are available for subsequent operations.

```python
%matplotlib inline
import matplotlib.pyplot as plt
import matplotlib.dates as dates
import math

import numpy as np
import datetime
from IPython.display import display
import pandas as pd

from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminSummaryDb, DaysSummary, MonitoringDb, MonitoringHeartRate, Sleep, GarminDb
from garmindb.summarydb import DaysSummary, SummaryDb

from jupyter_funcs import format_number
from graphs import Graph
```

--------------------------------

### Export Garmin Activity to TCX File

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This snippet demonstrates exporting a specific Garmin activity, identified by its ID, to a TCX file. It involves setting up the exporter with an output directory, activity ID, and measurement system, then processing the activity data and writing it to a file. Requires database connection parameters.

```python
from garmindb import ActivityExporter, GarminConnectConfigManager
from garmindb.garmindb import GarminDb, Attributes
import tempfile

# Setup
config = GarminConnectConfigManager()
db_params = config.get_db_params()

# Get measurement system from database
garmin_db = GarminDb(db_params)
measurement_system = Attributes.measurements_type(garmin_db)

# Export activity by ID
activity_id = 12345678
output_dir = tempfile.mkdtemp()  # or use specific directory

exporter = ActivityExporter(
    directory=output_dir,
    activity_id=activity_id,
    measurement_system=measurement_system,
    debug=0
)

# Process the activity data and generate TCX
exporter.process(db_params)

# Write to file
tcx_file = exporter.write(f'activity_{activity_id}.tcx')
print(f"Activity exported to: {tcx_file}")
```

--------------------------------

### Generate Garmindb Report: Goals and Low Battery Devices (Python)

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/checkup.ipynb

This Python script utilizes the garmindb library to fetch user goals and check the battery status of connected Garmin devices. It generates a markdown document summarizing the findings, highlighting devices with low battery levels. Dependencies include IPython, snakemd, and various modules from the fitfile and garmindb libraries.

```python
from IPython.display import display, Markdown
import snakemd

import fitfile
import garmindb
from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminDb, Device, DeviceInfo, ActivitiesDb, Activities, ActivityLaps, ActivityRecords, StepsActivities

doc = snakemd.new_doc()

gc_config = GarminConnectConfigManager()
db_params_dict = gc_config.get_db_params()

garmin_db = GarminDb(db_params_dict)

checkup = garmindb.Checkup(paragraph_func=doc.add_paragraph, heading_func=doc.add_heading)

doc.add_heading("Goals", 2)
checkup.goals()

doc.add_heading("Devices with Low Batteries", 2)

devices = Device.get_all(garmin_db)
for device in devices:
    battery_level = DeviceInfo.get_col_latest_where(garmin_db, DeviceInfo.battery_status,
                                                    [DeviceInfo.serial_number == device.serial_number,
                                                        DeviceInfo.battery_status != fitfile.field_enums.BatteryStatus.invalid])
    if battery_level is fitfile.field_enums.BatteryStatus.low:
        doc.add_paragraph(f"Device {device.manufacturer} {device.product} ({device.serial_number}) has a low battery")

display(Markdown(str(doc)))
```

--------------------------------

### Interactive Activity Selection and Filtering in Python

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/activities_dashboard.ipynb

This Python code defines functions to create interactive widgets for selecting Garmin activities, lap filters, and pace filters. It uses the `ipywidgets` library for interactive elements and manages global state for current selections. The functions recursively call each other to update filters based on user choices.

```python
tmp = remove_duplicates(tmp, key=lambda obj: obj.id)
activity = tmp
else:
    activity = activities_dict.get(treino)
activity_widget = interactive(select_activity, activity=activity)
activity_widget.children[0].description = "Activity"
activity_widget.children[0].style = custom_style
activity_widget.children[0].layout = custom_layout
display(activity_widget)

def select_activity(activity):
    global current_selected_lap
    lap_filter_list = original_lap_filter_list.copy()
    if current_selected_lap != "None":
        lap_filter_list.insert(0, current_selected_lap)
    lap_filter_list = remove_duplicates_from_list(lap_filter_list)
    lap_filter_widget = interactive(select_lap_filter, lap_filter=lap_filter_list, activity=fixed(activity))
    lap_filter_widget.children[0].description = "Lap Filter"
    lap_filter_widget.children[0].style = custom_style
    lap_filter_widget.children[0].layout = custom_layout
    display(lap_filter_widget)

def select_lap_filter(lap_filter, activity):
    global current_selected_lap, current_selected_pace
    current_selected_lap = lap_filter
    pace_filter_list = original_pace_filter_list
    if current_selected_pace != "None":
        pace_filter_list.insert(0, current_selected_pace)
    pace_filter_list = remove_duplicates_from_list(pace_filter_list)
    pace_filter_widget = interactive(select_pace_filter, pace_filter=pace_filter_list, activity=fixed(activity), lap_filter=fixed(lap_filter))
    pace_filter_widget.children[0].description = "Pace Filter"
    pace_filter_widget.children[0].style = custom_style
    pace_filter_widget.children[0].layout = custom_layout
    display(pace_filter_widget)

def select_pace_filter(pace_filter, activity, lap_filter):
    global current_selected_pace
    current_selected_pace = pace_filter
    response, map = get_laps_df(activity, lap_filter, pace_filter)
    if isinstance(response, pd.DataFrame):
         display(format_df(response))
    else:
        display(response)
    if map:
        map.display()


load_activities_list()
original_pace_filter_list = ["None"] + get_pace_list()
activities_filter_widget = interactive(select_training_filter, treino=Treino)
activities_filter_widget.children[0].description = "Activities Filter"
activities_filter_widget.children[0].style = custom_style
activities_filter_widget.children[0].layout = custom_layout
display(activities_filter_widget)
```

--------------------------------

### Generate Activity Report from Garmin DB (Python)

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/activities.ipynb

This Python script connects to a Garmin database and generates a comprehensive report. It utilizes libraries like snakemd for report generation and fitfile for activity data parsing. The script calculates various metrics including total activities, distance, speed, and provides detailed breakdowns by sport.

```python
from IPython.display import display, Markdown
import snakemd

import fitfile
from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminDb, Attributes, ActivitiesDb, Activities, StepsActivities, ActivityLaps, ActivityRecords
from idbutils.list_and_dict import list_not_none

from jupyter_funcs import format_number

gc_config = GarminConnectConfigManager()
db_params_dict = gc_config.get_db_params()


garmin_db = GarminDb(db_params_dict)
garmin_act_db = ActivitiesDb(db_params_dict)
measurement_system = Attributes.measurements_type(garmin_db)
unit_strings = fitfile.units.unit_strings[measurement_system]
distance_units = unit_strings[fitfile.units.UnitTypes.distance_long]

def __report_sport(sport_col, sport):
    records = Activities.row_count(garmin_act_db, sport_col, sport)
    if records > 0:
        sport_title = sport.title().replace('_', ' ')
        total_distance = Activities.get_col_sum_for_value(garmin_act_db, Activities.distance, sport_col, sport)
        if total_distance is None:
            total_distance = 0
            average_distance = 0
        else:
            average_distance = total_distance / records
        return [sport_title, records, format_number(total_distance, 1), format_number(average_distance, 1)]

doc = snakemd.new_doc()

doc.add_heading("Activities Report")
doc.add_paragraph("Analysis of all activities in the database.")

doc.add_table(
    ['Type', 'Count'],
    [
        ["Total activities", Activities.row_count(garmin_act_db)],
        ["Total Lap records", ActivityLaps.row_count(garmin_act_db)],
        ["Activity records", ActivityRecords.row_count(garmin_act_db)],
        ["Fitness activities", Activities.row_count(garmin_act_db, Activities.type, 'fitness')],
        ["Recreation activities", Activities.row_count(garmin_act_db, Activities.type, 'recreation')]
    ])

years = Activities.get_years(garmin_act_db)
years.sort()
doc.add_paragraph(f"Years with activities: {len(years)}: {years}")
sports = list_not_none(Activities.get_col_distinct(garmin_act_db, Activities.sport))
doc.add_paragraph(f"Sports: {', '.join(sports)}")
sub_sports = list_not_none(Activities.get_col_distinct(garmin_act_db, Activities.sub_sport))
doc.add_paragraph(f"SubSports: {', '.join(sub_sports)}")

sports_stats = []
for sport_name in [sport.name for sport in fitfile.Sport]:
    sport_stat = __report_sport(Activities.sport, sport_name)
    if sport_stat:
        sports_stats.append(sport_stat)
doc.add_heading("Sport Type Statistics", 3)
doc.add_table(['Sport', 'Total Activities', f'Total Distance ({distance_units})', f"Average Distance ({distance_units}) apresentado"], sports_stats)

def __format_activity(activity):
    if activity:
        if activity.is_steps_activity():
            steps_activity = StepsActivities.get(garmin_act_db, activity.activity_id)
            return [activity.activity_id, activity.name, activity.type, activity.sport, format_number(activity.distance, 1), activity.elapsed_time, format_number(activity.avg_speed, 1),
                    steps_activity.avg_pace, format_number(activity.calories), format_number(activity.training_load, 1), activity.self_eval_feel, activity.self_eval_effort]
        return [activity.activity_id, activity.name, activity.type, activity.sport, format_number(activity.distance, 1), activity.elapsed_time, format_number(activity.avg_speed, 1), '',
                format_number(activity.calories), format_number(activity.training_load, 1), activity.self_eval_feel, activity.self_eval_effort]
    return ['', '', '', '', '', '', '', '', '']

activities = Activities.get_latest(garmin_act_db, 10)
rows = [__format_activity(activity) for activity in activities]
doc.add_heading("Last Ten Activities", 3)
doc.add_table(['Id', 'Name', 'Type', 'Sport', f'Distance ({distance_units})', 'Elapsed Time', f'Speed ({unit_strings[fitfile.units.UnitTypes.speed]})',
               f'Pace ({unit_strings[fitfile.units.UnitTypes.pace]})', 'Calories', 'Training Load', 'Feel', 'Effort'], rows)

rows = []
for display_activity in gc_config.display_activities():
    name = display_activity.activity_name().capitalize()
    rows.append([f'Latest {name}'] + __format_activity(Activities.get_latest_by_sport(garmin_act_db, display_activity)))
    rows.append([f'Fastest {name}'] + __format_activity(Activities.get_fastest_by_sport(garmin_act_db, display_activity)))
    rows.append([f'Slowest {name}'] + __format_activity(Activities.get_slowest_by_sport(garmin_act_db, display_activity)))
    rows.append([f'Longest {name}'] + __format_activity(Activities.get_longest_by_sport(garmin_act_db, display_activity)))

doc.add_heading("Interesting Activities", 3)
doc.add_table(['What', 'Id', 'Name', 'Type', 'Sport', f'Distance ({distance_units})', 'Elapsed Time', f'Speed ({unit_strings[fitfile.units.UnitTypes.speed]})',
               f'Pace ({unit_strings[fitfile.units.UnitTypes.pace]})', 'Calories', 'Training Load', 'Feel', 'Effort'], rows)

```

--------------------------------

### Query Garmin Activity Laps and Records with SQLAlchemy

Source: https://context7.com/tcgoetz/garmindb/llms.txt

This Python snippet shows how to query activity laps and detailed GPS records for a specific activity from the `ActivitiesDb` using SQLAlchemy. It retrieves lap information (distance, time, HR) and individual record details (timestamp, coordinates, HR, speed). This requires the `garmindb` library.

```python
from garmindb.garmindb import ActivitiesDb, ActivityLaps, ActivityRecords
from garmindb import GarminConnectConfigManager

config = GarminConnectConfigManager()
db_params = config.get_db_params()

act_db = ActivitiesDb(db_params)
with act_db.managed_session() as session:
    activity_id = "12345678"

    # Get laps for an activity
    laps = ActivityLaps.s_get_activity(session, activity_id)
    for lap in laps:
        print(f"Lap {lap.lap}: {lap.distance} km in {lap.elapsed_time}")
        print(f"  Avg HR: {lap.avg_hr}, Max HR: {lap.max_hr}")

    # Get detailed records (GPS points)
    records = ActivityRecords.s_get_activity(session, activity_id)
    for record in records:
        print(f"{record.timestamp}: {record.position.lat_deg}, {record.position.long_deg}")
        print(f"  HR: {record.hr}, Speed: {record.speed}")
```

--------------------------------

### Select Training Data by Filter

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/activities_dashboard.ipynb

Selects and sorts training data based on a provided 'treino' filter. If 'treino' is 'All', it combines all activities from `activities_dict` into a single list and sorts them by date in descending order. Dependencies include `ChainMap` and assumes `activities_dict` is populated.

```python
def select_training_filter(treino):
    if treino == 'All':
        tmp = list(ChainMap(*[activities_dict.get(key) for key in activities_dict.keys()]))
        tmp = sorted(tmp, key=lambda x: x.date, reverse=True)
```

--------------------------------

### Display Yesterday's Summary - Python

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/daily.ipynb

This snippet calls the __render_day function to display the summary for yesterday. It requires the previously initialized garmin_sum_db and graph objects, and uses datetime to calculate yesterday's date.

```python
__render_day(garmin_sum_db, graph, datetime.date.today() - datetime.timedelta(days = 1))

```

--------------------------------

### Generate Weight Summary Graph

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/summary.ipynb

Generates a summary table and activity graph for weight data over multiple years. It displays the average, minimum, and maximum weight recorded for each year. Data formatting and presentation are handled by snakemd for tables and a custom Graph object for visualization, utilizing the initialized Garmin database connection and graph object.

```python
years_data = []
current_year = datetime.date.today().year
for year in range(current_year - years_to_display, current_year + 1):
    year_data = YearsSummary.get_year(garmin_sum_db, year)
    years_data.append([year, format_number(year_data.weight_avg), format_number(year_data.weight_min), format_number(year_data.weight_max)])

doc = snakemd.new_doc()
doc.add_heading("Weight", 3)
doc.add_table(['Year', 'Avg Weight', 'Min Weight', 'Max Weight'], years_data)
display(Markdown(str(doc)))
graph.graph_activity('weight', days=days_to_display)

```

--------------------------------

### Render Daily Summary - Python

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/daily.ipynb

This function retrieves and displays a daily summary from the GarminSummaryDb. It takes the database object, a graph object, and a specific date as input. If data for the date exists, it generates a Markdown table with various health metrics and displays it. It also calls a graph function for the given date. Dependencies include datetime, IPython.display, snakemd, garmindb, and jupyter_funcs.

```python
import datetime
from IPython.display import display, Markdown
import snakemd

from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminSummaryDb, DaysSummary

from jupyter_funcs import format_number
from graphs import Graph


def __render_day(garmin_sum_db, graph, date):
    day = DaysSummary.get_day(garmin_sum_db, date)
    if day:
        doc = snakemd.new_doc()
        doc.add_heading(f"Summary of {date}")
        doc.add_table(['Weight', 'Resting HR', 'Max HR', 'Waking Avg RR', 'Steps', 'Floors', 'Intensity Mins', 'Calories', 'Sleep', 'REM Sleep', 'Stress'],
            [
                [format_number(day.weight_avg), day.rhr_avg, day.hr_max, day.rr_waking_avg, day.steps, format_number(day.floors, 1),
                 day.intensity_time, day.calories_avg, day.sleep_avg, day.rem_sleep_avg, day.stress_avg]
            ]
        )
        display(Markdown(str(doc)))
    graph.graph_date(date)


gc_config = GarminConnectConfigManager()
db_params_dict = gc_config.get_db_params()
garmin_sum_db = GarminSummaryDb(db_params_dict)

graph = Graph()

```

--------------------------------

### Generate Intensity Minutes Activity Graph

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/summary.ipynb

Generates an activity graph for intensity minutes over a specified number of days. This function relies on the pre-initialized Graph object and the `days_to_display` variable. It visualizes the intensity minutes data.

```python
graph.graph_activity('itime', days=days_to_display)

```

--------------------------------

### Generate GarminDb File Statistics Table (Python)

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/garmin.ipynb

This Python script connects to a Garmin database, determines the measurement system and associated units, and then generates a Markdown table displaying the count of files for each type stored in the database. It utilizes libraries like `snakemd` for Markdown generation and `garmindb` for database interaction. The output is displayed as formatted Markdown.

```python
from IPython.display import display, Markdown
import snakemd

import fitfile
from garmindb import GarminConnectConfigManager
from garmindb.garmindb import GarminDb, Attributes, File


gc_config = GarminConnectConfigManager()
db_params_dict = gc_config.get_db_params()
garmin_db = GarminDb(db_params_dict)

measurement_system = Attributes.measurements_type(garmin_db)
unit_strings = fitfile.units.unit_strings[measurement_system]
distance_units = unit_strings[fitfile.units.UnitTypes.distance_long]

doc = snakemd.new_doc()

doc.add_heading("GarminDb Statistics")
doc.add_paragraph("Metadata for data in the database.")

file_stats = [
    ['All', File.row_count(garmin_db)]
]
for file_type_name in [file_type.name for file_type in File.FileType]:
    records = File.row_count(garmin_db, File.type, file_type_name)
    if records > 0:
        file_stats.append([file_type_name, records])
doc.add_table(['Type', 'Files'], file_stats)

display(Markdown(str(doc)))
```

--------------------------------

### Load and Categorize Garmin Activities

Source: https://github.com/tcgoetz/garmindb/blob/master/Jupyter/activities_dashboard.ipynb

Loads running activities from the Garmin database and categorizes them based on name matches and lap distances. It populates a global `activities_dict` with `CustomActivity` objects. Dependencies include `Activities`, `ActivityLaps`, `CustomActivity`, `math`, and `fitfile.conversions`. This function is designed to be called once to prepare activity data for further analysis.

```python
def load_activities_list():
    global activities_list, activities_dict
    activities_list = Activities.get_by_sport(garmin_act_db, "running")
    activities_list.reverse()
    for activity in activities_list:
        if len(group_activities_by_name) > 0:
            matches_by_name = [name for name in group_activities_by_name if name in activity.name]
            if len(matches_by_name) > 0:
                for key in matches_by_name:
                    activities_dict[key].append(CustomActivity(activity.activity_id, activity.name, activity.start_time.date()))
            else:
                key = "Without Name Match"
                activities_dict[key].append(CustomActivity(activity.activity_id, activity.name, activity.start_time.date()))
        if len(group_activities_by_lap_distance) > 0:
            laps = ActivityLaps.get_activity(garmin_act_db, activity.activity_id)
            complete_laps_list.extend(laps)
            for lap in laps:
                lap.avg_pace = fitfile.conversions.perhour_speed_to_pace(lap.avg_speed)
            for key, lap_search_distance in zip(group_activities_by_lap_distance, group_activities_by_lap_distance_converted):
                if any([lap for lap in laps if lap.distance is not None and math.isclose(lap.distance, lap_search_distance, rel_tol=lap_distance_precision) and lap.avg_pace is not None and lap.avg_pace < group_activities_by_lap_speed]):
                    activities_dict[key].append(CustomActivity(activity.activity_id, activity.name, activity.start_time.date()))
```