Revert "feature/sync-measurement-units (#138)" (#142)

This reverts commit d39c4de.

Author: jjjonesjr33

custom_components/petlibro/config_flow.py

@@ -10,23 +10,21 @@
 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, Platform
+from homeassistant.const import CONF_API_TOKEN, CONF_EMAIL, CONF_PASSWORD, CONF_REGION
 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,
-    APIKey as API,
+    CommonAPIKeys as API,
     Gender,
-    Unit,
+    UnitTypes,
 )
 from .exceptions import PetLibroCannotConnect, PetLibroInvalidAuth
 from .hub import PetLibroHub
@@ -203,54 +201,25 @@ async def async_step_account_settings(
             return self.async_abort(reason="account_update_nomember")
 
         user_input = user_input or {}
-        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)
-            
+        if user_input:
             update_setting = self.collect_updates(
                 fields=(API.FEED_UNIT, API.WATER_UNIT, API.WEIGHT_UNIT),
-                user_input=update_setting_temp,
-                enum_cls=Unit,
+                user_input=user_input.pop("measurement_unit", {}),
+                enum_cls=UnitTypes,
             )
 
             update_info = self.collect_updates(
                 fields=(API.NICKNAME, API.GENDER),
-                user_input=update_info_temp,
+                user_input=user_input,
                 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.")
-                reason = "account_update_nochanges" + ("_update_sensors" if update_all_units else "")
-                return self.async_abort(reason=reason)
+                return self.async_abort(reason="account_update_nochanges")
 
             no_error = await self.api.member_update_info(update_info, update_setting)
             await self.hub.async_refresh(force_member=True)
@@ -283,12 +252,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, Gender.NONE).lower
+                            API.GENDER, getattr(self.member, API.GENDER, str(Gender.NONE))
                         ),
                     ): selector(
                         {
                             "select": {
-                                "options": [g.lower for g in Gender],
+                                "options": [g.name.lower() for g in Gender],
                                 "mode": "dropdown",
                                 "translation_key": "member_gender",
                             }
@@ -311,32 +280,33 @@ 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).lower
+                        API.FEED_UNIT, getattr(self.member, API.FEED_UNIT, DEFAULT_FEED.name)
                     ),
-                ): self._unit_selector((Unit.CUPS, Unit.OUNCES, Unit.GRAMS, Unit.MILLILITERS)),
+                ): self._unit_selector(
+                    (UnitTypes.CUPS, UnitTypes.OUNCES, UnitTypes.GRAMS, UnitTypes.MILLILITERS)
+                ),
                 vol.Required(
                     str(API.WATER_UNIT),
                     default=user_input.get(
-                        API.WATER_UNIT, getattr(self.member, API.WATER_UNIT, DEFAULT_WATER).lower
+                        API.WATER_UNIT, getattr(self.member, API.WATER_UNIT, DEFAULT_WATER.name)
                     ),
-                ): self._unit_selector((Unit.WATER_OUNCES, Unit.WATER_MILLILITERS)),
+                ): self._unit_selector((UnitTypes.OUNCES, UnitTypes.MILLILITERS)),
                 vol.Required(
                     str(API.WEIGHT_UNIT),
                     default=user_input.get(
                         API.WEIGHT_UNIT,
-                        getattr(self.member, API.WEIGHT_UNIT, DEFAULT_WEIGHT).lower,
+                        getattr(self.member, API.WEIGHT_UNIT, DEFAULT_WEIGHT.name),
                     ),
-                ): self._unit_selector((Unit.POUNDS, Unit.KILOGRAMS)),
-                vol.Optional("update_all_units", default=user_input.get("update_all_units", False)): bool,
+                ): self._unit_selector((UnitTypes.POUNDS, UnitTypes.KILOGRAMS)),
             }
         )
 
-    def _unit_selector(self, options: tuple[Unit, ...]) -> Any:
+    def _unit_selector(self, options: tuple[Enum, ...]) -> Any:
         """Return a dropdown selector for measurement unit options."""
         return selector(
             {
                 "select": {
-                    "options": [o.lower for o in options],
+                    "options": [o.name.lower() for o in options],
                     "mode": "dropdown",
                     "translation_key": "unit_type",
                 }
@@ -354,7 +324,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]
+            return enum_cls[form_value_str].value
 
         _LOGGER.error("Invalid value: %s for API key: %s", form_value, api_key)
         return None
@@ -388,7 +358,6 @@ def collect_updates(
             else:
                 api_value = form_value
 
-            if api_value != current_value:
-                updates[api_key] = api_value
-                
+            updates[api_key] = api_value
+
         return updates

custom_components/petlibro/const.py

@@ -4,8 +4,6 @@
 
 from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, UnitOfMass, UnitOfVolume
 
-type _Unit = Unit
-
 DOMAIN = "petlibro"
 
 # Configuration keys
@@ -21,6 +19,42 @@
 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."""
 
@@ -38,10 +72,13 @@ def __new__(cls, value: int, icon: str, symbol: str, emoji: str):
         obj._emoji = emoji  # noqa: SLF001
         return obj
 
-    @property
-    def lower(self) -> str:
-        """Returns unit name in lower case."""
-        return self.name.lower()
+    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 icon(self) -> str:
@@ -59,120 +96,13 @@ def emoji(self) -> str:
         return self._emoji
 
 
-class APIKey(StrEnum):
+class CommonAPIKeys(StrEnum):
     """Common API JSON keys."""
 
-    # Common
-    ID = "id"
-    NAME = "name"
-    WEIGHT = "weight"
-
-    # Member
+    ACCOUNT_ID = "id"
     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,18 +5,16 @@
 
 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, member: Member, api: PetLibroAPI):
+    def __init__(self, data: dict, api: PetLibroAPI):
         super().__init__()
         self._data: dict = {}
         self.api = api
-        self.member = member
 
         self.update_data(data)