Migrate onewire to async library (home-assistant#154439)

Author: epenet

homeassistant/components/onewire/__init__.py

@@ -2,7 +2,7 @@
 
 import logging
 
-from pyownet import protocol
+from aio_ownet.exceptions import OWServerConnectionError, OWServerReturnError
 
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
@@ -28,8 +28,8 @@ async def async_setup_entry(hass: HomeAssistant, entry: OneWireConfigEntry) -> b
     try:
         await onewire_hub.initialize()
     except (
-        protocol.ConnError,  # Failed to connect to the server
-        protocol.OwnetError,  # Connected to server, but failed to list the devices
+        OWServerConnectionError,  # Failed to connect to the server
+        OWServerReturnError,  # Connected to server, but failed to list the devices
     ) as exc:
         raise ConfigEntryNotReady from exc
 

homeassistant/components/onewire/config_flow.py

@@ -5,7 +5,8 @@
 from copy import deepcopy
 from typing import Any
 
-from pyownet import protocol
+from aio_ownet.exceptions import OWServerConnectionError
+from aio_ownet.proxy import OWServerStatelessProxy
 import voluptuous as vol
 
 from homeassistant.config_entries import (
@@ -45,11 +46,10 @@ async def validate_input(
     hass: HomeAssistant, data: dict[str, Any], errors: dict[str, str]
 ) -> None:
     """Validate the user input allows us to connect."""
+    proxy = OWServerStatelessProxy(data[CONF_HOST], data[CONF_PORT])
     try:
-        await hass.async_add_executor_job(
-            protocol.proxy, data[CONF_HOST], data[CONF_PORT]
-        )
-    except protocol.ConnError:
+        await proxy.validate()
+    except OWServerConnectionError:
         errors["base"] = "cannot_connect"
 
 

homeassistant/components/onewire/entity.py

@@ -6,7 +6,8 @@
 import logging
 from typing import Any
 
-from pyownet import protocol
+from aio_ownet.exceptions import OWServerError
+from aio_ownet.proxy import OWServerStatelessProxy
 
 from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.entity import Entity, EntityDescription
@@ -36,7 +37,7 @@ def __init__(
         device_id: str,
         device_info: DeviceInfo,
         device_file: str,
-        owproxy: protocol._Proxy,
+        owproxy: OWServerStatelessProxy,
     ) -> None:
         """Initialize the entity."""
         self.entity_description = description
@@ -55,20 +56,19 @@ def extra_state_attributes(self) -> dict[str, Any] | None:
             "device_file": self._device_file,
         }
 
-    def _read_value(self) -> str:
+    async def _read_value(self) -> str:
         """Read a value from the server."""
-        read_bytes: bytes = self._owproxy.read(self._device_file)
-        return read_bytes.decode().lstrip()
+        return (await self._owproxy.read(self._device_file)).decode().lstrip()
 
-    def _write_value(self, value: bytes) -> None:
+    async def _write_value(self, value: bytes) -> None:
         """Write a value to the server."""
-        self._owproxy.write(self._device_file, value)
+        await self._owproxy.write(self._device_file, value)
 
-    def update(self) -> None:
+    async def async_update(self) -> None:
         """Get the latest data from the device."""
         try:
-            self._value_raw = float(self._read_value())
-        except protocol.Error as exc:
+            self._value_raw = float(await self._read_value())
+        except OWServerError as exc:
             if self._last_update_success:
                 _LOGGER.error("Error fetching %s data: %s", self.name, exc)
                 self._last_update_success = False

homeassistant/components/onewire/manifest.json

@@ -6,7 +6,7 @@
   "documentation": "https://www.home-assistant.io/integrations/onewire",
   "integration_type": "hub",
   "iot_class": "local_polling",
-  "loggers": ["pyownet"],
-  "requirements": ["pyownet==0.10.0.post1"],
+  "loggers": ["aio_ownet"],
+  "requirements": ["aio-ownet==0.0.3"],
   "zeroconf": ["_owserver._tcp.local."]
 }

homeassistant/components/onewire/onewirehub.py

