Cups and portions update

Manual Feed Quantity now a dropdown for Cups unit.
Added option for 'portions' for Manual Feed Quantity.

Author: FeliGoblin

custom_components/petlibro/__init__.py

@@ -162,7 +162,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
     # Initialize PetLibroHub
     try:
-        hub = PetLibroHub(hass, entry.data)
+        hub = PetLibroHub(hass, entry)
 
         # Store the hub in hass.data
         hass.data.setdefault(DOMAIN, {})[entry.entry_id] = hub
@@ -172,6 +172,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
         # Load devices only once here
         await hub.load_devices()
+        
+        # Initialize Helpers
+        await hub._initialize_helpers()
 
         # Start the coordinator for periodic updates
         await hub.coordinator.async_config_entry_first_refresh()

custom_components/petlibro/config_flow.py

@@ -10,19 +10,20 @@
 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 homeassistant.helpers.translation import async_get_translations
 
 from .api import PetLibroAPI
 from .const import (
+    SENTINEL,
     DEFAULT_FEED,
     DEFAULT_WATER,
     DEFAULT_WEIGHT,
-    ROUNDING_RULES,
+    MANUAL_FEED_PORTIONS,
     DOMAIN,
     APIKey as API,
     Gender,
@@ -161,8 +162,6 @@ def async_get_options_flow(config_entry: ConfigEntry) -> PetlibroOptionsFlow:
 class PetlibroOptionsFlow(OptionsFlow):
     """Handle an options flow for Petlibro."""
 
-    _SENTINEL = object()
-
     def __init__(self):
         """Initialise Petlibro Options Flow."""
         self._data: dict[str, Any] = {}  # For storing temporary data.
@@ -181,6 +180,8 @@ async def async_step_init(
         """Handle the initial options menu."""
 
         _LOGGER.debug("Starting Petlibro options flow.")
+        self.translations = await async_get_translations(
+            self.hass, self.hass.config.language, "common")
         self.entry = self.config_entry
         self.hub = self.hass.data[DOMAIN][self.handler]
         self.api = self.hub.api
@@ -190,73 +191,116 @@ async def async_step_init(
         _LOGGER.debug(
             "Started Petlibro options flow for account %s", self.entry.data[CONF_EMAIL]
         )
+        return self.async_show_menu(menu_options=["integration_settings", "account_settings"])
+
+    async def async_step_integration_settings(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle integration-level settings for the Petlibro integration."""
+        
+        user_input = user_input or {}
+        
+        if user_input:
+            manual_feed_portions = user_input.get(MANUAL_FEED_PORTIONS)
+            current_value = self.entry.options.get(MANUAL_FEED_PORTIONS, False)            
+            
+            # --- Nothing changed
+            if manual_feed_portions == current_value:
+                _LOGGER.debug("No integration settings changed.")
+                return self.async_abort(reason=self.get_common_translation("no_settings_changed", "No settings were changed"))
+
+            # --- Update option
+            self.hub.update_options({MANUAL_FEED_PORTIONS: manual_feed_portions})
+            _LOGGER.debug("Updated %s to %s", MANUAL_FEED_PORTIONS, manual_feed_portions)
+            
+            abort_messages = [self.get_common_translation("settings_updated", "Settings updated")]
+
+            # --- Reload integration if feed unit is cups
+            if self.member.feedUnitType == Unit.CUPS:
+                reload_integration = await self.hub.unit_entities.sync_manual_feed_entity_visibility(Unit.CUPS)
 
-        # Using a menu so more things can be added later.
-        return self.async_show_menu(menu_options=["account_settings"])
+                if reload_integration:
+                    abort_messages.append(
+                        self.get_common_translation("reloading_integration", "The integration is being reloaded")
+                    )
+                    _LOGGER.debug("'manual_feed_portions' value changed while feed unit is 'cups', reloading integration.")
+                    self.hass.config_entries.async_schedule_reload(self.handler)
+                else:
+                    _LOGGER.debug("No Manual Feed entities found — nothing to reload.")
+            else:
+                await self.hub.async_refresh()
+
+            # --- Done
+            return self.async_abort(
+                reason="integration_settings_abort",
+                description_placeholders={"integration_settings_abort": "\n".join(abort_messages)},
+            )
 
+        _LOGGER.debug("Showing integration settings form.")
+        return self._show_integration_settings_form(user_input)
+        
     async def async_step_account_settings(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
         """Handle account settings."""
 
         if not self.member:
-            return self.async_abort(reason="account_update_nomember")
+            return self.async_abort(reason="no_member_data")
 
         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:
+            # --- Extract updates
+            measurement_units_raw: dict = user_input.pop("measurement_unit", {})
+            account_info_raw = user_input.copy()
+            user_input.update(**measurement_units_raw)
+            update_all_units = measurement_units_raw.pop("update_all_units", False)
 
-            update_setting = self.collect_updates(
+            unit_updates = self.collect_updates(
                 fields=(API.FEED_UNIT, API.WATER_UNIT, API.WEIGHT_UNIT),
-                user_input=update_setting_temp,
+                user_input=measurement_units_raw,
                 enum_cls=Unit,
             )
 
-            update_info = self.collect_updates(
+            info_updates = self.collect_updates(
                 fields=(API.NICKNAME, API.GENDER),
-                user_input=update_info_temp,
+                user_input=account_info_raw,
                 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)
 
-            no_error = await self.api.member_update_info(update_info, update_setting)
-            await self.hub.async_refresh(force_member=True)
+            # --- Update entity options if units changed or update_all_units
+            reload_integration = await self.hub.unit_entities.update_sensor_entity_units(unit_updates, update_all_units)
 
+            # --- Apply account-level changes through API
+            abort_messages = []
+            if not (info_updates or unit_updates):
+                _LOGGER.debug("No account settings were changed.")
+                abort_messages.append(self.get_common_translation("no_settings_changed", "No settings were changed"))
+            else:
+                success = await self.api.member_update_info(update_info = info_updates, update_setting = unit_updates)
+                if success:
+                    abort_messages.append(self.get_common_translation("account_updated", "Account update successful"))
+                else:
+                    _LOGGER.error("Error updating account info via API.")
+                    return self.async_abort(reason="error_check_logs")
+
+            if update_all_units:
+                abort_messages.append(self.get_common_translation("sensors_updated", "Sensor entities were updated"))
+
+            # --- Reload or refresh
+            if reload_integration:
+                _LOGGER.debug("Reloading integration due to feed unit change to/from cups, or update_all_units chosen.")
+                abort_messages.append(self.get_common_translation("reloading_integration", "The integration is being reloaded"))
+                self.hass.config_entries.async_schedule_reload(self.handler)
+            elif info_updates or unit_updates:
+                await self.hub.async_refresh(force_member=True)
+                
+            # --- Done
             return self.async_abort(
-                reason="account_update_success" if no_error else "error_check_logs"
+                reason="account_settings_abort",
+                description_placeholders={"account_settings_abort": "\n".join(abort_messages)},
             )
 
         _LOGGER.debug("Showing account settings form.")
@@ -265,6 +309,23 @@ async def async_step_account_settings(
     # ------------------------------
     # Form Builders
     # ------------------------------
+    
+    def _show_integration_settings_form(self, user_input: dict[str, Any]) -> ConfigFlowResult:
+        """Build and show the integration settings form."""
+
+        return self.async_show_form(
+            data_schema=vol.Schema(
+                {
+                    vol.Optional(
+                        MANUAL_FEED_PORTIONS,
+                        default=self.entry.options.get(MANUAL_FEED_PORTIONS, False),
+                    ): selector({"boolean": {}})
+                }
+            ),
+            description_placeholders={
+                "uom": getattr(self.member, API.FEED_UNIT, DEFAULT_FEED).symbol
+            },
+        )
 
     def _show_account_settings_form(self, user_input: dict[str, Any]) -> ConfigFlowResult:
         """Build and show the account settings form."""
@@ -371,9 +432,9 @@ def collect_updates(
 
         for api_key in fields:
             form_value = user_input.get(api_key)
-            current_value = getattr(self.member, api_key, self._SENTINEL)
+            current_value = getattr(self.member, api_key, SENTINEL)
 
-            if current_value is self._SENTINEL:
+            if current_value is SENTINEL:
                 _LOGGER.error("Unsupported API key: %s", api_key)
                 continue
             if form_value == current_value:
@@ -392,3 +453,10 @@ def collect_updates(
                 updates[api_key] = api_value
 
         return updates
+    
+    def get_common_translation(self, translation_key: str, fallback: str = "") -> str:
+        """Get a translated string under the 'common' key from the user's chosen language."""
+        translation_path = f"component.{DOMAIN}.common.{translation_key}"
+        if translation_path not in self.translations:
+            _LOGGER.warning("Translation key %s not found in translation file.", translation_key)
+        return self.translations.get(translation_path, fallback)

custom_components/petlibro/const.py

@@ -5,8 +5,10 @@
 from homeassistant.const import CONF_EMAIL, CONF_PASSWORD, UnitOfMass, UnitOfVolume
 
 type _Unit = Unit
+SENTINEL = object()
 
 DOMAIN = "petlibro"
+GITHUB = "https://github.com/jjjonesjr33/petlibro"
 
 # Configuration keys
 CONF_EMAIL = "email"
@@ -85,9 +87,15 @@ class APIKey(StrEnum):
 
 
 class Unit(IntEnum):
-    """Weight, feed, and water units with symbols and conversion."""
+    """Weight, feed, and water units with symbols and conversion.
+    
+    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.
+    
+    WATER int values must be different to avoid aliasing. Take care when using .value
+    """
 
-    CUPS = 1, 1/12, "cup", ""
+    CUPS = 1, 1/12, "cups", ""
     OUNCES = 2, 0.35, UnitOfMass.OUNCES, "weight"
     GRAMS = 3, 10, UnitOfMass.GRAMS, "weight"
     MILLILITERS = 4, 20, UnitOfVolume.MILLILITERS, "volume"
@@ -97,11 +105,6 @@ class Unit(IntEnum):
 
     WATER_OUNCES = 2 +6, 0.033814, 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."
@@ -165,6 +168,7 @@ def convert_feed(
 DEFAULT_FEED = Unit.CUPS
 DEFAULT_WATER = Unit.WATER_OUNCES
 MAX_FEED_PORTIONS = 48
+MANUAL_FEED_PORTIONS = "manual_feed_portions"
 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},

custom_components/petlibro/helpers/__init__.py

@@ -0,0 +1 @@
+"""Helper methods for components within the Petlibro integration."""