Обновить custom_components/motion_light/manifest.json

custom_components/motion_light/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "motion_light",
   "name": "Motion Light",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "documentation": "https://github.com/sirmrak/motion_light",
   "issue_tracker": "https://github.com/sirmrak/motion_light/issues",
   "dependencies": [],

custom_components/motion_light/number.py

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