@@ -7,7 +7,9 @@
 import logging
 import os
 
-from pyownet import protocol
+from aio_ownet.definitions import OWServerCommonPath
+from aio_ownet.exceptions import OWServerProtocolError, OWServerReturnError
+from aio_ownet.proxy import OWServerStatelessProxy
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import ATTR_VIA_DEVICE, CONF_HOST, CONF_PORT
@@ -57,7 +59,7 @@ def _is_known_device(device_family: str, device_type: str | None) -> bool:
 class OneWireHub:
     """Hub to communicate with server."""
 
-    owproxy: protocol._Proxy
+    owproxy: OWServerStatelessProxy
     devices: list[OWDeviceDescription]
     _version: str | None = None
 
@@ -66,23 +68,25 @@ def __init__(self, hass: HomeAssistant, config_entry: OneWireConfigEntry) -> Non
         self._hass = hass
         self._config_entry = config_entry
 
-    def _initialize(self) -> None:
-        """Connect to the server, and discover connected devices.
-
-        Needs to be run in executor.
-        """
+    async def _initialize(self) -> None:
+        """Connect to the server, and discover connected devices."""
         host = self._config_entry.data[CONF_HOST]
         port = self._config_entry.data[CONF_PORT]
         _LOGGER.debug("Initializing connection to %s:%s", host, port)
-        self.owproxy = protocol.proxy(host, port)
-        with contextlib.suppress(protocol.OwnetError):
+        self.owproxy = OWServerStatelessProxy(
+            self._config_entry.data[CONF_HOST], self._config_entry.data[CONF_PORT]
+        )
+        await self.owproxy.validate()
+        with contextlib.suppress(OWServerReturnError):
             # Version is not available on all servers
-            self._version = self.owproxy.read(protocol.PTH_VERSION).decode()
-        self.devices = _discover_devices(self.owproxy)
+            self._version = (
+                await self.owproxy.read(OWServerCommonPath.VERSION)
+            ).decode()
+        self.devices = await _discover_devices(self.owproxy)
 
     async def initialize(self) -> None:
         """Initialize a config entry."""
-        await self._hass.async_add_executor_job(self._initialize)
+        await self._initialize()
         self._populate_device_registry(self.devices)
 
     @callback
@@ -106,9 +110,7 @@ def schedule_scan_for_new_devices(self) -> None:
 
     async def _scan_for_new_devices(self, _: datetime) -> None:
         """Scan the bus for new devices."""
-        devices = await self._hass.async_add_executor_job(
-            _discover_devices, self.owproxy
-        )
+        devices = await _discover_devices(self.owproxy)
         existing_device_ids = [device.id for device in self.devices]
         new_devices = [
             device for device in devices if device.id not in existing_device_ids
@@ -121,16 +123,16 @@ async def _scan_for_new_devices(self, _: datetime) -> None:
             )
 
 
