Corrected units/device type for some body related sensors

Update HACS URL

.github/workflows/hassfest.yml

@@ -0,0 +1,15 @@
+
+name: Validate with hassfest
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: "0 0 * * *"
+
+jobs:
+  validate:
+    runs-on: "ubuntu-latest"
+    steps:
+      - uses: "actions/checkout@v2"
+      - uses: home-assistant/actions/hassfest@master

README.md

@@ -1,15 +1,19 @@
-[![hacs_badge](https://img.shields.io/badge/HACS-Default-orange.svg)](https://github.com/custom-components/hacs)  [![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/) [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/cyberjunkynl/)
+[![hacs_badge](https://img.shields.io/badge/HACS-Default-orange.svg)](https://github.com/hacs/integration)  [![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/) [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/cyberjunkynl/)
 
 # Garmin Connect
 The Garmin Connect integration allows you to expose data from Garmin Connect to Home Assistant.
 
+NOTE: This integration doesn't support 2FA on Garmin Connect, so if you have enabled it -and want to keep it- this integration doesn't work, it will try to login repeatedly and generate lots of 2FA codes via email.
+The change of adding support for it is unlikely since the Garmin Connect API is closed source, and will not be open for open-sourced projects.
 
 ## Installation
 
 ### HACS - Recommended
 - Have [HACS](https://hacs.xyz) installed, this will allow you to easily manage and track updates.
+- Inside HACS click 'Explore & download repositories'
 - Search for 'Garmin Connect'.
-- Click Install below the found integration.
+- Click on found integration.
+- Click Download this repository with HACS.
 - Restart Home-Assistant.
 - Follow configuration steps below.
 

custom_components/garmin_connect/__init__.py

@@ -2,7 +2,7 @@
 from datetime import date
 import logging
 
-from garminconnect_ha import (
+from garminconnect import (
     Garmin,
     GarminConnectAuthenticationError,
     GarminConnectConnectionError,
@@ -25,38 +25,11 @@ PLATFORMS = ["sensor"]
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up Garmin Connect from a config entry."""
 
-    username: str = entry.data[CONF_USERNAME]
-    password: str = entry.data[CONF_PASSWORD]
+    coordinator = GarminConnectDataUpdateCoordinator(hass, entry=entry)
 
-    api = Garmin(username, password)
-    try:
-        await hass.async_add_executor_job(api.login)
-    except (
-        GarminConnectAuthenticationError,
-        GarminConnectTooManyRequestsError,
-    ) as err:
-        _LOGGER.error("Error occurred during Garmin Connect login request: %s", err)
-        return False
-    except (GarminConnectConnectionError) as err:
-        _LOGGER.error(
-            "Connection error occurred during Garmin Connect login request: %s", err
-        )
-        raise ConfigEntryNotReady from err
-    except Exception:  # pylint: disable=broad-except
-        _LOGGER.exception("Unknown error occurred during Garmin Connect login request")
+    if not await coordinator.async_login():
         return False
 
-    async def async_update_data():
-        _LOGGER.debug("Updating data for %s", username)
-        return await async_update_garmin_data(hass, api)
-
-    coordinator = DataUpdateCoordinator(
-        hass,
-        _LOGGER,
-        name=username,
-        update_method=async_update_data,
-        update_interval=DEFAULT_UPDATE_INTERVAL,
-    )
     await coordinator.async_config_entry_first_refresh()
 
     hass.data.setdefault(DOMAIN, {})
@@ -77,25 +50,68 @@ async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry):
     return unload_ok
 
 
-async def async_update_garmin_data(hass, api):
-    """Fetch data from API endpoint."""
-    try:
-        summary = await hass.async_add_executor_job(
-            api.get_user_summary, date.today().isoformat()
-        )
-        body = await hass.async_add_executor_job(
-            api.get_body_composition, date.today().isoformat()
-        )
-        alarms = await hass.async_add_executor_job(api.get_device_alarms)
-    except (
-        GarminConnectAuthenticationError,
-        GarminConnectTooManyRequestsError,
-        GarminConnectConnectionError,
-    ) as error:
-        raise UpdateFailed(error) from error
+class GarminConnectDataUpdateCoordinator(DataUpdateCoordinator):
+    """Garmin Connect Data Update Coordinator."""
 
-    return {
-        **summary,
-        **body["totalAverage"],
-        "nextAlarm": alarms,
-    }
+    def __init__(self, hass: HomeAssistant, entry: ConfigEntry) -> None:
+        """Initialize the Garmin Connect hub."""
+        self.entry = entry
+        self.hass = hass
+
+        self._api = Garmin(entry.data[CONF_USERNAME], entry.data[CONF_PASSWORD])
+
+        super().__init__(
+            hass, _LOGGER, name=DOMAIN, update_interval=DEFAULT_UPDATE_INTERVAL
+        )
+
+    async def async_login(self) -> bool:
+        """Login to Garmin Connect."""
+        try:
+            await self.hass.async_add_executor_job(self._api.login)
+        except (
+            GarminConnectAuthenticationError,
+            GarminConnectTooManyRequestsError,
+        ) as err:
+            _LOGGER.error("Error occurred during Garmin Connect login request: %s", err)
+            return False
+        except (GarminConnectConnectionError) as err:
+            _LOGGER.error(
+                "Connection error occurred during Garmin Connect login request: %s", err
+            )
+            raise ConfigEntryNotReady from err
+        except Exception:  # pylint: disable=broad-except
+            _LOGGER.exception(
+                "Unknown error occurred during Garmin Connect login request"
+            )
+            return False
+
+        return True
+
+    async def _async_update_data(self) -> dict:
+        """Fetch data from Garmin Connect."""
+        try:
+            summary = await self.hass.async_add_executor_job(
+                self._api.get_user_summary, date.today().isoformat()
+            )
+            _LOGGER.debug(summary)
+            body = await self.hass.async_add_executor_job(
+                self._api.get_body_composition, date.today().isoformat()
+            )
+            _LOGGER.debug(body)
+            alarms = await self.hass.async_add_executor_job(self._api.get_device_alarms)
+            _LOGGER.debug(alarms)
+        except (
+            GarminConnectAuthenticationError,
+            GarminConnectTooManyRequestsError,
+            GarminConnectConnectionError,
+        ) as error:
+            _LOGGER.debug("Trying to relogin to Garmin Connect")
+            if not await self.async_login():
+                raise UpdateFailed(error) from error
+            return {}
+
+        return {
+            **summary,
+            **body["totalAverage"],
+            "nextAlarm": alarms,
+        }

custom_components/garmin_connect/config_flow.py

@@ -1,7 +1,7 @@
 """Config flow for Garmin Connect integration."""
 import logging
 
-from garminconnect_ha import (
+from garminconnect import (
     Garmin,
     GarminConnectAuthenticationError,
     GarminConnectConnectionError,

custom_components/garmin_connect/const.py

@@ -2,16 +2,15 @@
 from datetime import timedelta
 
 from homeassistant.const import (
-    DEVICE_CLASS_TIMESTAMP,
     LENGTH_METERS,
     MASS_KILOGRAMS,
     PERCENTAGE,
     TIME_MINUTES,
     TIME_YEARS,
 )
+from homeassistant.components.sensor import SensorDeviceClass
 
 DOMAIN = "garmin_connect"
-ATTRIBUTION = "connect.garmin.com"
 DATA_COORDINATOR = "coordinator"
 DEFAULT_UPDATE_INTERVAL = timedelta(minutes=5)
 
@@ -37,26 +36,26 @@ GARMIN_ENTITY_LIST = {
         None,
         False,
     ],
-    "netCalorieGoal": ["Net Calorie Goal", "cal", "mdi:food", None, False],
+    "netCalorieGoal": ["Net Calorie Goal", "kcal", "mdi:food", None, False],
     "totalDistanceMeters": [
         "Total Distance Mtr",
         LENGTH_METERS,
         "mdi:walk",
-        None,
+        SensorDeviceClass.DISTANCE,
         True,
     ],
     "wellnessStartTimeLocal": [
         "Wellness Start Time",
         None,
         "mdi:clock",
-        DEVICE_CLASS_TIMESTAMP,
+        SensorDeviceClass.TIMESTAMP,
         False,
     ],
     "wellnessEndTimeLocal": [
         "Wellness End Time",
         None,
         "mdi:clock",
-        DEVICE_CLASS_TIMESTAMP,
+        SensorDeviceClass.TIMESTAMP,
         False,
     ],
     "wellnessDescription": ["Wellness Description", "", "mdi:clock", None, False],
@@ -64,7 +63,7 @@ GARMIN_ENTITY_LIST = {
         "Wellness Distance Mtr",
         LENGTH_METERS,
         "mdi:walk",
-        None,
+        SensorDeviceClass.DISTANCE,
         False,
     ],
     "wellnessActiveKilocalories": [
@@ -103,14 +102,14 @@ GARMIN_ENTITY_LIST = {
         "Floors Ascended Mtr",
         LENGTH_METERS,
         "mdi:stairs",
-        None,
+        SensorDeviceClass.DISTANCE,
         False,
     ],
     "floorsDescendedInMeters": [
         "Floors Descended Mtr",
         LENGTH_METERS,
         "mdi:stairs",
-        None,
+        SensorDeviceClass.DISTANCE,
         False,
     ],
     "floorsAscended": ["Floors Ascended", "floors", "mdi:stairs", None, True],
@@ -198,49 +197,49 @@ GARMIN_ENTITY_LIST = {
         "Stress Percentage",
         PERCENTAGE,
         "mdi:flash-alert",
-        None,
+        SensorDeviceClass.BATTERY,
         False,
     ],
     "restStressPercentage": [
         "Rest Stress Percentage",
         PERCENTAGE,
         "mdi:flash-alert",
-        None,
+        SensorDeviceClass.BATTERY,
         False,
     ],
     "activityStressPercentage": [
         "Activity Stress Percentage",
         PERCENTAGE,
         "mdi:flash-alert",
-        None,
+        SensorDeviceClass.BATTERY,
         False,
     ],
     "uncategorizedStressPercentage": [
         "Uncat. Stress Percentage",
         PERCENTAGE,
         "mdi:flash-alert",
-        None,
+        SensorDeviceClass.BATTERY,
         False,
     ],
     "lowStressPercentage": [
         "Low Stress Percentage",
         PERCENTAGE,
         "mdi:flash-alert",
-        None,
+        SensorDeviceClass.BATTERY,
         False,
     ],
     "mediumStressPercentage": [
         "Medium Stress Percentage",
         PERCENTAGE,
         "mdi:flash-alert",
-        None,
+        SensorDeviceClass.BATTERY,
         False,
     ],
     "highStressPercentage": [
         "High Stress Percentage",
         PERCENTAGE,
         "mdi:flash-alert",
-        None,
+        SensorDeviceClass.BATTERY,
         False,
     ],
     "moderateIntensityMinutes": [
@@ -268,35 +267,35 @@ GARMIN_ENTITY_LIST = {
         "Body Battery Charged",
         PERCENTAGE,
         "mdi:battery-charging-100",
-        None,
+        SensorDeviceClass.BATTERY,
         True,
     ],
     "bodyBatteryDrainedValue": [
         "Body Battery Drained",
         PERCENTAGE,
         "mdi:battery-alert-variant-outline",
-        None,
+        SensorDeviceClass.BATTERY,
         True,
     ],
     "bodyBatteryHighestValue": [
         "Body Battery Highest",
         PERCENTAGE,
         "mdi:battery-heart",
-        None,
+        SensorDeviceClass.BATTERY,
         True,
     ],
     "bodyBatteryLowestValue": [
         "Body Battery Lowest",
         PERCENTAGE,
         "mdi:battery-heart-outline",
-        None,
+        SensorDeviceClass.BATTERY,
         True,
     ],
     "bodyBatteryMostRecentValue": [
         "Body Battery Most Recent",
         PERCENTAGE,
         "mdi:battery-positive",
-        None,
+        SensorDeviceClass.BATTERY,
         True,
     ],
     "averageSpo2": ["Average SPO2", PERCENTAGE, "mdi:diabetes", None, True],
@@ -306,7 +305,7 @@ GARMIN_ENTITY_LIST = {
         "Latest SPO2 Time",
         None,
         "mdi:diabetes",
-        DEVICE_CLASS_TIMESTAMP,
+        SensorDeviceClass.TIMESTAMP,
         False,
     ],
     "averageMonitoringEnvironmentAltitude": [
@@ -341,17 +340,17 @@ GARMIN_ENTITY_LIST = {
         "Latest Respiration Update",
         None,
         "mdi:progress-clock",
-        DEVICE_CLASS_TIMESTAMP,
+        SensorDeviceClass.TIMESTAMP,
         False,
     ],
-    "weight": ["Weight", MASS_KILOGRAMS, "mdi:weight-kilogram", None, False],
+    "weight": ["Weight", MASS_KILOGRAMS, "mdi:weight-kilogram", SensorDeviceClass.WEIGHT, False],
     "bmi": ["BMI", "bmi", "mdi:food", None, False],
-    "bodyFat": ["Body Fat", PERCENTAGE, "mdi:food", None, False],
-    "bodyWater": ["Body Water", PERCENTAGE, "mdi:water-percent", None, False],
-    "bodyMass": ["Body Mass", MASS_KILOGRAMS, "mdi:food", None, False],
-    "muscleMass": ["Muscle Mass", MASS_KILOGRAMS, "mdi:dumbbell", None, False],
+    "bodyFat": ["Body Fat", PERCENTAGE, "mdi:food", SensorDeviceClass.BATTERY, False],
+    "bodyWater": ["Body Water", PERCENTAGE, "mdi:water-percent", SensorDeviceClass.BATTERY, False],
+    "boneMass": ["Bone Mass", MASS_KILOGRAMS, "mdi:bone", SensorDeviceClass.WEIGHT, False],
+    "muscleMass": ["Muscle Mass", MASS_KILOGRAMS, "mdi:dumbbell", SensorDeviceClass.WEIGHT, False],
     "physiqueRating": ["Physique Rating", None, "mdi:numeric", None, False],
-    "visceralFat": ["Visceral Fat", PERCENTAGE, "mdi:food", None, False],
+    "visceralFat": ["Visceral Fat", PERCENTAGE, "mdi:food", SensorDeviceClass.BATTERY, False],
     "metabolicAge": ["Metabolic Age", TIME_YEARS, "mdi:calendar-heart", None, False],
-    "nextAlarm": ["Next Alarm Time", None, "mdi:alarm", DEVICE_CLASS_TIMESTAMP, True],
+    "nextAlarm": ["Next Alarm Time", None, "mdi:alarm", SensorDeviceClass.TIMESTAMP, True],
 }

custom_components/garmin_connect/manifest.json

@@ -2,9 +2,10 @@
   "domain": "garmin_connect",
   "name": "Garmin Connect",
   "documentation": "https://github.com/cyberjunky/home-assistant-garmin_connect",
-  "requirements": ["garminconnect_ha==0.1.12"],
+  "issue_tracker": "https://github.com/cyberjunky/home-assistant-garmin_connect/issues",
+  "requirements": ["garminconnect==0.1.50"],
   "codeowners": ["@cyberjunky"],
   "config_flow": true,
   "iot_class": "cloud_polling",
-  "version": "0.1.0"
+  "version": "0.2.6"
 }

custom_components/garmin_connect/sensor.py

@@ -2,10 +2,16 @@
 from __future__ import annotations
 
 import logging
+import datetime
+import pytz
 
-from homeassistant.components.sensor import SensorEntity
+from homeassistant.components.sensor import (
+    SensorEntity, 
+    SensorStateClass,
+    SensorDeviceClass,
+)
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_ATTRIBUTION, CONF_ID, DEVICE_CLASS_TIMESTAMP
+from homeassistant.const import ATTR_ATTRIBUTION, CONF_ID
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.update_coordinator import (
@@ -15,7 +21,6 @@ from homeassistant.helpers.update_coordinator import (
 
 from .alarm_util import calculate_next_active_alarms
 from .const import (
-    ATTRIBUTION,
     DATA_COORDINATOR,
     DOMAIN as GARMIN_DOMAIN,
     GARMIN_ENTITY_LIST,
@@ -83,24 +88,18 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
 
         self._unique_id = unique_id
         self._type = sensor_type
-        self._name = name
-        self._unit = unit
-        self._icon = icon
         self._device_class = device_class
         self._enabled_default = enabled_default
 
-    @property
-    def name(self):
-        """Return the name of the sensor."""
-        return self._name
+        self._attr_name = name
+        self._attr_device_class = self._device_class
+        self._attr_icon = icon
+        self._attr_native_unit_of_measurement = unit
+        self._attr_unique_id = f"{self._unique_id}_{self._type}"
+        self._attr_state_class = SensorStateClass.TOTAL
 
     @property
-    def icon(self):
-        """Return the icon to use in the frontend."""
-        return self._icon
-
-    @property
-    def state(self):
+    def native_value(self):
         """Return the state of the sensor."""
         if not self.coordinator.data or not self.coordinator.data[self._type]:
             return None
@@ -115,23 +114,23 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
                 self.coordinator.data[self._type]
             )
             if active_alarms:
-                value = active_alarms[0]
+                date_time_obj = datetime.datetime.strptime(active_alarms[0], "%Y-%m-%dT%H:%M:%S")
+                timezone = pytz.timezone('UTC')
+                timezone_date_time_obj = timezone.localize(date_time_obj)
+                return timezone_date_time_obj
+            else:
+                return None
+        elif self._type == "stressQualifier":
+                return value
 
-        if self._device_class == DEVICE_CLASS_TIMESTAMP:
-            return value
+        if self._device_class == SensorDeviceClass.TIMESTAMP:
+            date_time_obj = datetime.datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%f")
+            timezone = pytz.timezone('UTC')
+            timezone_date_time_obj = timezone.localize(date_time_obj)
+            return timezone_date_time_obj
 
         return round(value, 2)
 
-    @property
-    def unique_id(self) -> str:
-        """Return the unique ID for this sensor."""
-        return f"{self._unique_id}_{self._type}"
-
-    @property
-    def unit_of_measurement(self):
-        """Return the unit of measurement."""
-        return self._unit
-
     @property
     def extra_state_attributes(self):
         """Return attributes for sensor."""
@@ -139,9 +138,7 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
             return {}
 
         attributes = {
-            "source": self.coordinator.data["source"],
             "last_synced": self.coordinator.data["lastSyncTimestampGMT"],
-            ATTR_ATTRIBUTION: ATTRIBUTION,
         }
         if self._type == "nextAlarm":
             attributes["next_alarms"] = calculate_next_active_alarms(
@@ -172,8 +169,3 @@ class GarminConnectSensor(CoordinatorEntity, SensorEntity):
             and self.coordinator.data
             and self._type in self.coordinator.data
         )
-
-    @property
-    def device_class(self):
-        """Return the device class of the sensor."""
-        return self._device_class

custom_components/garmin_connect/strings.json

@@ -15,8 +15,7 @@
           "password": "[%key:common::config_flow::data::password%]",
           "username": "[%key:common::config_flow::data::username%]"
         },
-        "description": "Enter your credentials.",
-        "title": "Garmin Connect"
+        "description": "Enter your credentials."
       }
     }
   }

custom_components/garmin_connect/translations/en.json

@@ -15,9 +15,8 @@
                     "password": "Password",
                     "username": "Username"
                 },
-                "description": "Enter your credentials.",
-                "title": "Garmin Connect"
+                "description": "Enter your credentials."
             }
         }
     }
-}
+}

hacs.json

@@ -1,7 +1,5 @@
 {
     "name": "Garmin Connect",
-    "country": "NL",
     "render_readme": true,
     "domains": ["sensor"]
-  }
-  
+}