feature/sync-measurement-units (#138)

* Entity measurement units update

Removed useless __json__ from IntEnums (oops)
Added feed unit conversion
Made Enum usage a bit more efficient
Removed api refresh on every number entity change, using async_write_ha_state instead
UnitTypes and CommonAPIKeys renamed to Unit and APIKey
Fixed changed settings not remaining on account settings page when an error occurs
Fixed account settings update validation not working properly

* Changed 'grain' to 'portion'

* Unit sensors sync when changed + fixes

Unit sensors will update to chosen measurement unit when that unit is changed in account settings.
Added checkbox to account settings to update ALL unit sensors, regardless of what's changed in account settings.
Fixed water units not working properly.
Removed "portion" number entities.
Updated Dockstream 2 entities to work with unit system.
Updated translations for member and unit stuff. Used AI for non-english languages, can't say how accurate they are.

* Round water_low_threshold unit conversion

* Fixed update_all_units not updating all feed units

* Cleaning up sensor entity update

* Fixed missing method argument

* Increased max manual feed amount to 48 (4 cups)

---------

Co-authored-by: Jamie Jones <29973406+jjjonesjr33@users.noreply.github.com>

Author: FeliGoblin

custom_components/petlibro/config_flow.py

@@ -10,21 +10,23 @@
 import voluptuous as vol
 
 from homeassistant.config_entries import ConfigEntry, ConfigFlow, ConfigFlowResult, OptionsFlow
-from homeassistant.const import CONF_API_TOKEN, CONF_EMAIL, CONF_PASSWORD, CONF_REGION
+from homeassistant.const import CONF_API_TOKEN, CONF_EMAIL, CONF_PASSWORD, CONF_REGION, Platform
 from homeassistant.core import callback
 from homeassistant.data_entry_flow import section
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.selector import selector
+from homeassistant.helpers.entity_registry import async_get as get_entity_registry
 
 from .api import PetLibroAPI
 from .const import (
     DEFAULT_FEED,
     DEFAULT_WATER,
     DEFAULT_WEIGHT,
+    ROUNDING_RULES,
     DOMAIN,
-    CommonAPIKeys as API,
+    APIKey as API,
     Gender,
-    UnitTypes,
+    Unit,
 )
 from .exceptions import PetLibroCannotConnect, PetLibroInvalidAuth
 from .hub import PetLibroHub
@@ -201,25 +203,54 @@ async def async_step_account_settings(
             return self.async_abort(reason="account_update_nomember")
 
         user_input = user_input or {}
-        if user_input:
+        if user_input:            
+            update_setting_temp = user_input.pop("measurement_unit", {})
+            update_info_temp = user_input.copy()
+            user_input.update(**update_setting_temp)
+            update_all_units = update_setting_temp.pop("update_all_units", False)
+            
             update_setting = self.collect_updates(
                 fields=(API.FEED_UNIT, API.WATER_UNIT, API.WEIGHT_UNIT),
-                user_input=user_input.pop("measurement_unit", {}),
-                enum_cls=UnitTypes,
+                user_input=update_setting_temp,
+                enum_cls=Unit,
             )
 
             update_info = self.collect_updates(
                 fields=(API.NICKNAME, API.GENDER),
-                user_input=user_input,
+                user_input=update_info_temp,
                 special={
                     API.NICKNAME: lambda v: v or "",
                     API.GENDER: lambda v: self.validate_enum(API.GENDER, v, Gender),
                 },
             )
+                            
+            if update_setting or update_all_units:
+                registry = get_entity_registry(self.hass)
+                for unit_type in self.hub.unit_sensor_unique_ids:
+                    unit = (input if isinstance(input := update_setting.get(unit_type), Unit)
+                        else Unit(input) if input else getattr(self.member, unit_type, None))
+                    if (unit_type not in update_setting or not unit or not unit.device_class) and not update_all_units:
+                        continue
+                    _LOGGER.debug("Updating %s sensor entities", unit_type)
+                    if update_all_units and unit_type == API.FEED_UNIT:
+                        target_units = {"weight": unit if unit.device_class == "weight" else Unit.GRAMS,
+                            "volume": unit if unit.device_class == "volume" else Unit.MILLILITERS}
+                    else:
+                        target_units = {unit.device_class: unit}
+                    for device_class, target_unit in target_units.items():
+                        display_precision = ROUNDING_RULES.get(target_unit, 0)
+                        options = { "unit_of_measurement": target_unit.symbol,
+                                    "display_precision": display_precision,
+                                    "suggested_display_precision": display_precision }
+                        for unique_id in self.hub.unit_sensor_unique_ids.get(unit_type, {}).get(device_class, []):
+                            entity_id = registry.async_get_entity_id(Platform.SENSOR, DOMAIN, unique_id)
+                            _LOGGER.debug("Setting %s to %s with display precision %s", entity_id, unit.symbol, display_precision)
+                            registry.async_update_entity_options(entity_id, Platform.SENSOR, options)
 
             if not (update_info or update_setting):
                 _LOGGER.debug("No account settings were changed.")
-                return self.async_abort(reason="account_update_nochanges")
+                reason = "account_update_nochanges" + ("_update_sensors" if update_all_units else "")
+                return self.async_abort(reason=reason)
 
             no_error = await self.api.member_update_info(update_info, update_setting)
             await self.hub.async_refresh(force_member=True)
@@ -252,12 +283,12 @@ def _show_account_settings_form(self, user_input: dict[str, Any]) -> ConfigFlowR
                     vol.Required(
                         str(API.GENDER),
                         default=user_input.get(
-                            API.GENDER, getattr(self.member, API.GENDER, str(Gender.NONE))
+                            API.GENDER, getattr(self.member, API.GENDER, Gender.NONE).lower
                         ),
                     ): selector(
                         {
                             "select": {
-                                "options": [g.name.lower() for g in Gender],
+                                "options": [g.lower for g in Gender],
                                 "mode": "dropdown",
                                 "translation_key": "member_gender",
                             }
@@ -280,33 +311,32 @@ def _get_measurement_schema(self, user_input: dict[str, Any]) -> vol.Schema:
                 vol.Required(
                     str(API.FEED_UNIT),
                     default=user_input.get(
-                        API.FEED_UNIT, getattr(self.member, API.FEED_UNIT, DEFAULT_FEED.name)
+                        API.FEED_UNIT, getattr(self.member, API.FEED_UNIT, DEFAULT_FEED).lower
                     ),
-                ): self._unit_selector(
-                    (UnitTypes.CUPS, UnitTypes.OUNCES, UnitTypes.GRAMS, UnitTypes.MILLILITERS)
-                ),
+                ): self._unit_selector((Unit.CUPS, Unit.OUNCES, Unit.GRAMS, Unit.MILLILITERS)),
                 vol.Required(
                     str(API.WATER_UNIT),
                     default=user_input.get(
-                        API.WATER_UNIT, getattr(self.member, API.WATER_UNIT, DEFAULT_WATER.name)
+                        API.WATER_UNIT, getattr(self.member, API.WATER_UNIT, DEFAULT_WATER).lower
                     ),
-                ): self._unit_selector((UnitTypes.OUNCES, UnitTypes.MILLILITERS)),
+                ): self._unit_selector((Unit.WATER_OUNCES, Unit.WATER_MILLILITERS)),
                 vol.Required(
                     str(API.WEIGHT_UNIT),
                     default=user_input.get(
                         API.WEIGHT_UNIT,
-                        getattr(self.member, API.WEIGHT_UNIT, DEFAULT_WEIGHT.name),
+                        getattr(self.member, API.WEIGHT_UNIT, DEFAULT_WEIGHT).lower,
                     ),
-                ): self._unit_selector((UnitTypes.POUNDS, UnitTypes.KILOGRAMS)),
+                ): self._unit_selector((Unit.POUNDS, Unit.KILOGRAMS)),
+                vol.Optional("update_all_units", default=user_input.get("update_all_units", False)): bool,
             }
         )
 
