Updated get_compatible_pins to return a set of pin indices rather than a dict of pins.

This is to encourage the use of ``get_pin`` OOP.

Author: CreatingNull

CHANGES.rst

@@ -32,8 +32,10 @@ Version 0.5.0
   This allows us more freedom to build higher level decoding functions.
 * Adding functionality to include ADC and GPIO responses as objects stored
   in the device pins.
-* Protected pins dict and instead exposed a get_pin function on device.
+* Protected pins dict and instead exposed a ``get_pin`` function on device.
   This allows introspection on pin internals to making usage easier.
+* Updated ``get_compatible_pins`` to return a set of pin indices rather
+  than a dict of pins. This is to encourage the use of ``get_pin`` OOP.
 
 Version 0.4.0
 -------------

tests/test_api.py

@@ -106,14 +106,12 @@ def test_device_function(uos_device, function: UOSFunction):
     for volatility in Persistence:
         if volatility not in uos_device.device.functions_enabled[function.name]:
             continue  # Ignore unsupported volatilities for device
-        pins = uos_device.device.get_compatible_pins(function)
-        if pins is None or len(pins) == 0:
-            pins = [0]  # insert a dummy pin for non-pinned functions.
-        for pin in pins:
+        pins_indices = uos_device.device.get_compatible_pins(function)
+        for pin_index in pins_indices:
             api_function = getattr(uos_device, function.name)
             call_arguments = {}
             if "pin" in signature(api_function).parameters.keys():
-                call_arguments["pin"] = pin
+                call_arguments["pin"] = pin_index
             if "level" in signature(api_function).parameters.keys():
                 call_arguments["level"] = 0
             if "volatility" in signature(api_function).parameters.keys():

tests/test_devices.py

@@ -15,16 +15,18 @@ def test_get_compatible_pins(uos_device: UOSDevice):
         UOSFunctions.get_adc_input,
     ):
         if function.name in uos_device.device.functions_enabled:
-            pins = uos_device.device.get_compatible_pins(function)
-            assert len(pins) > 0
-            assert isinstance(pins[next(iter(pins))], Pin)
-            if function == UOSFunctions.get_adc_input:
-                assert all(pins[pin].adc_in for pin in pins)
-            elif function == UOSFunctions.set_gpio_output:
-                assert all(pins[pin].gpio_out for pin in pins)
+            pins_indices = uos_device.device.get_compatible_pins(function)
+            assert len(pins_indices) > 0
+            for pin_index in pins_indices:
+                pin = uos_device.device.get_pin(pin_index)
+                assert isinstance(pin, Pin)
+                if function == UOSFunctions.get_adc_input:
+                    assert pin.adc_in
+                elif function == UOSFunctions.set_gpio_output:
+                    assert pin.gpio_out
     # Check lookup of function without pins returns empty list.
     pins = uos_device.device.get_compatible_pins(UOSFunctions.hard_reset)
-    assert isinstance(pins, dict)
+    assert isinstance(pins, set)
     assert len(pins) == 0
     # Check bad function throws unsupported error
     with pytest.raises(UOSUnsupportedError):

uoshardware/abstractions.py

@@ -351,21 +351,21 @@ def get_pins(self) -> set:
         """Return a set of pin indices known by this device."""
         return set(self._pins.keys())
 
-    def get_compatible_pins(self, function: UOSFunction) -> dict:
-        """Return a dict of pin objects that are suitable for a function.
+    def get_compatible_pins(self, function: UOSFunction) -> set:
+        """Get pins suitable for use with a particular UOS Function.
 
         :param function: the string name of the UOS Schema function.
-        :return: Dict of pin objects, keyed on pin index.
+        :return: Set of pin indices which support the function.
         """
         if (
             not isinstance(function, UOSFunction)
             or function not in UOSFunctions.enumerate_functions()
         ):
             raise UOSUnsupportedError(f"UOS function {function.name} doesn't exist.")
         if function.pin_requirements is None:  # pins are not relevant to this function
-            return {}
+            return set()
         return {
-            pin_index: pin
+            pin_index
             for pin_index, pin in self._pins.items()
             if all(
                 getattr(pin, requirement) for requirement in function.pin_requirements