Merge pull request #131 from c-st/use-same-unique-id

Auto lights fixes, code restructuring

Author: c-st

custom_components/auto_areas/auto_area.py

@@ -6,7 +6,7 @@
 from homeassistant.helpers.entity_registry import async_get as async_get_entity_registry
 from homeassistant.helpers.issue_registry import async_create_issue, IssueSeverity
 from homeassistant.config_entries import ConfigEntry
-
+from homeassistant.util import slugify
 from homeassistant.helpers.area_registry import AreaEntry
 from homeassistant.helpers.entity_registry import RegistryEntry
 
@@ -67,7 +67,6 @@ async def async_initialize(self):
             "%s: Initializing after HA start",
             self.area_name
         )
-
         self.auto_lights = AutoLights(self)
         await self.auto_lights.initialize()
 
@@ -98,3 +97,8 @@ def get_valid_entities(self) -> list[RegistryEntry]:
     def area_name(self) -> str:
         """Return area name or fallback."""
         return self.area.name if self.area is not None else "unknown"
+
+    @property
+    def slugified_area_name(self) -> str:
+        """Return slugified area name or fallback."""
+        return slugify(self.area.name) if self.area is not None else "unknown"

custom_components/auto_areas/auto_entity.py

@@ -136,13 +136,6 @@ async def _handle_state_change(self, event: Event[EventStateChangedData]):
 
         self._aggregated_state = self._get_state()
 
-        LOGGER.debug(
-            "%s: got state %s, %d entities",
-            self.device_class,
-            str(self.state),
-            len(self.entity_states.values())
-        )
-
         self.async_schedule_update_ha_state()
 
     async def async_will_remove_from_hass(self) -> None:

custom_components/auto_areas/auto_lights.py

@@ -51,17 +51,18 @@ def __init__(self, auto_area) -> None:
             or []
         )
 
