Feature/pets management (#204)

* Pets Management integration

Changes:
    Replaced uses of 'datetime.utcnow()' (deprecated) with homeassistant.util.dt.utcnow()
    Moved the 'PetlibroHub.loaded_device_sn' set to the DevicesHelper.
    Moved the 'PetlibroHub.feed_number_unique_ids' and 'PetlibroHub.unit_entities_unique_ids' dicts to the Unit_Entities helper.
    Changed 'PetlibroHub.devices' to a dictionary with serial numbers as keys.

New:
    Device serial numbers, device IDs and owned/shared status gets saved to Config Entry options.
    Pet IDs, pet device IDs and owned/shared status gets saved to Config Entry options.
    Added DevicesHelper.
    Added PetsHelper.
    Devices and Pets removed from the Petlibro account will be removed from the integration automatically.
    Added 'media' directory for images etc.
    Added option to Integration Settings:
        Show Pets from Shared Devices
    Added entity platforms:
        date
        image
    Added methods to API:
        device_get_bound_pets
        pets.get_list
        pets.get_details
        pets.get_bound_devices
        pets.save_or_update
        pets.goal_setting
    Added Pet object and pet devices with entities.

* Added missing feed unit mismatch failsafe to pets entities

---------

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

Author: FeliGoblin

custom_components/petlibro/__init__.py

@@ -179,14 +179,17 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         # Store the hub in hass.data
         hass.data.setdefault(DOMAIN, {})[entry.entry_id] = hub
 
+        # Initialize Helpers
+        await hub._initialize_helpers()
+
         # Load member only once here
         await hub.load_member()
 
         # Load devices only once here
         await hub.load_devices()
-        
-        # Initialize Helpers
-        await hub._initialize_helpers()
+
+        # Load pets only once here
+        await hub.load_pets()
 
         # Start the coordinator for periodic updates
         await hub.coordinator.async_config_entry_first_refresh()
@@ -236,6 +239,6 @@ async def async_remove_config_entry_device(hass: HomeAssistant, entry: ConfigEnt
         identifier
         for identifier in device_entry.identifiers
         if identifier[0] == DOMAIN
-        for device in hub.devices
+        for device in hub.devices.values()
         if device.serial == identifier[1]
-    )
+    )

custom_components/petlibro/api.py

@@ -15,13 +15,14 @@
 
 from logging import getLogger
 from hashlib import md5
+import sys
 from urllib.parse import urljoin
 from typing import Any, Dict, List, TypeAlias
-from datetime import datetime, timedelta
+from datetime import timedelta
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
-from homeassistant.exceptions import ConfigEntryAuthFailed
-from .exceptions import PetLibroAPIError, PetLibroInvalidAuth
-from aiohttp import ClientSession, ClientError
+from homeassistant.util.dt import utcnow
+from .exceptions import PetLibroAPIError
+from aiohttp import ClientSession
 
 import aiohttp
 import uuid  # To generate unique request IDs