-def _discover_devices(
-    owproxy: protocol._Proxy, path: str = "/", parent_id: str | None = None
+async def _discover_devices(
+    owproxy: OWServerStatelessProxy, path: str = "/", parent_id: str | None = None
 ) -> list[OWDeviceDescription]:
     """Discover all server devices."""
     devices: list[OWDeviceDescription] = []
-    for device_path in owproxy.dir(path):
+    for device_path in await owproxy.dir(path):
         device_id = os.path.split(os.path.split(device_path)[0])[1]
-        device_family = owproxy.read(f"{device_path}family").decode()
+        device_family = (await owproxy.read(f"{device_path}family")).decode()
         _LOGGER.debug("read `%sfamily`: %s", device_path, device_family)
-        device_type = _get_device_type(owproxy, device_path)
+        device_type = await _get_device_type(owproxy, device_path)
         if not _is_known_device(device_family, device_type):
             _LOGGER.warning(
                 "Ignoring unknown device family/type (%s/%s) found for device %s",
@@ -159,22 +161,24 @@ def _discover_devices(
         devices.append(device)
         if device_branches := DEVICE_COUPLERS.get(device_family):
             for branch in device_branches:
-                devices += _discover_devices(
+                devices += await _discover_devices(
                     owproxy, f"{device_path}{branch}", device_id
                 )
 
     return devices
 
 
-def _get_device_type(owproxy: protocol._Proxy, device_path: str) -> str | None:
+async def _get_device_type(
+    owproxy: OWServerStatelessProxy, device_path: str
+) -> str | None:
     """Get device model."""
     try:
-        device_type: str = owproxy.read(f"{device_path}type").decode()
-    except protocol.ProtocolError as exc:
+        device_type = (await owproxy.read(f"{device_path}type")).decode()
+    except OWServerProtocolError as exc:
         _LOGGER.debug("Unable to read `%stype`: %s", device_path, exc)
         return None
     _LOGGER.debug("read `%stype`: %s", device_path, device_type)
     if device_type == "EDS":
-        device_type = owproxy.read(f"{device_path}device_type").decode()
+        device_type = (await owproxy.read(f"{device_path}device_type")).decode()
         _LOGGER.debug("read `%sdevice_type`: %s", device_path, device_type)
     return device_type

homeassistant/components/onewire/select.py

@@ -105,6 +105,6 @@ def current_option(self) -> str | None:
         """Return the selected entity option to represent the entity state."""
         return str(self._state)
 
-    def select_option(self, option: str) -> None:
+    async def async_select_option(self, option: str) -> None:
         """Change the selected option."""
-        self._write_value(option.encode("ascii"))
+        await self._write_value(option.encode("ascii"))

homeassistant/components/onewire/sensor.py

@@ -9,7 +9,7 @@
 import os
 from typing import Any
 
-from pyownet import protocol
+from aio_ownet.exceptions import OWServerReturnError
 
 from homeassistant.components.sensor import (
     SensorDeviceClass,
@@ -397,11 +397,7 @@ async def _add_entities(
         """Add 1-Wire entities for all devices."""
         if not devices:
             return
-        # note: we have to go through the executor as SENSOR platform
-        # makes extra calls to the hub during device listing
-        entities = await hass.async_add_executor_job(
-            get_entities, hub, devices, config_entry.options
-        )
+        entities = await get_entities(hub, devices, config_entry.options)
         async_add_entities(entities, True)
 
     hub = config_entry.runtime_data
@@ -411,7 +407,7 @@ async def _add_entities(
     )
 
 
-def get_entities(
+async def get_entities(
     onewire_hub: OneWireHub,
     devices: list[OWDeviceDescription],
     options: Mapping[str, Any],
@@ -441,8 +437,10 @@ def get_entities(
             if description.key.startswith("moisture/"):
                 s_id = description.key.split(".")[1]
                 is_leaf = int(
-                    onewire_hub.owproxy.read(
-                        f"{device_path}moisture/is_leaf.{s_id}"
+                    (
+                        await onewire_hub.owproxy.read(
+                            f"{device_path}moisture/is_leaf.{s_id}"
+                        )
                     ).decode()
                 )
                 if is_leaf:
@@ -463,8 +461,8 @@ def get_entities(
             if family == "12":
                 # We need to check if there is TAI8570 plugged in
                 try:
-                    onewire_hub.owproxy.read(device_file)
-                except protocol.OwnetError as err:
+                    await onewire_hub.owproxy.read(device_file)
+                except OWServerReturnError as err:
                     _LOGGER.debug(
                         "Ignoring unreachable sensor %s",
                         device_file,

homeassistant/components/onewire/switch.py

@@ -220,10 +220,10 @@ def is_on(self) -> bool | None:
             return None
         return self._state == 1
 
-    def turn_on(self, **kwargs: Any) -> None:
+    async def async_turn_on(self, **kwargs: Any) -> None:
         """Turn the entity on."""
-        self._write_value(b"1")
+        await self._write_value(b"1")
 
-    def turn_off(self, **kwargs: Any) -> None:
+    async def async_turn_off(self, **kwargs: Any) -> None:
         """Turn the entity off."""
-        self._write_value(b"0")
+        await self._write_value(b"0")