0.7.0

Author: Aohzan

CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 0.7.0
+
+- Fix default conf missing
+- Lint and code improvments
+- Bump pyserial-asyncio
+- Add service translation
+- Handle no USB device found during init
+
 ## 0.6.1
 
 - Fix incapacity to create switch entity when automatic entity add is disabled at bootstrap

custom_components/rfplayer/__init__.py

@@ -1,14 +1,13 @@
 """Support for Rfplayer devices."""
-import asyncio
+from asyncio import timeout
 from collections import defaultdict
 import copy
 import logging
 
-import async_timeout
 from serial import SerialException
-from homeassistant.util import slugify
 import voluptuous as vol
 
+from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
     ATTR_ENTITY_ID,
     ATTR_STATE,
@@ -19,14 +18,14 @@
     CONF_PROTOCOL,
     EVENT_HOMEASSISTANT_STOP,
 )
-from homeassistant.core import CoreState, callback
+from homeassistant.core import CoreState, HomeAssistant, callback
+from homeassistant.helpers import device_registry as dr
 import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import (
     async_dispatcher_connect,
     async_dispatcher_send,
 )
-from homeassistant.helpers import device_registry as dr
-from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.restore_state import RestoreEntity
 
 from .const import (
@@ -76,17 +75,19 @@ def identify_event_type(event):
     return "unknown"
 
 
-async def async_setup_entry(hass, entry):
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up GCE RFPlayer from a config entry."""
+    hass.data.setdefault(DOMAIN, {})
+
     config = entry.data
     options = entry.options
 
     async def async_send_command(call):
         """Send Rfplayer command."""
         _LOGGER.debug("Rfplayer send command for %s", str(call.data))
         if not await hass.data[DOMAIN][RFPLAYER_PROTOCOL].send_command_ack(
-            protocol=call.data[CONF_PROTOCOL],
-            command=call.data[CONF_COMMAND],
+            call.data[CONF_PROTOCOL],
+            call.data[CONF_COMMAND],
             device_address=call.data.get(CONF_DEVICE_ADDRESS),
             device_id=call.data.get(CONF_DEVICE_ID),
         ):
@@ -138,17 +139,15 @@ def event_callback(event):
             # Propagate event to every entity matching the device id
             _LOGGER.debug("passing event to %s", entity_id)
             async_dispatcher_send(hass, SIGNAL_HANDLE_EVENT.format(entity_id), event)
+        elif event_type in hass.data[DOMAIN][DATA_DEVICE_REGISTER]:
+            _LOGGER.debug("device_id not known, adding new device")
+            hass.data[DOMAIN][DATA_ENTITY_LOOKUP][event_type][event_id] = event
+            _add_device_to_base_config(event, event_id)
+            hass.async_create_task(
+                hass.data[DOMAIN][DATA_DEVICE_REGISTER][event_type](event)
+            )
         else:
-            # If device is not yet known, register with platform (if loaded)
-            if event_type in hass.data[DOMAIN][DATA_DEVICE_REGISTER]:
-                _LOGGER.debug("device_id not known, adding new device")
-                hass.data[DOMAIN][DATA_ENTITY_LOOKUP][event_type][event_id] = event
-                _add_device_to_base_config(event, event_id)
-                hass.async_create_task(
-                    hass.data[DOMAIN][DATA_DEVICE_REGISTER][event_type](event)
-                )
-            else:
-                _LOGGER.debug("device_id not known and automatic add disabled")
+            _LOGGER.debug("device_id not known and automatic add disabled")
 
     @callback
     def _add_device_to_base_config(event, event_id):
@@ -182,14 +181,10 @@ async def connect():
         )
 
         try:
-            with async_timeout.timeout(CONNECTION_TIMEOUT):
+            with timeout(CONNECTION_TIMEOUT):
                 transport, protocol = await connection
 
-        except (
-            SerialException,
-            OSError,
-            asyncio.TimeoutError,
-        ) as exc:
+        except (TimeoutError, SerialException, OSError) as exc:
             reconnect_interval = config[CONF_RECONNECT_INTERVAL]
             _LOGGER.exception(
                 "Error connecting to Rfplayer, reconnecting in %s", reconnect_interval
@@ -240,8 +235,6 @@ class RfplayerDevice(RestoreEntity):
     Contains the common logic for Rfplayer entities.
     """
 
-    platform = None
-    _state = None
     _available = True
 
     def __init__(
@@ -251,22 +244,22 @@ def __init__(
         device_id=None,
         initial_event=None,
         name=None,
-    ):
+    ) -> None:
         """Initialize the device."""
         # Rflink specific attributes for every component type
         self._initial_event = initial_event
         self._protocol = protocol
         self._device_id = device_id
         self._device_address = device_address
         self._event = None
-        self._state: bool = None
         self._attr_assumed_state = True
-        if name is not None:
+        self._attr_unique_id = "_".join(
+            [self._protocol, self._device_address or self._device_id]
+        )
+        if name:
             self._attr_name = name
-            self._attr_unique_id = slugify(f"{protocol}_{name}")
         else:
-            self._attr_name = f"{protocol} {device_id or device_address}"
-            self._attr_unique_id = slugify(f"{protocol}_{device_id or device_address}")
+            self._attr_name = f"{protocol} {device_address or device_id}"
 
     async def _async_send_command(self, command, *args):
         rfplayer = self.hass.data[DOMAIN][RFPLAYER_PROTOCOL]
@@ -298,7 +291,7 @@ def handle_event_callback(self, event):
 
     def _handle_event(self, event):
         """Platform specific event handler."""
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @property
     def should_poll(self):

custom_components/rfplayer/config_flow.py

@@ -1,12 +1,21 @@
 """Config flow to configure the rfplayer integration."""
 import os
+from typing import Any
 
 import serial
 import voluptuous as vol
 
-from homeassistant import config_entries, exceptions
+from homeassistant import exceptions
+from homeassistant.config_entries import (
+    HANDLERS,
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlow,
+)
 from homeassistant.const import CONF_DEVICE, CONF_DEVICES
 from homeassistant.core import callback
+from homeassistant.data_entry_flow import AbortFlow
 
 from .const import (
     CONF_AUTOMATIC_ADD,
@@ -16,15 +25,17 @@
 )
 
 
-@config_entries.HANDLERS.register(DOMAIN)
-class RfplayerConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+@HANDLERS.register(DOMAIN)
+class RfplayerConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle a rfplayer config flow."""
 
     VERSION = 1
 
-    async def async_step_user(self, user_input=None):
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
         """Config flow started from UI."""
-        errors = {}
+        schema_errors: dict[str, Any] = {}
 
         if user_input is not None:
             user_input[CONF_DEVICES] = {}
@@ -33,20 +44,22 @@ async def async_step_user(self, user_input=None):
                 get_serial_by_id, user_input[CONF_DEVICE]
             )
 
-            if not errors:
+            if not schema_errors:
                 return self.async_create_entry(
                     title=user_input[CONF_DEVICE], data=user_input
                 )
 
         ports = await self.hass.async_add_executor_job(serial.tools.list_ports.comports)
         list_of_ports = {}
         for port in ports:
-            list_of_ports[
-                port.device
-            ] = f"{port}, s/n: {port.serial_number or 'n/a'}" + (
-                f" - {port.manufacturer}" if port.manufacturer else ""
+            list_of_ports[port.device] = (
+                f"{port}, s/n: {port.serial_number or 'n/a'}"
+                + (f" - {port.manufacturer}" if port.manufacturer else "")
             )
 
+        if not list_of_ports:
+            raise AbortFlow("no_devices_found")
+
         data = {
             vol.Required(CONF_DEVICE): vol.In(list_of_ports),
             vol.Required(CONF_AUTOMATIC_ADD, default=True): bool,
@@ -57,24 +70,26 @@ async def async_step_user(self, user_input=None):
         return self.async_show_form(
             step_id="user",
             data_schema=vol.Schema(data),
-            errors=errors,
+            errors=schema_errors,
         )
 
     @staticmethod
     @callback
-    def async_get_options_flow(config_entry):
+    def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
         """Define the config flow to handle options."""
         return RfPlayerOptionsFlowHandler(config_entry)
 
 
-class RfPlayerOptionsFlowHandler(config_entries.OptionsFlow):
+class RfPlayerOptionsFlowHandler(OptionsFlow):
     """Handle a RFPLayer options flow."""
 
-    def __init__(self, config_entry):
+    def __init__(self, config_entry: ConfigEntry) -> None:
         """Initialize."""
         self.config_entry = config_entry
 
-    async def async_step_init(self, user_input: dict = None):
+    async def async_step_init(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
         """Manage the options."""
         if user_input is None:
             config = self.config_entry.data

custom_components/rfplayer/const.py

@@ -8,7 +8,7 @@
 DEFAULT_RECONNECT_INTERVAL = 10
 DEFAULT_SIGNAL_REPETITIONS = 1
 
-PLATFORMS = ["sensor", "switch", "number"]
+PLATFORMS = ["number", "sensor", "switch"]
 
 ATTR_EVENT = "event"
 

custom_components/rfplayer/icons.json

@@ -0,0 +1,5 @@
+{
+  "services": {
+    "send_command": "mdi:remote"
+  }
+}

custom_components/rfplayer/manifest.json

@@ -7,6 +7,6 @@
   "documentation": "https://github.com/gce-electronics/HA_RFPlayer",
   "iot_class": "assumed_state",
   "issue_tracker": "https://github.com/gce-electronics/HA_RFPlayer/issues",
-  "requirements": ["pyserial==3.5", "pyserial-asyncio==0.5"],
-  "version": "0.6.1"
+  "requirements": ["pyserial==3.5", "pyserial-asyncio==0.6"],
+  "version": "0.7.0"
 }

custom_components/rfplayer/number.py

@@ -1,53 +1,61 @@
 """Support for Rfplayer number."""
 import logging
 
-from homeassistant.components.number import NumberEntity
-from homeassistant.core import callback
-from homeassistant.helpers.entity import EntityCategory
+from homeassistant.components.number import NumberMode, RestoreNumber
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
-from . import RfplayerDevice
-from .const import DOMAIN, RFPLAYER_PROTOCOL
+from . import EVENT_KEY_COMMAND, RfplayerDevice
+from .const import DATA_ENTITY_LOOKUP, DOMAIN, EVENT_KEY_ID, RFPLAYER_PROTOCOL
 
 _LOGGER = logging.getLogger(__name__)
 
 
-async def async_setup_entry(hass, entry, async_add_entities):
+async def async_setup_entry(
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
+) -> None:
     """Set up the Rfplayer platform."""
     _LOGGER.debug("Add jamming number entity")
     async_add_entities([RfplayerJammingNumber()])
 
 
-class RfplayerJammingNumber(RfplayerDevice, NumberEntity):
+class RfplayerJammingNumber(RfplayerDevice, RestoreNumber):
     """Representation of a Rfplayer jamming number setting entity."""
 
-    def __init__(self):
+    _attr_native_min_value = 0
+    _attr_native_max_value = 10
+    _attr_mode = NumberMode.SLIDER
+
+    def __init__(self) -> None:
         """Init the number rfplayer entity."""
-        self._attr_native_min_value = 0
-        self._attr_native_max_value = 10
-        self._attr_native_mode = "slider"
-        self._attr_native_entity_category = EntityCategory.CONFIG
-        super().__init__("JAMMING", device_id=0, name="Jamming detection level")
+        self._state: int | None = None
+        super().__init__("JAMMING")
 
-    async def async_added_to_hass(self):
+    async def async_added_to_hass(self) -> None:
         """Restore RFPlayer device state."""
         await super().async_added_to_hass()
+
+        self.hass.data[DOMAIN][DATA_ENTITY_LOOKUP][EVENT_KEY_COMMAND][
+            self._initial_event[EVENT_KEY_ID]
+        ] = self.entity_id
+
         if self._event is None:
             old_state = await self.async_get_last_state()
             if old_state is not None:
-                self._state = old_state.state
+                self._state = int(old_state.state)
 
     @callback
     def _handle_event(self, event):
-        self._state = int(event["value"])
+        self._state = int(event["command"])
 
     @property
-    def native_value(self):
+    def value(self):
         """Return the current setting."""
         return self._state
 
-    async def async_set_native_value(self, value) -> None:
+    async def async_set_native_value(self, value: float) -> None:
         """Update the current value."""
         rfplayer = self.hass.data[DOMAIN][RFPLAYER_PROTOCOL]
         await rfplayer.send_command_ack(command=int(value), protocol=self._protocol)
-        self._state = value
-        self.async_write_ha_state()
+        self._state = int(value)

custom_components/rfplayer/rflib/__init__.py

@@ -1 +1 @@
-# noqa
+"""rflib."""

custom_components/rfplayer/rflib/exception.py

@@ -0,0 +1,5 @@
+"""RfPlayer exceptions."""
+
+
+class RfPlayerException(Exception):
+    """Generic RfPlayer exception."""