@@ -204,6 +205,10 @@ def __init__(self, session: ClientSession, time_zone: str, region: str, email: s
         self._last_api_call_times = {}  # To store last call time per device
         self._cached_responses = {}  # To store cached responses for short periods
 
+        if "PL_PetAPI" not in sys.modules:
+            from .pets.api import PL_PetAPI
+        self.pets = PL_PetAPI(self.hass, self.config_entry, self.session)
+
     @staticmethod
     def hash_password(password: str) -> str:
         """Generate the password hash for the API"""
@@ -242,7 +247,7 @@ async def login(self, email: str, password: str) -> str:
 
     async def get_device_real_info(self, device_id: str) -> dict:
         """Fetch real-time information for a device, with caching to prevent frequent requests."""
-        now = datetime.utcnow()
+        now = utcnow()
         last_call_time = self._last_api_call_times.get(f"{device_id}_realInfo")
 
         # If we made the request within the last 10 seconds, return cached response
@@ -268,7 +273,7 @@ async def get_device_real_info(self, device_id: str) -> dict:
 
     async def get_device_data_real_info(self, device_id: str) -> dict:
         """Fetch real-time information for a device, with caching to prevent frequent requests."""
-        now = datetime.utcnow()
+        now = utcnow()
         last_call_time = self._last_api_call_times.get(f"{device_id}_dataRealInfo")
 
         # If we made the request within the last 10 seconds, return cached response
@@ -294,7 +299,7 @@ async def get_device_data_real_info(self, device_id: str) -> dict:
 
     async def get_device_drink_water(self, device_id: str) -> dict:
         """Fetch real-time information for a device, with caching to prevent frequent requests."""
-        now = datetime.utcnow()
+        now = utcnow()
         last_call_time = self._last_api_call_times.get(f"{device_id}_drinkWater")
 
         # If we made the request within the last 10 seconds, return cached response
@@ -320,7 +325,7 @@ async def get_device_drink_water(self, device_id: str) -> dict:
 
     async def get_device_attribute_settings(self, device_id: str) -> dict:
         """Fetch real-time information for a device, with caching to prevent frequent requests."""
-        now = datetime.utcnow()
+        now = utcnow()
         last_call_time = self._last_api_call_times.get(f"{device_id}_getAttributeSetting")
 
         # If we made the request within the last 10 seconds, return cached response
@@ -345,7 +350,7 @@ async def get_device_attribute_settings(self, device_id: str) -> dict:
 
     async def get_device_upgrade(self, device_id: str) -> dict:
         """Fetch real-time information for a device, with caching to prevent frequent requests."""
-        now = datetime.utcnow()
+        now = utcnow()
         last_call_time = self._last_api_call_times.get(f"{device_id}_getUpgrade")
 
         # If we made the request within the last 10 seconds, return cached response
@@ -370,7 +375,7 @@ async def get_device_upgrade(self, device_id: str) -> dict:
 
     async def get_device_base_info(self, device_id: str) -> dict:
         """Fetch real-time information for a device, with caching to prevent frequent requests."""
-        now = datetime.utcnow()
+        now = utcnow()
         last_call_time = self._last_api_call_times.get(f"{device_id}_baseInfo")
 
         # If we made the request within the last 10 seconds, return cached response
@@ -395,7 +400,7 @@ async def get_device_base_info(self, device_id: str) -> dict:
 
     async def get_device_work_record(self, device_id: str) -> dict:
         """Fetch real-time information for a device, with caching to prevent frequent requests."""
-        now = datetime.utcnow()
+        now = utcnow()
         last_call_time = self._last_api_call_times.get(f"{device_id}_work_record")
 
         if last_call_time and (now - last_call_time) < timedelta(seconds=10):
@@ -432,7 +437,7 @@ async def get_device_work_record(self, device_id: str) -> dict:
 
     async def get_device_events(self, device_id: str) -> dict:
         """Fetch real-time information for a device, with caching to prevent frequent requests."""
-        now = datetime.utcnow()
+        now = utcnow()
         last_call_time = self._last_api_call_times.get(f"{device_id}_events")
 
         # If we made the request within the last 10 seconds, return cached response
@@ -463,7 +468,7 @@ async def get_default_matrix(self, device_sn: str) -> dict:
         :return: The default matrix data.
         """
         # Check cache for recently fetched data
-        now = datetime.utcnow()
+        now = utcnow()
         cache_key = f"{device_sn}_getDefaultMatrix"
         last_call_time = self._last_api_call_times.get(cache_key)
 
@@ -542,6 +547,21 @@ async def device_feeding_plan_list(self, serial: str) -> List[Dict[str, Any]]:
     async def device_wet_feeding_plan(self, serial: str) -> Dict[str, Any]:
         return await self.session.post_serial("/device/wetFeedingPlan/wetListV3", serial)
 
+    async def device_get_bound_pets(self, device_sn: str) -> list[dict]:
+        """Get pets bound to a device."""
+        _LOGGER.debug("Requesting pets bound to device sn: %s", device_sn)
+
+        try:
+            data = await self.session.post("/device/devicePetRelation/getBoundPets", json={"deviceSn": device_sn})
+        except Exception as exc:
+            raise PetLibroAPIError("Failed to fetch list of bound pets") from exc
+
+        if data and not isinstance(data, list):
+            raise PetLibroAPIError(f"Invalid bound pets response format: {data}")
+        
+        _LOGGER.debug("Bound pets retrieved successfully")
+        return data or []
+
     # Support for new switch functions
     async def set_feeding_plan(self, serial: str, enable: bool):
         """Set the feeding plan on/off."""

custom_components/petlibro/binary_sensor.py

@@ -612,7 +612,7 @@ async def async_setup_entry(
 ) -> None:
     """Set up PETLIBRO binary sensors using config entry."""
     # Retrieve the hub from hass.data that was set up in __init__.py
-    hub = hass.data[DOMAIN].get(entry.entry_id)
+    hub: PetLibroHub = hass.data[DOMAIN].get(entry.entry_id)
 
     if not hub:
         _LOGGER.error("Hub not found for entry: %s", entry.entry_id)
@@ -632,7 +632,7 @@ async def async_setup_entry(
     # Create binary sensor entities for each device based on the binary sensor map
     entities = [
         PetLibroBinarySensorEntity(device, hub, description)
-        for device in devices  # Iterate through devices from the hub
+        for device in devices.values()  # Iterate through devices from the hub
         for device_type, entity_descriptions in DEVICE_BINARY_SENSOR_MAP.items()
         if isinstance(device, device_type)
         for description in entity_descriptions
@@ -648,4 +648,3 @@ async def async_setup_entry(
 
         # Add binary sensor entities to Home Assistant
         async_add_entities(entities)
-

custom_components/petlibro/button.py

@@ -484,7 +484,7 @@ async def async_setup_entry(
 ) -> None:
     """Set up PETLIBRO buttons using config entry."""
     # Retrieve the hub from hass.data that was set up in __init__.py
-    hub = hass.data[DOMAIN].get(entry.entry_id)
+    hub: PetLibroHub = hass.data[DOMAIN].get(entry.entry_id)
 
     if not hub:
         _LOGGER.error("Hub not found for entry: %s", entry.entry_id)
@@ -504,7 +504,7 @@ async def async_setup_entry(
     # Create button entities for each device based on the button map
     entities = [
         PetLibroButtonEntity(device, hub, description)
-        for device in devices  # Iterate through devices from the hub
+        for device in devices.values()  # Iterate through devices from the hub
         for device_type, entity_descriptions in DEVICE_BUTTON_MAP.items()
         if isinstance(device, device_type)
         for description in entity_descriptions

custom_components/petlibro/config_flow.py

@@ -6,6 +6,7 @@
 from enum import Enum
 import logging
 from typing import Any
+from types import MappingProxyType
 
 import voluptuous as vol
 
@@ -23,11 +24,11 @@
     DEFAULT_FEED,
     DEFAULT_WATER,
     DEFAULT_WEIGHT,
-    MANUAL_FEED_PORTIONS,
     DOMAIN,
     APIKey as API,
     Gender,
     Unit,
+    IntegrationSetting,
 )
 from .exceptions import PetLibroCannotConnect, PetLibroInvalidAuth
 from .hub import PetLibroHub
@@ -201,33 +202,48 @@ async def async_step_integration_settings(
         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)            
-            
+            # --- Extract updates
+            updates = self.collect_updates(
+                fields=IntegrationSetting,
+                user_input=user_input,
+                local_data=self.entry.options,
+            )
+
             # --- Nothing changed
-            if manual_feed_portions == current_value:
+            if not updates:
                 _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)
+            # --- Update options
+            self.hub.update_options(updates)
+            _LOGGER.debug("Updated integration settings: %s", updates)
 
             abort_messages = [self.get_common_translation("settings_updated", "Settings updated")]
+            auto_reload = manual_reload = False
 
-            # --- Update entities and warn user if feed unit is cups
-            if self.member.feedUnitType == Unit.CUPS:
-                reload_needed = await self.hub.unit_entities.sync_manual_feed_entity_visibility(Unit.CUPS)
-
-                if reload_needed:
-                    abort_messages.append(
-                        self.get_common_translation("reloading_integration", "The integration will reload shortly")
-                    )
+            # --- Update entities and warn user if MANUAL_FEED_PORTIONS was changed and feed unit is cups
+            if IntegrationSetting.MANUAL_FEED_PORTIONS in updates and self.member.feedUnitType == Unit.CUPS:
+                if await self.hub.unit_entities.sync_manual_feed_entity_visibility(Unit.CUPS):
                     _LOGGER.debug("'manual_feed_portions' value changed while feed unit is 'cups', reloading integration.")
+                    auto_reload = True
                 else:
                     _LOGGER.debug("No Manual Feed entities found — nothing to reload.")
+
+            if IntegrationSetting.ENABLE_SHARED_PETS in updates:
+                if updates[IntegrationSetting.ENABLE_SHARED_PETS]:
+                    manual_reload = True
+                else:
+                    await self.hub.pets_helper.remove_shared_pets()
+
             await self.hub.async_refresh()
 
+            if auto_reload or manual_reload:
+                abort_messages.append(
+                    self.get_common_translation("reloading_integration", "The integration will reload shortly")
+                )
+                if not auto_reload:
+                    self.hass.config_entries.async_schedule_reload(self.handler)
+
             # --- Done
             return self.async_abort(
                 reason="integration_settings_abort",
@@ -256,12 +272,14 @@ async def async_step_account_settings(
             unit_updates = self.collect_updates(
                 fields=(API.FEED_UNIT, API.WATER_UNIT, API.WEIGHT_UNIT),
                 user_input=measurement_units_raw,
+                local_data=self.member,
                 enum_cls=Unit,
             )
 
             info_updates = self.collect_updates(
                 fields=(API.NICKNAME, API.GENDER),
                 user_input=account_info_raw,
+                local_data=self.member,
                 special={
                     API.NICKNAME: lambda v: v or "",
                     API.GENDER: lambda v: self.validate_enum(API.GENDER, v, Gender),
@@ -317,10 +335,11 @@ def _show_integration_settings_form(self, user_input: dict[str, Any]) -> ConfigF
         return self.async_show_form(
             data_schema=vol.Schema(
                 {
-                    vol.Optional(
-                        MANUAL_FEED_PORTIONS,
-                        default=self.entry.options.get(MANUAL_FEED_PORTIONS, False),
+                    vol.Required(
+                        setting.value,
+                        default=self.entry.options.get(setting, setting.default),
                     ): selector({"boolean": {}})
+                    for setting in IntegrationSetting
                 }
             ),
             description_placeholders={
@@ -425,6 +444,7 @@ def collect_updates(
         self,
         fields: tuple[str, ...],
         user_input: dict[str, Any],
+        local_data: dict[str, Any],
         enum_cls: type[Enum] | None = None,
         special: dict[str, Callable[[Any], Any]] | None = None,
     ) -> dict[str, Any]:
@@ -433,10 +453,15 @@ def collect_updates(
 
         for api_key in fields:
             form_value = user_input.get(api_key)
-            current_value = getattr(self.member, api_key, SENTINEL)
+
+            current_value = (
+                local_data.get(api_key, SENTINEL)
+                if isinstance(local_data, MappingProxyType)
+                else getattr(local_data, api_key, SENTINEL)
+            )
 
             if current_value is SENTINEL:
-                _LOGGER.error("Unsupported API key: %s", api_key)
+                _LOGGER.warning("Unsupported API key: %s", api_key)
                 continue
             if form_value == current_value:
                 continue