+        # Entities
         self.sleep_mode_entity_id = (
             f"{SLEEP_MODE_SWITCH_ENTITY_PREFIX}{
-                slugify(self.auto_area.area.name)}"
+                slugify(self.auto_area.area_name)}"
         )
         self.presence_entity_id = (
             f"{PRESENCE_BINARY_SENSOR_ENTITY_PREFIX}{
-                slugify(self.auto_area.area.name)}"
+                slugify(self.auto_area.area_name)}"
         )
         self.illuminance_entity_id = (
             f"{ILLUMINANCE_SENSOR_ENTITY_PREFIX}{
-                slugify(self.auto_area.area.name)}"
+                slugify(self.auto_area.area_name)}"
         )
 
         self.light_entity_ids = [
@@ -80,17 +81,22 @@ def __init__(self, auto_area) -> None:
 
         LOGGER.debug(
             "%s: Managing light entities: %s",
-            self.auto_area.area.name,
+            self.auto_area.area_name,
             self.light_entity_ids,
         )
+
         if len(self.light_entity_ids) == 0:
             LOGGER.warning(
-                "%s: No light entities found to manage", self.auto_area.area.name
+                "%s: No light entities found to manage",
+                self.auto_area.area_name
             )
-            return
 
     async def initialize(self):
         """Start subscribing to state changes."""
+        LOGGER.debug("AutoLights %s %s",
+                     self.presence_entity_id,
+                     self.illuminance_entity_id
+                     )
 
         if self.is_sleeping_area:
             # set initial state
@@ -107,13 +113,23 @@ async def initialize(self):
         initial_presence_state = self.hass.states.get(self.presence_entity_id)
         if initial_presence_state and self.light_entity_ids:
             if initial_presence_state.state == STATE_ON:
+                LOGGER.info(
+                    "%s: Initial presence detected. Turning lights on %s",
+                    self.auto_area.area_name,
+                    self.light_entity_ids,
+                )
                 await self.auto_area.hass.services.async_call(
                     LIGHT_DOMAIN,
                     SERVICE_TURN_ON,
                     {ATTR_ENTITY_ID: self.light_entity_ids},
                 )
                 self.lights_turned_on = True
             else:
+                LOGGER.info(
+                    "%s: No initial presence detected. Turning lights off %s",
+                    self.auto_area.area_name,
+                    self.light_entity_ids,
+                )
                 await self.auto_area.hass.services.async_call(
                     LIGHT_DOMAIN,
                     SERVICE_TURN_OFF,
@@ -139,6 +155,8 @@ async def handle_presence_state_change(self, event: Event[EventStateChangedData]
         from_state = event.data.get('old_state')
         to_state = event.data.get('new_state')
 
+        LOGGER.debug("handle_presence_state_change")
+
         previous_state = from_state.state if from_state else ""
         if to_state is None:
             return
@@ -159,7 +177,7 @@ async def handle_presence_state_change(self, event: Event[EventStateChangedData]
             if self.sleep_mode_enabled:
                 LOGGER.info(
                     "%s: Sleep mode is on. Not turning on lights",
-                    self.auto_area.area.name,
+                    self.auto_area.area_name,
                 )
                 return
 
@@ -171,7 +189,7 @@ async def handle_presence_state_change(self, event: Event[EventStateChangedData]
                 ):
                     LOGGER.info(
                         "%s: illuminance (%s lx) > threshold (%s lx). Not turning on lights",
-                        self.auto_area.area.name,
+                        self.auto_area.area_name,
                         current_illuminance,
                         self.illuminance_threshold,
                     )
@@ -180,7 +198,7 @@ async def handle_presence_state_change(self, event: Event[EventStateChangedData]
             # turn lights on
             LOGGER.info(
                 "%s: Turning lights on %s",
-                self.auto_area.area.name,
+                self.auto_area.area_name,
                 self.light_entity_ids,
             )
             await self.hass.services.async_call(
@@ -195,7 +213,7 @@ async def handle_presence_state_change(self, event: Event[EventStateChangedData]
             if not self.sleep_mode_enabled:
                 LOGGER.info(
                     "%s: Turning lights off %s",
-                    self.auto_area.area.name,
+                    self.auto_area.area_name,
                     self.light_entity_ids,
                 )
             await self.hass.services.async_call(
@@ -207,6 +225,7 @@ async def handle_presence_state_change(self, event: Event[EventStateChangedData]
 
     async def handle_sleep_mode_state_change(self, event: Event[EventStateChangedData]):
         """Handle changes in sleep mode."""
+
         entity_id = event.data.get('entity_id')
         from_state = event.data.get('old_state')
         to_state = event.data.get('new_state')
@@ -227,7 +246,7 @@ async def handle_sleep_mode_state_change(self, event: Event[EventStateChangedDat
         if current_state == STATE_ON:
             LOGGER.info(
                 "%s: Sleep mode enabled - turning lights off %s",
-                self.auto_area.area.name,
+                self.auto_area.area_name,
                 self.light_entity_ids,
             )
             self.sleep_mode_enabled = True
@@ -238,7 +257,10 @@ async def handle_sleep_mode_state_change(self, event: Event[EventStateChangedDat
             )
             self.lights_turned_on = False
         else:
-            LOGGER.info("%s: Sleep mode disabled", self.auto_area.area.name)
+            LOGGER.info(
+                "%s: Sleep mode disabled",
+                self.auto_area.area_name,
+            )
             self.sleep_mode_enabled = False
             has_presence = (
                 self.hass.states.get(self.presence_entity_id).state == STATE_ON
@@ -248,7 +270,7 @@ async def handle_sleep_mode_state_change(self, event: Event[EventStateChangedDat
                     return
                 LOGGER.info(
                     "%s: Turning lights on due to presence %s",
-                    self.auto_area.area.name,
+                    self.auto_area.area_name,
                     self.light_entity_ids,
                 )
                 await self.hass.services.async_call(
@@ -273,7 +295,7 @@ async def handle_illuminance_change(self, _event: Event[EventStateChangedData]):
         if self.lights_turned_on:
             LOGGER.debug(
                 "%s: Lights were already turned on. Not turning on lights",
-                self.auto_area.area.name,
+                self.auto_area.area_name,
             )
             return
 
@@ -283,7 +305,7 @@ async def handle_illuminance_change(self, _event: Event[EventStateChangedData]):
 
         LOGGER.info(
             "%s: Turning lights on due to illuminance %s",
-            self.auto_area.area.name,
+            self.auto_area.area_name,
             self.light_entity_ids,
         )
         await self.hass.services.async_call(
@@ -299,7 +321,7 @@ def is_below_illuminance_threshold(self) -> bool:
             if current_illuminance > self.illuminance_threshold:
                 LOGGER.debug(
                     "%s: illuminance (%s lx) > threshold (%s lx). Not turning on lights",
-                    self.auto_area.area.name,
+                    self.auto_area.area_name,
                     current_illuminance,
                     self.illuminance_threshold,
                 )
@@ -313,14 +335,17 @@ def get_current_illuminance(self) -> float | None:
             current_illuminance = float(
                 self.hass.states.get(self.illuminance_entity_id).state
             )
-        except ValueError:
+        except (ValueError, AttributeError):
             current_illuminance = None
 
         return current_illuminance
 
     def cleanup(self):
         """Deinitialize this area."""
-        LOGGER.debug("%s: Disabling light control", self.auto_area.area.name)
+        LOGGER.debug(
+            "%s: Disabling light control",
+            self.auto_area.area_name,
+        )
         if self.unsubscribe_sleep_mode is not None:
             self.unsubscribe_sleep_mode()
 

custom_components/auto_areas/binary_sensor.py

@@ -2,144 +2,16 @@
 
 from __future__ import annotations
 
-from functools import cached_property
-from typing import Literal, override
-from homeassistant.core import Event, EventStateChangedData
-from homeassistant.const import STATE_ON, STATE_OFF
-from homeassistant.components.binary_sensor import (
-    BinarySensorDeviceClass,
-    BinarySensorEntity,
-)
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
-from homeassistant.helpers.event import async_track_state_change_event
-from custom_components.auto_areas.ha_helpers import all_states_are_off
-
-from .auto_entity import AutoEntity
+from custom_components.auto_areas.binary_sensors.presence import PresenceBinarySensor
 
 from .auto_area import AutoArea
 from .const import (
     DOMAIN,
-    LOGGER,
-    PRESENCE_BINARY_SENSOR_DEVICE_CLASSES,
-    PRESENCE_BINARY_SENSOR_ENTITY_PREFIX,
-    PRESENCE_BINARY_SENSOR_PREFIX,
-    PRESENCE_ON_STATES,
 )
 
 
 async def async_setup_entry(hass, entry, async_add_entities: AddEntitiesCallback):
     """Set up the binary_sensor platform."""
     auto_area: AutoArea = hass.data[DOMAIN][entry.entry_id]
     async_add_entities([PresenceBinarySensor(hass, auto_area)])
-
-
-class PresenceBinarySensor(
-    AutoEntity[BinarySensorEntity, BinarySensorDeviceClass], BinarySensorEntity
-):
-    """Set up aggregated presence binary sensor."""
-
-    def __init__(self, hass, auto_area: AutoArea) -> None:
-        """Initialize presence binary sensor."""
-        super().__init__(
-            hass,
-            auto_area,
-            BinarySensorDeviceClass.OCCUPANCY,
-            PRESENCE_BINARY_SENSOR_PREFIX,
-            PRESENCE_BINARY_SENSOR_ENTITY_PREFIX
-        )
-        self.presence: bool | None = None
-        LOGGER.debug("Presence entities %s", self.entity_ids)
-
-    @cached_property
-    def is_on(self) -> bool | None:
-        """Return true if the binary sensor is on."""
-        return self.presence
-
-    @cached_property
-    def state(self) -> Literal["on", "off"] | None:  # type: ignore
-        """Return the state of the binary sensor."""
-        if (is_on := self.is_on) is None:
-            return None
-        return STATE_ON if is_on else STATE_OFF
-
-    @override
-    def _get_sensor_entities(self) -> list[str]:
-        """Retrieve all relevant presence entities."""
-        return [
-            entity.entity_id
-            for entity in self.auto_area.get_valid_entities()
-            if entity.device_class in PRESENCE_BINARY_SENSOR_DEVICE_CLASSES
-            or entity.original_device_class in PRESENCE_BINARY_SENSOR_DEVICE_CLASSES
-        ]
-
-    @override
-    async def async_added_to_hass(self):
-        """Start tracking sensors."""
-        LOGGER.debug(
-            "%s: Presence detection entities %s",
-            self.auto_area.area_name,
-            self.entity_ids,
-        )
-
-        # Set initial presence
-        self.presence = not all_states_are_off(
-            self.hass,
-            self.entity_ids,
-            PRESENCE_ON_STATES,
-        )
-        self.schedule_update_ha_state()
-
-        LOGGER.info(
-            "%s: Initial presence %s",
-            self.auto_area.area_name,
-            self.presence
-        )
-
-        # Subscribe to state changes
-        self.unsubscribe = async_track_state_change_event(
-            self.hass,
-            self.entity_ids,
-            self._handle_state_change,
-        )
-
-    @override
-    async def _handle_state_change(self, event: Event[EventStateChangedData]) -> None:
-        """Handle state change of any tracked presence sensors."""
-        entity_id = event.data.get('entity_id')
-        from_state = event.data.get('old_state')
-        to_state = event.data.get('new_state')
-
-        previous_state = from_state.state if from_state else ""
-        current_state = to_state.state if to_state else ""
-
-        LOGGER.debug("presence sensor handling state change %s", current_state)
-
-        if previous_state == current_state:
-            return
-
-        LOGGER.debug(
-            "%s: State change %s: %s -> %s",
-            self.auto_area.area_name,
-            entity_id,
-            previous_state,
-            current_state,
-        )
-
-        if current_state in PRESENCE_ON_STATES:
-            if not self.presence:
-                LOGGER.info("%s: Presence detected", self.auto_area.area_name)
-                self.presence = True
-                self.schedule_update_ha_state()
-        else:
-            if all_states_are_off(
-                self.hass,
-                self.entity_ids,
-                PRESENCE_ON_STATES,
-            ):
-                if self.presence:
-                    LOGGER.info(
-                        "%s: Presence cleared",
-                        self.auto_area.area_name
-                    )
-                    self.presence = False
-                    self.schedule_update_ha_state()