Не создаем сущности lux при отсутствии датчика освещенности

This commit is contained in:
2026-07-08 14:26:08 +03:00
parent e77fdc00f9
commit 55488681b2
+171 -164
View File
@@ -1,165 +1,172 @@
"""Number platform for Motion Light settings.""" """Number platform for Motion Light settings."""
import logging import logging
from homeassistant.components.number import NumberEntity from homeassistant.components.number import NumberEntity
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import UnitOfTime from homeassistant.const import UnitOfTime
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.helpers.update_coordinator import CoordinatorEntity from homeassistant.helpers.update_coordinator import CoordinatorEntity
from homeassistant.helpers.restore_state import RestoreEntity from homeassistant.helpers.restore_state import RestoreEntity
from homeassistant.helpers.device_registry import DeviceInfo from homeassistant.helpers.device_registry import DeviceInfo
from .const import ( from .const import (
DOMAIN, DOMAIN,
ENTITY_MOTION_FILTER, ENTITY_MOTION_FILTER,
ENTITY_OFF_DELAY, ENTITY_OFF_DELAY,
ENTITY_LUX_THRESHOLD, ENTITY_LUX_THRESHOLD,
ENTITY_LUX_COOLDOWN, ENTITY_LUX_COOLDOWN,
ENTITY_MANUAL_IDLE_TIMEOUT, ENTITY_MANUAL_IDLE_TIMEOUT,
ENTITY_MANUAL_OFF_COOLDOWN, ENTITY_MANUAL_OFF_COOLDOWN,
DEFAULT_MOTION_FILTER, DEFAULT_MOTION_FILTER,
DEFAULT_OFF_DELAY, DEFAULT_OFF_DELAY,
DEFAULT_LUX_THRESHOLD, DEFAULT_LUX_THRESHOLD,
DEFAULT_LUX_COOLDOWN, DEFAULT_LUX_COOLDOWN,
DEFAULT_MANUAL_IDLE_TIMEOUT, DEFAULT_MANUAL_IDLE_TIMEOUT,
DEFAULT_MANUAL_OFF_COOLDOWN, DEFAULT_MANUAL_OFF_COOLDOWN,
) )
_LOGGER = logging.getLogger(__name__) _LOGGER = logging.getLogger(__name__)
class PrefixLoggerAdapter(logging.LoggerAdapter): class PrefixLoggerAdapter(logging.LoggerAdapter):
"""Logger adapter that adds a prefix to log messages.""" """Logger adapter that adds a prefix to log messages."""
def process(self, msg, kwargs): def process(self, msg, kwargs):
"""Add prefix to the log message.""" """Add prefix to the log message."""
return f"[{self.extra.get('name', 'Unknown')}] {msg}", kwargs return f"[{self.extra.get('name', 'Unknown')}] {msg}", kwargs
TRANSLATION_KEYS = { TRANSLATION_KEYS = {
ENTITY_MOTION_FILTER: "motion_light_motion_filter", ENTITY_MOTION_FILTER: "motion_light_motion_filter",
ENTITY_OFF_DELAY: "motion_light_off_delay", ENTITY_OFF_DELAY: "motion_light_off_delay",
ENTITY_LUX_THRESHOLD: "motion_light_lux_threshold", ENTITY_LUX_THRESHOLD: "motion_light_lux_threshold",
ENTITY_LUX_COOLDOWN: "motion_light_lux_cooldown", ENTITY_LUX_COOLDOWN: "motion_light_lux_cooldown",
ENTITY_MANUAL_IDLE_TIMEOUT: "motion_light_manual_idle_timeout", ENTITY_MANUAL_IDLE_TIMEOUT: "motion_light_manual_idle_timeout",
ENTITY_MANUAL_OFF_COOLDOWN: "motion_light_manual_off_cooldown", ENTITY_MANUAL_OFF_COOLDOWN: "motion_light_manual_off_cooldown",
} }
ICONS = { ICONS = {
ENTITY_MOTION_FILTER: "mdi:timer-outline", ENTITY_MOTION_FILTER: "mdi:timer-outline",
ENTITY_OFF_DELAY: "mdi:timer-sand", ENTITY_OFF_DELAY: "mdi:timer-sand",
ENTITY_LUX_THRESHOLD: "mdi:brightness-5", ENTITY_LUX_THRESHOLD: "mdi:brightness-5",
ENTITY_LUX_COOLDOWN: "mdi:timer-pause", ENTITY_LUX_COOLDOWN: "mdi:timer-pause",
ENTITY_MANUAL_IDLE_TIMEOUT: "mdi:timer-alert", ENTITY_MANUAL_IDLE_TIMEOUT: "mdi:timer-alert",
ENTITY_MANUAL_OFF_COOLDOWN: "mdi:timer-off", ENTITY_MANUAL_OFF_COOLDOWN: "mdi:timer-off",
} }
UNITS = { UNITS = {
ENTITY_MOTION_FILTER: UnitOfTime.SECONDS, ENTITY_MOTION_FILTER: UnitOfTime.SECONDS,
ENTITY_OFF_DELAY: UnitOfTime.SECONDS, ENTITY_OFF_DELAY: UnitOfTime.SECONDS,
ENTITY_LUX_THRESHOLD: "lx", ENTITY_LUX_THRESHOLD: "lx",
ENTITY_LUX_COOLDOWN: UnitOfTime.SECONDS, ENTITY_LUX_COOLDOWN: UnitOfTime.SECONDS,
ENTITY_MANUAL_IDLE_TIMEOUT: UnitOfTime.SECONDS, ENTITY_MANUAL_IDLE_TIMEOUT: UnitOfTime.SECONDS,
ENTITY_MANUAL_OFF_COOLDOWN: UnitOfTime.SECONDS, ENTITY_MANUAL_OFF_COOLDOWN: UnitOfTime.SECONDS,
} }
async def async_setup_entry( async def async_setup_entry(
hass: HomeAssistant, hass: HomeAssistant,
entry: ConfigEntry, entry: ConfigEntry,
async_add_entities: AddEntitiesCallback, async_add_entities: AddEntitiesCallback,
) -> None: ) -> None:
"""Set up Motion Light number entities.""" """Set up Motion Light number entities."""
coordinator = hass.data[DOMAIN][entry.entry_id] coordinator = hass.data[DOMAIN][entry.entry_id]
entities = [
MotionLightNumber(coordinator, entry, ENTITY_MOTION_FILTER, 0, 10, 1, DEFAULT_MOTION_FILTER), lux_sensor = entry.options.get(CONF_LUX_SENSOR) or entry.data.get(CONF_LUX_SENSOR)
MotionLightNumber(coordinator, entry, ENTITY_OFF_DELAY, 0, 600, 5, DEFAULT_OFF_DELAY),
MotionLightNumber(coordinator, entry, ENTITY_LUX_THRESHOLD, 1, 1000, 10, DEFAULT_LUX_THRESHOLD), entities = [
MotionLightNumber(coordinator, entry, ENTITY_LUX_COOLDOWN, 0, 300, 5, DEFAULT_LUX_COOLDOWN), MotionLightNumber(coordinator, entry, ENTITY_MOTION_FILTER, 0, 10, 1, DEFAULT_MOTION_FILTER),
MotionLightNumber(coordinator, entry, ENTITY_MANUAL_IDLE_TIMEOUT, 0, 3600, 60, DEFAULT_MANUAL_IDLE_TIMEOUT), MotionLightNumber(coordinator, entry, ENTITY_OFF_DELAY, 0, 600, 5, DEFAULT_OFF_DELAY),
MotionLightNumber(coordinator, entry, ENTITY_MANUAL_OFF_COOLDOWN, 0, 300, 5, DEFAULT_MANUAL_OFF_COOLDOWN), MotionLightNumber(coordinator, entry, ENTITY_MANUAL_IDLE_TIMEOUT, 0, 3600, 30, DEFAULT_MANUAL_IDLE_TIMEOUT),
] MotionLightNumber(coordinator, entry, ENTITY_MANUAL_OFF_COOLDOWN, 0, 300, 5, DEFAULT_MANUAL_OFF_COOLDOWN),
async_add_entities(entities) ]
if lux_sensor:
class MotionLightNumber(CoordinatorEntity, NumberEntity, RestoreEntity): entities.extend([
"""Representation of a Motion Light setting as a number entity.""" MotionLightNumber(coordinator, entry, ENTITY_LUX_THRESHOLD, 1, 1000, 10, DEFAULT_LUX_THRESHOLD),
_attr_has_entity_name = True MotionLightNumber(coordinator, entry, ENTITY_LUX_COOLDOWN, 0, 300, 5, DEFAULT_LUX_COOLDOWN),
])
def __init__(self, coordinator, entry, entity_id, min_val, max_val, step, default):
"""Initialize the number entity.""" async_add_entities(entities)
super().__init__(coordinator)
self.entry = entry class MotionLightNumber(CoordinatorEntity, NumberEntity, RestoreEntity):
"""Representation of a Motion Light setting as a number entity."""
self.logger = PrefixLoggerAdapter(_LOGGER, {"name": entry.title}) _attr_has_entity_name = True
self._entity_suffix = entity_id def __init__(self, coordinator, entry, entity_id, min_val, max_val, step, default):
self._attr_unique_id = f"{entry.entry_id}_{entity_id}" """Initialize the number entity."""
self._attr_translation_key = TRANSLATION_KEYS[entity_id] super().__init__(coordinator)
self._attr_native_min_value = min_val self.entry = entry
self._attr_native_max_value = max_val
self._attr_native_step = step self.logger = PrefixLoggerAdapter(_LOGGER, {"name": entry.title})
self._attr_native_unit_of_measurement = UNITS[entity_id]
self._attr_icon = ICONS[entity_id] self._entity_suffix = entity_id
self._default_value = default self._attr_unique_id = f"{entry.entry_id}_{entity_id}"
self._attr_native_value = default self._attr_translation_key = TRANSLATION_KEYS[entity_id]
self._attr_device_info = DeviceInfo( self._attr_native_min_value = min_val
identifiers={(DOMAIN, entry.entry_id)}, self._attr_native_max_value = max_val
name=entry.title, self._attr_native_step = step
manufacturer="Motion Light", self._attr_native_unit_of_measurement = UNITS[entity_id]
model="Switch Control Integration", self._attr_icon = ICONS[entity_id]
) self._default_value = default
self._attr_native_value = default
@property self._attr_device_info = DeviceInfo(
def native_value(self) -> float: identifiers={(DOMAIN, entry.entry_id)},
"""Return the current value.""" name=entry.title,
return self._attr_native_value manufacturer="Motion Light",
model="Switch Control Integration",
async def async_set_native_value(self, value: float) -> None: )
"""Update the current value."""
self._attr_native_value = value @property
self.logger.info("Setting %s to %s", self._entity_suffix, value) def native_value(self) -> float:
"""Return the current value."""
if self._entity_suffix == ENTITY_MOTION_FILTER: return self._attr_native_value
self.coordinator.set_motion_filter(value)
elif self._entity_suffix == ENTITY_OFF_DELAY: async def async_set_native_value(self, value: float) -> None:
self.coordinator.set_off_delay(value) """Update the current value."""
elif self._entity_suffix == ENTITY_LUX_THRESHOLD: self._attr_native_value = value
self.coordinator.set_lux_threshold(value) self.logger.info("Setting %s to %s", self._entity_suffix, value)
elif self._entity_suffix == ENTITY_LUX_COOLDOWN:
self.coordinator.set_lux_cooldown(value) if self._entity_suffix == ENTITY_MOTION_FILTER:
elif self._entity_suffix == ENTITY_MANUAL_IDLE_TIMEOUT: self.coordinator.set_motion_filter(value)
self.coordinator.set_manual_idle_timeout(value) elif self._entity_suffix == ENTITY_OFF_DELAY:
elif self._entity_suffix == ENTITY_MANUAL_OFF_COOLDOWN: self.coordinator.set_off_delay(value)
self.coordinator.set_manual_off_cooldown(value) elif self._entity_suffix == ENTITY_LUX_THRESHOLD:
self.coordinator.set_lux_threshold(value)
self.async_write_ha_state() elif self._entity_suffix == ENTITY_LUX_COOLDOWN:
self.coordinator.set_lux_cooldown(value)
async def async_added_to_hass(self) -> None: elif self._entity_suffix == ENTITY_MANUAL_IDLE_TIMEOUT:
"""Handle entity which will be added.""" self.coordinator.set_manual_idle_timeout(value)
await super().async_added_to_hass() elif self._entity_suffix == ENTITY_MANUAL_OFF_COOLDOWN:
last_state = await self.async_get_last_state() self.coordinator.set_manual_off_cooldown(value)
if last_state is not None:
try: self.async_write_ha_state()
value = float(last_state.state)
self._attr_native_value = value async def async_added_to_hass(self) -> None:
self.logger.info("Restored %s: %s", self._entity_suffix, value) """Handle entity which will be added."""
await super().async_added_to_hass()
if self._entity_suffix == ENTITY_MOTION_FILTER: last_state = await self.async_get_last_state()
self.coordinator.set_motion_filter(value) if last_state is not None:
elif self._entity_suffix == ENTITY_OFF_DELAY: try:
self.coordinator.set_off_delay(value) value = float(last_state.state)
elif self._entity_suffix == ENTITY_LUX_THRESHOLD: self._attr_native_value = value
self.coordinator.set_lux_threshold(value) self.logger.info("Restored %s: %s", self._entity_suffix, value)
elif self._entity_suffix == ENTITY_LUX_COOLDOWN:
self.coordinator.set_lux_cooldown(value) if self._entity_suffix == ENTITY_MOTION_FILTER:
elif self._entity_suffix == ENTITY_MANUAL_IDLE_TIMEOUT: self.coordinator.set_motion_filter(value)
self.coordinator.set_manual_idle_timeout(value) elif self._entity_suffix == ENTITY_OFF_DELAY:
elif self._entity_suffix == ENTITY_MANUAL_OFF_COOLDOWN: self.coordinator.set_off_delay(value)
self.coordinator.set_manual_off_cooldown(value) elif self._entity_suffix == ENTITY_LUX_THRESHOLD:
except (ValueError, TypeError): self.coordinator.set_lux_threshold(value)
self.logger.warning("Could not restore %s, using default", self._entity_suffix) elif self._entity_suffix == ENTITY_LUX_COOLDOWN:
self.async_write_ha_state() self.coordinator.set_lux_cooldown(value)
elif self._entity_suffix == ENTITY_MANUAL_IDLE_TIMEOUT:
def _handle_coordinator_update(self) -> None: self.coordinator.set_manual_idle_timeout(value)
"""Handle updated data from the coordinator.""" elif self._entity_suffix == ENTITY_MANUAL_OFF_COOLDOWN:
self.coordinator.set_manual_off_cooldown(value)
except (ValueError, TypeError):
self.logger.warning("Could not restore %s, using default", self._entity_suffix)
self.async_write_ha_state()
def _handle_coordinator_update(self) -> None:
"""Handle updated data from the coordinator."""
self.async_write_ha_state() self.async_write_ha_state()