Add numato integration (#33816)

* Add support for Numato 32 port USB GPIO boards

Included are a binary_sensor, sensor and switch component
implementations. The binary_sensor interface pushes updates via
registered callback functions, so no need to poll here.

Unit tests are included to test against a Numato device mockup.

* Refactor numato configuration due to PR finding

* Resolve minor review findings

* Bump numato-gpio requirement

* Load numato platforms during domain setup

According to review finding

* Guard from platform setup without discovery_info

According to review finding

* Move numato API state into hass.data

According to review finding.

* Avoid side effects in numato entity constructors

According to review finding

* Keep only first line of numato module docstrings

Removed reference to the documentation. Requested by reviewer.

* Minor improvements inspired by review findings

* Fix async tests

Pytest fixture was returning from the yield too early executing teardown
code during test execution.

* Improve test coverage

* Configure GPIO ports early

Review finding

* Move read_gpio callback to outside the loop

Also continue on failed switch setup, resolve other minor review
findings and correct some error messages

* Bump numato-gpio requirement

This fixes a crash during cleanup. When any device had a communication
problem, its cleanup would raise an exception which was not handled,
fell through to the caller and prevented the remaining devices from
being cleaned up.

* Call services directly

Define local helper functions for better readability.
Resolves a review finding.

* Assert something in every test

So not only coverage is satisfied but things are actually tested
to be in the expected state.
Resolves a review finding.

* Clarify scope of notification tests

Make unit test for hass NumatoAPI independent of Home Assistant (very basic test of notifications).
Improve the regular operations test for notifications.

* Test for hass.states after operating switches

Resolves a review finding.

* Check for wrong port directions

* WIP: Split numato tests to multiple files

test_hass_binary_sensor_notification still fails.

* Remove pytest asyncio decorator

Apears to be redundant. Resolves a review finding.

* Call switch services directly.

Resolves a review finding.

* Remove obsolete inline pylint config

Co-Authored-By: Martin Hjelmare <marhje52@gmail.com>

* Improve the numato_gpio module mockup

Resolves a review finding.

* Remove needless explicit conversions to str

Resolves review findings.

* Test setup of binary_sensor callbacks

* Fix test_hass_binary_sensor_notification

* Add forgotten await

Review finding.

Co-authored-by: Martin Hjelmare <marhje52@gmail.com>

homeassistant/components/numato/binary_sensor.py

@@ -0,0 +1,120 @@
+"""Binary sensor platform integration for Numato USB GPIO expanders."""
+from functools import partial
+import logging
+
+from numato_gpio import NumatoGpioError
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+from homeassistant.const import DEVICE_DEFAULT_NAME
+from homeassistant.core import callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect, dispatcher_send
+
+from . import (
+    CONF_BINARY_SENSORS,
+    CONF_DEVICES,
+    CONF_ID,
+    CONF_INVERT_LOGIC,
+    CONF_PORTS,
+    DATA_API,
+    DOMAIN,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+NUMATO_SIGNAL = "numato_signal_{}_{}"
+
+
+def setup_platform(hass, config, add_entities, discovery_info=None):
+    """Set up the configured Numato USB GPIO binary sensor ports."""
+    if discovery_info is None:
+        return
+
+    def read_gpio(device_id, port, level):
+        """Send signal to entity to have it update state."""
+        dispatcher_send(hass, NUMATO_SIGNAL.format(device_id, port), level)
+
+    api = hass.data[DOMAIN][DATA_API]
+    binary_sensors = []
+    devices = hass.data[DOMAIN][CONF_DEVICES]
+    for device in [d for d in devices if CONF_BINARY_SENSORS in d]:
+        device_id = device[CONF_ID]
+        platform = device[CONF_BINARY_SENSORS]
+        invert_logic = platform[CONF_INVERT_LOGIC]
+        ports = platform[CONF_PORTS]
+        for port, port_name in ports.items():
+            try:
+
+                api.setup_input(device_id, port)
+                api.edge_detect(device_id, port, partial(read_gpio, device_id))
+
+            except NumatoGpioError as err:
+                _LOGGER.error(
+                    "Failed to initialize binary sensor '%s' on Numato device %s port %s: %s",
+                    port_name,
+                    device_id,
+                    port,
+                    err,
+                )
+                continue
+
+            binary_sensors.append(
+                NumatoGpioBinarySensor(port_name, device_id, port, invert_logic, api,)
+            )
+    add_entities(binary_sensors, True)
+
+
+class NumatoGpioBinarySensor(BinarySensorDevice):
+    """Represents a binary sensor (input) port of a Numato GPIO expander."""
+
+    def __init__(self, name, device_id, port, invert_logic, api):
+        """Initialize the Numato GPIO based binary sensor object."""
+        self._name = name or DEVICE_DEFAULT_NAME
+        self._device_id = device_id
+        self._port = port
+        self._invert_logic = invert_logic
+        self._state = None
+        self._api = api
+
+    async def async_added_to_hass(self):
+        """Connect state update callback."""
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                NUMATO_SIGNAL.format(self._device_id, self._port),
+                self._async_update_state,
+            )
+        )
+
+    @callback
+    def _async_update_state(self, level):
+        """Update entity state."""
+        self._state = level
+        self.async_write_ha_state()
+
+    @property
+    def should_poll(self):
+        """No polling needed."""
+        return False
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return self._name
+
+    @property
+    def is_on(self):
+        """Return the state of the entity."""
+        return self._state != self._invert_logic
+
+    def update(self):
+        """Update the GPIO state."""
+        try:
+            self._state = self._api.read_input(self._device_id, self._port)
+        except NumatoGpioError as err:
+            self._state = None
+            _LOGGER.error(
+                "Failed to update Numato device %s port %s: %s",
+                self._device_id,
+                self._port,
+                err,
+            )