homeassistant 2025.6.3__py3-none-any.whl → 2025.7.0b5__py3-none-any.whl

homeassistant/components/qbus/const.py

@@ -7,6 +7,7 @@ from homeassistant.const import Platform
 DOMAIN: Final = "qbus"
 PLATFORMS: list[Platform] = [
     Platform.CLIMATE,
+    Platform.COVER,
     Platform.LIGHT,
     Platform.SCENE,
     Platform.SWITCH,

homeassistant/components/qbus/cover.py

@@ -0,0 +1,193 @@
+"""Support for Qbus cover."""
+
+from typing import Any
+
+from qbusmqttapi.const import (
+    KEY_PROPERTIES_SHUTTER_POSITION,
+    KEY_PROPERTIES_SLAT_POSITION,
+)
+from qbusmqttapi.discovery import QbusMqttOutput
+from qbusmqttapi.state import QbusMqttShutterState, StateType
+
+from homeassistant.components.cover import (
+    ATTR_POSITION,
+    ATTR_TILT_POSITION,
+    CoverDeviceClass,
+    CoverEntity,
+    CoverEntityFeature,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from .coordinator import QbusConfigEntry
+from .entity import QbusEntity, add_new_outputs
+
+PARALLEL_UPDATES = 0
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: QbusConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up cover entities."""
+
+    coordinator = entry.runtime_data
+    added_outputs: list[QbusMqttOutput] = []
+
+    def _check_outputs() -> None:
+        add_new_outputs(
+            coordinator,
+            added_outputs,
+            lambda output: output.type == "shutter",
+            QbusCover,
+            async_add_entities,
+        )
+
+    _check_outputs()
+    entry.async_on_unload(coordinator.async_add_listener(_check_outputs))
+
+
+class QbusCover(QbusEntity, CoverEntity):
+    """Representation of a Qbus cover entity."""
+
+    _state_cls = QbusMqttShutterState
+
+    _attr_name = None
+    _attr_supported_features: CoverEntityFeature
+    _attr_device_class = CoverDeviceClass.BLIND
+
+    def __init__(self, mqtt_output: QbusMqttOutput) -> None:
+        """Initialize cover entity."""
+
+        super().__init__(mqtt_output)
+
+        self._attr_assumed_state = False
+        self._attr_current_cover_position = 0
+        self._attr_current_cover_tilt_position = 0
+        self._attr_is_closed = True
+
+        self._attr_supported_features = (
+            CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
+        )
+
+        if "shutterStop" in mqtt_output.actions:
+            self._attr_supported_features |= CoverEntityFeature.STOP
+            self._attr_assumed_state = True
+
+        if KEY_PROPERTIES_SHUTTER_POSITION in mqtt_output.properties:
+            self._attr_supported_features |= CoverEntityFeature.SET_POSITION
+
+        if KEY_PROPERTIES_SLAT_POSITION in mqtt_output.properties:
+            self._attr_supported_features |= CoverEntityFeature.SET_TILT_POSITION
+            self._attr_supported_features |= CoverEntityFeature.OPEN_TILT
+            self._attr_supported_features |= CoverEntityFeature.CLOSE_TILT
+
+        self._target_shutter_position: int | None = None
+        self._target_slat_position: int | None = None
+        self._target_state: str | None = None
+        self._previous_state: str | None = None
+
+    async def async_open_cover(self, **kwargs: Any) -> None:
+        """Open the cover."""
+
+        state = QbusMqttShutterState(id=self._mqtt_output.id, type=StateType.STATE)
+
+        if self._attr_supported_features & CoverEntityFeature.SET_POSITION:
+            state.write_position(100)
+        else:
+            state.write_state("up")
+
+        await self._async_publish_output_state(state)
+
+    async def async_close_cover(self, **kwargs: Any) -> None:
+        """Close the cover."""
+
+        state = QbusMqttShutterState(id=self._mqtt_output.id, type=StateType.STATE)
+
+        if self._attr_supported_features & CoverEntityFeature.SET_POSITION:
+            state.write_position(0)
+
+            if self._attr_supported_features & CoverEntityFeature.SET_TILT_POSITION:
+                state.write_slat_position(0)
+        else:
+            state.write_state("down")
+
+        await self._async_publish_output_state(state)
+
+    async def async_stop_cover(self, **kwargs: Any) -> None:
+        """Stop the cover."""
+        state = QbusMqttShutterState(id=self._mqtt_output.id, type=StateType.STATE)
+        state.write_state("stop")
+        await self._async_publish_output_state(state)
+
+    async def async_set_cover_position(self, **kwargs: Any) -> None:
+        """Move the cover to a specific position."""
+        state = QbusMqttShutterState(id=self._mqtt_output.id, type=StateType.STATE)
+        state.write_position(int(kwargs[ATTR_POSITION]))
+        await self._async_publish_output_state(state)
+
+    async def async_open_cover_tilt(self, **kwargs: Any) -> None:
+        """Open the cover tilt."""
+        state = QbusMqttShutterState(id=self._mqtt_output.id, type=StateType.STATE)
+        state.write_slat_position(50)
+        await self._async_publish_output_state(state)
+
+    async def async_close_cover_tilt(self, **kwargs: Any) -> None:
+        """Close the cover tilt."""
+        state = QbusMqttShutterState(id=self._mqtt_output.id, type=StateType.STATE)
+        state.write_slat_position(0)
+        await self._async_publish_output_state(state)
+
+    async def async_set_cover_tilt_position(self, **kwargs: Any) -> None:
+        """Move the cover tilt to a specific position."""
+        state = QbusMqttShutterState(id=self._mqtt_output.id, type=StateType.STATE)
+        state.write_slat_position(int(kwargs[ATTR_TILT_POSITION]))
+        await self._async_publish_output_state(state)
+
+    async def _handle_state_received(self, state: QbusMqttShutterState) -> None:
+        output_state = state.read_state()
+        shutter_position = state.read_position()
+        slat_position = state.read_slat_position()
+
+        if output_state is not None:
+            self._previous_state = self._target_state
+            self._target_state = output_state
+
+        if shutter_position is not None:
+            self._target_shutter_position = shutter_position
+
+        if slat_position is not None:
+            self._target_slat_position = slat_position
+
+        self._update_is_closed()
+        self._update_cover_position()
+        self._update_tilt_position()
+
+    def _update_is_closed(self) -> None:
+        if self._attr_supported_features & CoverEntityFeature.SET_POSITION:
+            if self._attr_supported_features & CoverEntityFeature.SET_TILT_POSITION:
+                self._attr_is_closed = (
+                    self._target_shutter_position == 0
+                    and self._target_slat_position in (0, 100)
+                )
+            else:
+                self._attr_is_closed = self._target_shutter_position == 0
+        else:
+            self._attr_is_closed = (
+                self._previous_state == "down" and self._target_state == "stop"
+            )
+
+    def _update_cover_position(self) -> None:
+        self._attr_current_cover_position = (
+            self._target_shutter_position
+            if self._attr_supported_features & CoverEntityFeature.SET_POSITION
+            else None
+        )
+
+    def _update_tilt_position(self) -> None:
+        self._attr_current_cover_tilt_position = (
+            self._target_slat_position
+            if self._attr_supported_features & CoverEntityFeature.SET_TILT_POSITION
+            else None
+        )

homeassistant/components/qbus/entity.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 import re
+from typing import Generic, TypeVar, cast
 
 from qbusmqttapi.discovery import QbusMqttOutput
 from qbusmqttapi.factory import QbusMqttMessageFactory, QbusMqttTopicFactory
@@ -20,6 +21,8 @@ from .coordinator import QbusControllerCoordinator
 
 _REFID_REGEX = re.compile(r"^\d+\/(\d+(?:\/\d+)?)$")
 
+StateT = TypeVar("StateT", bound=QbusMqttState)
+
 
 def add_new_outputs(
     coordinator: QbusControllerCoordinator,
@@ -59,9 +62,11 @@ def create_main_device_identifier(mqtt_output: QbusMqttOutput) -> tuple[str, str
     return (DOMAIN, format_mac(mqtt_output.device.mac))
 
 
-class QbusEntity(Entity, ABC):
+class QbusEntity(Entity, Generic[StateT], ABC):
     """Representation of a Qbus entity."""
 
+    _state_cls: type[StateT] = cast(type[StateT], QbusMqttState)
+
     _attr_has_entity_name = True
     _attr_should_poll = False
 
@@ -97,9 +102,16 @@ class QbusEntity(Entity, ABC):
             )
         )
 
-    @abstractmethod
     async def _state_received(self, msg: ReceiveMessage) -> None:
-        pass
+        state = self._message_factory.parse_output_state(self._state_cls, msg.payload)
+
+        if isinstance(state, self._state_cls):
+            await self._handle_state_received(state)
+            self.async_schedule_update_ha_state()
+
+    @abstractmethod
+    async def _handle_state_received(self, state: StateT) -> None:
+        raise NotImplementedError
 
     async def _async_publish_output_state(self, state: QbusMqttState) -> None:
         request = self._message_factory.create_set_output_state_request(

homeassistant/components/qbus/light.py

@@ -6,7 +6,6 @@ from qbusmqttapi.discovery import QbusMqttOutput
 from qbusmqttapi.state import QbusMqttAnalogState, StateType
 
 from homeassistant.components.light import ATTR_BRIGHTNESS, ColorMode, LightEntity
-from homeassistant.components.mqtt import ReceiveMessage
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.color import brightness_to_value, value_to_brightness
@@ -43,6 +42,8 @@ async def async_setup_entry(
 class QbusLight(QbusEntity, LightEntity):
     """Representation of a Qbus light entity."""
 
+    _state_cls = QbusMqttAnalogState
+
     _attr_name = None
     _attr_supported_color_modes = {ColorMode.BRIGHTNESS}
     _attr_color_mode = ColorMode.BRIGHTNESS
@@ -57,17 +58,11 @@ class QbusLight(QbusEntity, LightEntity):
     async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
         brightness = kwargs.get(ATTR_BRIGHTNESS)
-
-        percentage: int | None = None
-        on: bool | None = None
-
         state = QbusMqttAnalogState(id=self._mqtt_output.id)
 
         if brightness is None:
-            on = True
-
             state.type = StateType.ACTION
-            state.write_on_off(on)
+            state.write_on_off(on=True)
         else:
             percentage = round(brightness_to_value((1, 100), brightness))
 
@@ -83,16 +78,10 @@ class QbusLight(QbusEntity, LightEntity):
 
         await self._async_publish_output_state(state)
 
-    async def _state_received(self, msg: ReceiveMessage) -> None:
-        output = self._message_factory.parse_output_state(
-            QbusMqttAnalogState, msg.payload
-        )
-
-        if output is not None:
-            percentage = round(output.read_percentage())
-            self._set_state(percentage)
-            self.async_schedule_update_ha_state()
+    async def _handle_state_received(self, state: QbusMqttAnalogState) -> None:
+        percentage = round(state.read_percentage())
+        self._set_state(percentage)
 
-    def _set_state(self, percentage: int = 0) -> None:
+    def _set_state(self, percentage: int) -> None:
         self._attr_is_on = percentage > 0
         self._attr_brightness = value_to_brightness((1, 100), percentage)

homeassistant/components/qbus/scene.py

@@ -5,7 +5,6 @@ from typing import Any
 from qbusmqttapi.discovery import QbusMqttOutput
 from qbusmqttapi.state import QbusMqttState, StateAction, StateType
 
-from homeassistant.components.mqtt import ReceiveMessage
 from homeassistant.components.scene import Scene
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.device_registry import DeviceInfo
@@ -61,6 +60,6 @@ class QbusScene(QbusEntity, Scene):
         )
         await self._async_publish_output_state(state)
 
-    async def _state_received(self, msg: ReceiveMessage) -> None:
+    async def _handle_state_received(self, state: QbusMqttState) -> None:
         # Nothing to do
         pass

homeassistant/components/qbus/switch.py

@@ -5,7 +5,6 @@ from typing import Any
 from qbusmqttapi.discovery import QbusMqttOutput
 from qbusmqttapi.state import QbusMqttOnOffState, StateType
 
-from homeassistant.components.mqtt import ReceiveMessage
 from homeassistant.components.switch import SwitchDeviceClass, SwitchEntity
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
@@ -42,6 +41,8 @@ async def async_setup_entry(
 class QbusSwitch(QbusEntity, SwitchEntity):
     """Representation of a Qbus switch entity."""
 
+    _state_cls = QbusMqttOnOffState
+
     _attr_name = None
     _attr_device_class = SwitchDeviceClass.SWITCH
 
@@ -66,11 +67,5 @@ class QbusSwitch(QbusEntity, SwitchEntity):
 
         await self._async_publish_output_state(state)
 
-    async def _state_received(self, msg: ReceiveMessage) -> None:
-        output = self._message_factory.parse_output_state(
-            QbusMqttOnOffState, msg.payload
-        )
-
-        if output is not None:
-            self._attr_is_on = output.read_value()
-            self.async_schedule_update_ha_state()
+    async def _handle_state_received(self, state: QbusMqttOnOffState) -> None:
+        self._attr_is_on = state.read_value()

homeassistant/components/qbus/translations/el.json

@@ -14,5 +14,10 @@
                 "title": "\u03a0\u03c1\u03bf\u03c3\u03b8\u03ae\u03ba\u03b7 \u03b5\u03bb\u03b5\u03b3\u03ba\u03c4\u03ae"
             }
         }
+    },
+    "exceptions": {
+        "invalid_preset": {
+            "message": "\u0397 \u03c0\u03c1\u03bf\u03ba\u03b1\u03b8\u03bf\u03c1\u03b9\u03c3\u03bc\u03ad\u03bd\u03b7 \u03bb\u03b5\u03b9\u03c4\u03bf\u03c5\u03c1\u03b3\u03af\u03b1 \"{preset}\" \u03b4\u03b5\u03bd \u03b5\u03af\u03bd\u03b1\u03b9 \u03ad\u03b3\u03ba\u03c5\u03c1\u03b7. \u039f\u03b9 \u03ad\u03b3\u03ba\u03c5\u03c1\u03b5\u03c2 \u03c0\u03c1\u03bf\u03ba\u03b1\u03b8\u03bf\u03c1\u03b9\u03c3\u03bc\u03ad\u03bd\u03b5\u03c2 \u03bb\u03b5\u03b9\u03c4\u03bf\u03c5\u03c1\u03b3\u03af\u03b5\u03c2 \u03b5\u03af\u03bd\u03b1\u03b9: {options}."
+        }
     }
 }

homeassistant/components/qnap/translations/sv.json

@@ -74,7 +74,7 @@
                 "name": "Drifttid"
             },
             "volume_percentage_used": {
-                "name": "Anv\u00e4nd volym ({monitor_device})"
+                "name": "Volymanv\u00e4ndning ({monitor_device})"
             },
             "volume_size_free": {
                 "name": "Ledigt utrymme ({monitor_device})"

homeassistant/components/radarr/entity.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-from typing import cast
-
 from homeassistant.const import ATTR_SW_VERSION
 from homeassistant.helpers.device_registry import DeviceEntryType, DeviceInfo
 from homeassistant.helpers.entity import EntityDescription
@@ -40,7 +38,5 @@ class RadarrEntity(CoordinatorEntity[RadarrDataUpdateCoordinator[T]]):
             name=self.coordinator.config_entry.title,
         )
         if isinstance(self.coordinator, StatusDataUpdateCoordinator):
-            device_info[ATTR_SW_VERSION] = cast(
-                StatusDataUpdateCoordinator, self.coordinator
-            ).data.version
+            device_info[ATTR_SW_VERSION] = self.coordinator.data.version
         return device_info

homeassistant/components/random/translations/sv.json

@@ -11,8 +11,8 @@
             "sensor": {
                 "data": {
                     "device_class": "Enhetsklass",
-                    "maximum": "Maximum",
-                    "minimum": "Minimum",
+                    "maximum": "H\u00f6gst",
+                    "minimum": "L\u00e4gst",
                     "name": "Namn",
                     "unit_of_measurement": "M\u00e5ttenhet"
                 },
@@ -37,8 +37,8 @@
             "sensor": {
                 "data": {
                     "device_class": "Enhetsklass",
-                    "maximum": "Maximum",
-                    "minimum": "Minimum",
+                    "maximum": "H\u00f6gst",
+                    "minimum": "L\u00e4gst",
                     "unit_of_measurement": "M\u00e5ttenhet"
                 },
                 "title": "Slumpm\u00e4ssig sensor"

homeassistant/components/recorder/__init__.py

@@ -45,7 +45,7 @@ from .const import (  # noqa: F401
     SupportedDialect,
 )
 from .core import Recorder
-from .services import async_register_services
+from .services import async_setup_services
 from .tasks import AddRecorderPlatformTask
 from .util import get_instance
 
@@ -174,7 +174,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     instance.async_initialize()
     instance.async_register()
     instance.start()
-    async_register_services(hass, instance)
+    async_setup_services(hass)
     websocket_api.async_setup(hass)
 
     await _async_setup_integration_platform(hass, instance)

homeassistant/components/recorder/auto_repairs/schema.py

@@ -242,7 +242,7 @@ def correct_db_schema_utf8(
         f"{table_name}.4-byte UTF-8" in schema_errors
         or f"{table_name}.utf8mb4_unicode_ci" in schema_errors
     ):
-        from ..migration import (  # pylint: disable=import-outside-toplevel
+        from ..migration import (  # noqa: PLC0415
             _correct_table_character_set_and_collation,
         )
 
@@ -258,9 +258,7 @@ def correct_db_schema_precision(
     table_name = table_object.__tablename__
 
     if f"{table_name}.double precision" in schema_errors:
-        from ..migration import (  # pylint: disable=import-outside-toplevel
-            _modify_columns,
-        )
+        from ..migration import _modify_columns  # noqa: PLC0415
 
         precision_columns = _get_precision_column_types(table_object)
         # Attempt to convert timestamp columns to µs precision

homeassistant/components/recorder/history/__init__.py

@@ -45,7 +45,7 @@ def get_full_significant_states_with_session(
 ) -> dict[str, list[State]]:
     """Return a dict of significant states during a time period."""
     if not get_instance(hass).states_meta_manager.active:
-        from .legacy import (  # pylint: disable=import-outside-toplevel
+        from .legacy import (  # noqa: PLC0415
             get_full_significant_states_with_session as _legacy_get_full_significant_states_with_session,
         )
 
@@ -70,7 +70,7 @@ def get_last_state_changes(
 ) -> dict[str, list[State]]:
     """Return the last number_of_states."""
     if not get_instance(hass).states_meta_manager.active:
-        from .legacy import (  # pylint: disable=import-outside-toplevel
+        from .legacy import (  # noqa: PLC0415
             get_last_state_changes as _legacy_get_last_state_changes,
         )
 
@@ -94,7 +94,7 @@ def get_significant_states(
 ) -> dict[str, list[State | dict[str, Any]]]:
     """Return a dict of significant states during a time period."""
     if not get_instance(hass).states_meta_manager.active:
-        from .legacy import (  # pylint: disable=import-outside-toplevel
+        from .legacy import (  # noqa: PLC0415
             get_significant_states as _legacy_get_significant_states,
         )
 
@@ -130,7 +130,7 @@ def get_significant_states_with_session(
 ) -> dict[str, list[State | dict[str, Any]]]:
     """Return a dict of significant states during a time period."""
     if not get_instance(hass).states_meta_manager.active:
-        from .legacy import (  # pylint: disable=import-outside-toplevel
+        from .legacy import (  # noqa: PLC0415
             get_significant_states_with_session as _legacy_get_significant_states_with_session,
         )
 
@@ -164,7 +164,7 @@ def state_changes_during_period(
 ) -> dict[str, list[State]]:
     """Return a list of states that changed during a time period."""
     if not get_instance(hass).states_meta_manager.active:
-        from .legacy import (  # pylint: disable=import-outside-toplevel
+        from .legacy import (  # noqa: PLC0415
             state_changes_during_period as _legacy_state_changes_during_period,
         )
 

homeassistant/components/recorder/manifest.json

@@ -7,7 +7,7 @@
   "iot_class": "local_push",
   "quality_scale": "internal",
   "requirements": [
-    "SQLAlchemy==2.0.40",
+    "SQLAlchemy==2.0.41",
     "fnv-hash-fast==1.5.0",
     "psutil-home-assistant==0.0.1"
   ]

homeassistant/components/recorder/pool.py

@@ -90,7 +90,7 @@ class RecorderPool(SingletonThreadPool, NullPool):
         if threading.get_ident() in self.recorder_and_worker_thread_ids:
             super().dispose()
 
-    def _do_get(self) -> ConnectionPoolEntry:  # type: ignore[return]
+    def _do_get(self) -> ConnectionPoolEntry:  # type: ignore[return]  # noqa: RET503
         if threading.get_ident() in self.recorder_and_worker_thread_ids:
             return super()._do_get()
         try:
@@ -100,7 +100,7 @@ class RecorderPool(SingletonThreadPool, NullPool):
             # which is allowed but discouraged since its much slower
             return self._do_get_db_connection_protected()
         # In the event loop, raise an exception
-        raise_for_blocking_call(  # noqa: RET503
+        raise_for_blocking_call(
             self._do_get_db_connection_protected,
             strict=True,
             advise_msg=ADVISE_MSG,