-    def _unit_selector(self, options: tuple[Enum, ...]) -> Any:
+    def _unit_selector(self, options: tuple[Unit, ...]) -> Any:
         """Return a dropdown selector for measurement unit options."""
         return selector(
             {
                 "select": {
-                    "options": [o.name.lower() for o in options],
+                    "options": [o.lower for o in options],
                     "mode": "dropdown",
                     "translation_key": "unit_type",
                 }
@@ -324,7 +354,7 @@ def validate_enum(self, api_key: str, form_value: Any, enum_cls: type[Enum]) ->
 
         form_value_str = str(form_value).upper()
         if form_value_str in enum_cls.__members__:
-            return enum_cls[form_value_str].value
+            return enum_cls[form_value_str]
 
         _LOGGER.error("Invalid value: %s for API key: %s", form_value, api_key)
         return None
@@ -358,6 +388,7 @@ def collect_updates(
             else:
                 api_value = form_value
 
-            updates[api_key] = api_value
-
+            if api_value != current_value:
+                updates[api_key] = api_value
+                
         return updates

custom_components/petlibro/const.py

@@ -4,6 +4,8 @@
 
 from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, UnitOfMass, UnitOfVolume
 
+type _Unit = Unit
+
 DOMAIN = "petlibro"
 
 # Configuration keys
@@ -19,42 +21,6 @@
 UPDATE_INTERVAL_SECONDS = 60  # You can adjust this value based on your needs
 
 
-class UnitTypes(IntEnum):
-    """Weight, feed, and water units with symbols."""
-
-    CUPS = 1, "cup"
-    OUNCES = 2, UnitOfMass.OUNCES
-    GRAMS = 3, UnitOfMass.GRAMS
-    MILLILITERS = 4, UnitOfVolume.MILLILITERS
-    KILOGRAMS = 5, UnitOfMass.KILOGRAMS
-    POUNDS = 6, UnitOfMass.POUNDS
-
-    def __new__(cls, value: int, symbol: str):
-        "Ensures IntEnum functionality while allowing symbols."
-        obj = int.__new__(cls, value)
-        obj._value_ = value
-        obj._symbol = symbol  # noqa: SLF001
-        return obj
-
-    def __str__(self) -> str:
-        """Returns the name as a string."""
-        return self.name
-
-    def __json__(self) -> int:
-        """Returns the int value when sending to the API."""
-        return int(self)
-
-    @property
-    def symbol(self) -> str:
-        """Returns unit symbol."""
-        return self._symbol
-
-
-DEFAULT_WEIGHT = UnitTypes.POUNDS
-DEFAULT_FEED = UnitTypes.CUPS
-DEFAULT_WATER = UnitTypes.OUNCES
-
-
 class Gender(IntEnum):
     """Gender/sex options."""
 
@@ -72,13 +38,10 @@ def __new__(cls, value: int, icon: str, symbol: str, emoji: str):
         obj._emoji = emoji  # noqa: SLF001
         return obj
 
-    def __str__(self) -> str:
-        """Returns the name as a string."""
-        return self.name
-
-    def __json__(self) -> int:
-        """Returns the int value when sending to API."""
-        return int(self)
+    @property
+    def lower(self) -> str:
+        """Returns unit name in lower case."""
+        return self.name.lower()
 
     @property
     def icon(self) -> str:
@@ -96,13 +59,120 @@ def emoji(self) -> str:
         return self._emoji
 
 
-class CommonAPIKeys(StrEnum):
+class APIKey(StrEnum):
     """Common API JSON keys."""
 
-    ACCOUNT_ID = "id"
+    # Common
+    ID = "id"
+    NAME = "name"
+    WEIGHT = "weight"
+
+    # Member
     EMAIL = "email"
     NICKNAME = "nickname"
     GENDER = "gender"
     FEED_UNIT = "feedUnitType"
     WATER_UNIT = "waterUnitType"
     WEIGHT_UNIT = "weightUnitType"
+
+    # Pet
+    BIRTHDAY = "birthday"
+    TYPE = "type"
+    SEX = "gender"
+    BREED_NAME = "breedName"
+    BREED_ID = "breedId"
+    PET_ID = "petId"
+
+
+class Unit(IntEnum):
+    """Weight, feed, and water units with symbols and conversion."""
+
+    CUPS = 1, 1/12, "cup", ""
+    OUNCES = 2, 0.35, UnitOfMass.OUNCES, "weight"
+    GRAMS = 3, 10, UnitOfMass.GRAMS, "weight"
+    MILLILITERS = 4, 20, UnitOfVolume.MILLILITERS, "volume"
+
+    KILOGRAMS = 5, 1, UnitOfMass.KILOGRAMS, "weight"
+    POUNDS = 6, 2.20459, UnitOfMass.POUNDS, "weight"
+
+    WATER_OUNCES = 2 +6, 0.035195, UnitOfVolume.FLUID_OUNCES, "volume"
+    WATER_MILLILITERS = 4 +6, 1, UnitOfVolume.MILLILITERS, "volume"
+    
+    # KILOGRAMS, POUNDS, and WATER_ values can be converted using HA's built-in unit
+    # converter, so their "factor"s and "device_class"s likely won't be used much or at all.
+    
+    # WATER_ int values must be different to avoid aliasing. Take care when using .value
+
+    def __new__(cls, value: int, factor: float, symbol: str, device_class: str):
+        "Ensures IntEnum functionality while allowing extra attributes."
+        
+        obj = int.__new__(cls, value if value <= 6 else value - 6)
+        obj._value_ = value
+        obj._factor = factor  # noqa: SLF001
+        obj._symbol = symbol  # noqa: SLF001
+        obj._device_class = device_class  # noqa: SLF001
+        return obj
+
+    @property
+    def lower(self) -> str:
+        """Returns unit name in lower case."""
+        return self.name.lower()
+
+    @property
+    def factor(self) -> float:
+        """Returns unit conversion factor."""
+        return self._factor
+
+    @property
+    def symbol(self) -> str:
+        """Returns unit symbol."""
+        return self._symbol
+
+    @property
+    def device_class(self) -> str:
+        """Returns unit device class."""
+        return self._device_class
+
+    @classmethod
+    def round(self, value: float, unit: _Unit):
+        return round(value, ROUNDING_RULES.get(unit, 0))
+
+    @classmethod
+    def convert_feed(
+        self, value: float, from_unit: _Unit | None, to_unit: _Unit | None, rounded: bool = False
+    ):
+        """Convert PetLibro feed units. Use **None** for portion unit (1/12th of a cup)."""
+        if value and from_unit != to_unit:
+            if not {from_unit, to_unit}.issubset(VALID_UNIT_TYPES[APIKey.FEED_UNIT]):
+                raise ValueError(f"Incompatible conversion: {from_unit} -> {to_unit}")
+
+            from_factor = from_unit.factor if from_unit else 1
+            to_factor = to_unit.factor if to_unit else 1
+
+            api_value = value / from_factor
+            new_value = api_value * to_factor
+        else:
+            new_value = value
+
+        if not to_unit:
+            return round(new_value)
+        if rounded:
+            return Unit.round(new_value, to_unit)
+        return new_value
+    
+
+DEFAULT_WEIGHT = Unit.POUNDS
+DEFAULT_FEED = Unit.CUPS
+DEFAULT_WATER = Unit.WATER_OUNCES
+MAX_FEED_PORTIONS = 48
+VALID_UNIT_TYPES: dict[str, set[Unit]] = {
+    APIKey.WEIGHT_UNIT: {Unit.POUNDS, Unit.KILOGRAMS, None},
+    APIKey.FEED_UNIT: {Unit.CUPS, Unit.OUNCES, Unit.GRAMS, Unit.MILLILITERS, None},
+    APIKey.WATER_UNIT: {Unit.WATER_OUNCES, Unit.WATER_MILLILITERS, None},
+}
+ROUNDING_RULES = {
+    Unit.CUPS: 3, Unit.OUNCES: 2, Unit.POUNDS: 2, Unit.WATER_OUNCES: 2, Unit.KILOGRAMS: 2
+}
+WATER_MAPPING = {
+    Unit.MILLILITERS: Unit.WATER_MILLILITERS, Unit.OUNCES: Unit.WATER_OUNCES
+}

custom_components/petlibro/devices/device.py

@@ -5,16 +5,18 @@
 
 from ..api import PetLibroAPI
 from .event import Event, EVENT_UPDATE
+from ..member import Member
 
 
 _LOGGER = getLogger(__name__)
 
 
 class Device(Event):
-    def __init__(self, data: dict, api: PetLibroAPI):
+    def __init__(self, data: dict, member: Member, api: PetLibroAPI):
         super().__init__()
         self._data: dict = {}
         self.api = api
+        self.member = member
 
         self.update_data(data)