* Moving get_compatible_pins function to be defined at the UOSDevice level.

  This is justified by the same reason as moving the ``get_pin``.
* ``UOSDevice.device`` set protected to avoid confusion and misuse.
  This is primarily for internal use and where it is required for clients
  getter methods such as ``get_pin`` should be provided.

Author: CreatingNull

CHANGES.rst

@@ -3,12 +3,17 @@ Version 0.6.0
 
 :Date: TBC
 
-* Moving get_pin function to be defined at the UOSDevice level.
+* Moving ``get_pin`` function to be defined at the UOSDevice level.
   This is a client-facing function and low level devices aren't client-facing.
   Also set ``pin_index`` argument to be ``pin`` so this is more consistent
   with the other API functions.
 * ``Device._pins`` un-protected as this was purely to promote use of get_pin.
 * ``Device.get_pins`` removed as this is not required if pins is not protected.
+* Moving ``get_compatible_pins`` function to be defined at the UOSDevice level.
+  This is justified by the same reason as moving the ``get_pin``.
+* ``UOSDevice.device`` set protected to avoid confusion and misuse.
+  This is primarily for internal use and where it is required for clients
+  getter methods such as ``get_pin`` should be provided.
 
 Version 0.5.0
 -------------

tests/test_api.py

@@ -101,12 +101,12 @@ def test_context_manager(uos_identities: dict):
 
 
 @pytest.mark.parametrize("function", UOSFunctions.enumerate_functions())
-def test_device_function(uos_device, function: UOSFunction):
+def test_device_function(uos_device: UOSDevice, function: UOSFunction):
     """Checks the UOS functions respond correctly."""
     for volatility in Persistence:
-        if volatility not in uos_device.device.functions_enabled[function.name]:
+        if volatility not in uos_device.get_functions_enabled()[function.name]:
             continue  # Ignore unsupported volatilities for device
-        pins_indices = uos_device.device.get_compatible_pins(function)
+        pins_indices = uos_device.get_compatible_pins(function)
         for pin_index in pins_indices:
             api_function = getattr(uos_device, function.name)
             call_arguments = {}

tests/test_devices.py

@@ -14,8 +14,8 @@ def test_get_compatible_pins(uos_device: UOSDevice):
         UOSFunctions.get_gpio_input,
         UOSFunctions.get_adc_input,
     ):
-        if function.name in uos_device.device.functions_enabled:
-            pins_indices = uos_device.device.get_compatible_pins(function)
+        if function.name in uos_device.get_functions_enabled():
+            pins_indices = uos_device.get_compatible_pins(function)
             assert len(pins_indices) > 0
             for pin_index in pins_indices:
                 pin = uos_device.get_pin(pin_index)
@@ -25,11 +25,11 @@ def test_get_compatible_pins(uos_device: UOSDevice):
                 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)
+    pins = uos_device.get_compatible_pins(UOSFunctions.hard_reset)
     assert isinstance(pins, set)
     assert len(pins) == 0
     # Check bad function throws unsupported error
     with pytest.raises(UOSUnsupportedError):
-        uos_device.device.get_compatible_pins(
+        uos_device.get_compatible_pins(
             UOSFunction(name="bad_function", address_lut={}, ack=False)
         )

uoshardware/abstractions.py

@@ -335,27 +335,6 @@ class Device:
     pins: dict[int, Pin] = field(default_factory=dict)
     aux_params: dict = field(default_factory=dict)
 
-    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: 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 set()
-        return {
-            pin_index
-            for pin_index, pin in self.pins.items()
-            if all(
-                getattr(pin, requirement) for requirement in function.pin_requirements
-            )
-        }
-
     def update_adc_samples(self, result: ComResult):
         """Update the pin samples with the response of a get_adc_input."""
         if not result.status or len(result.exception) != 0:

uoshardware/api.py

@@ -57,14 +57,14 @@ def get_device_definition(identity: str) -> Device | None:
 class UOSDevice:  # dead: disable
     """Class for high level object-orientated control of UOS devices.
 
-    :ivar device: Device definitions as parsed from a compatible ini.
+    :ivar __device: Device definitions as parsed from a compatible ini.
     :ivar identity: The type of device, this is must have a valid device in the config.
     :ivar address: Compliant connection string for identifying the device and interface.
     :ivar __device_interface: Lower level communication protocol layer.
     :ivar __kwargs: Connection specific / optional parameters.
     """
 
-    device: Device
+    __device: Device
     identity = ""
     address = ""
     __device_interface: UOSInterface
@@ -101,13 +101,16 @@ def __init__(
             raise UOSUnsupportedError(
                 f"'{self.identity}' does not have a valid look up table"
             )
-        self.device = device
-        if interface == Interface.SERIAL and Interface.SERIAL in self.device.interfaces:
+        self.__device = device
+        if (
+            interface == Interface.SERIAL
+            and Interface.SERIAL in self.__device.interfaces
+        ):
             self.__device_interface = Serial(
                 address,
-                baudrate=self.device.aux_params["default_baudrate"],
+                baudrate=self.__device.aux_params["default_baudrate"],
             )
-        elif interface == Interface.STUB and Interface.STUB in self.device.interfaces:
+        elif interface == Interface.STUB and Interface.STUB in self.__device.interfaces:
             self.__device_interface = Stub(
                 connection=address,
                 errored=(kwargs["errored"] if "errored" in kwargs else False),
@@ -173,7 +176,7 @@ def get_gpio_input(
             ),
         )
         if result.status:
-            self.device.update_gpio_samples(result)
+            self.__device.update_gpio_samples(result)
         return result
 
     def get_adc_input(
@@ -192,7 +195,7 @@ def get_adc_input(
             ),
         )
         if result.status:  # update the samples in the device.
-            self.device.update_adc_samples(result)
+            self.__device.update_adc_samples(result)
         return result
 
     def get_system_info(self) -> ComResult:
@@ -254,17 +257,16 @@ def __execute_instruction(
         :raises: UOSUnsupportedError if function is not possible on the loaded device.
         """
         if (
-            function.name not in self.device.functions_enabled
+            function.name not in self.__device.functions_enabled
             or (
                 instruction_data.check_pin is not None
-                and instruction_data.check_pin
-                not in self.device.get_compatible_pins(function)
+                and instruction_data.check_pin not in self.get_compatible_pins(function)
             )
             or instruction_data.volatility
-            not in self.device.functions_enabled[function.name]
+            not in self.__device.functions_enabled[function.name]
         ):
             logger.debug(
-                "Known functions %s", str(self.device.functions_enabled.keys())
+                "Known functions %s", str(self.__device.functions_enabled.keys())
             )
             raise UOSUnsupportedError(
                 f"{function.name}({instruction_data.volatility.name}) "
@@ -332,11 +334,40 @@ def get_pin(self, pin: int) -> Pin:  # dead: disable
         :param pin: The index of the pin to return.
         :return: Pin object for provided index.
         """
-        if pin not in self.device.pins:
+        if pin not in self.__device.pins:
             raise UOSRuntimeError(
-                f"Pin index {pin} doesn't exist for device {self.device.name}"
+                f"Pin index {pin} doesn't exist for device {self.__device.name}"
+            )
+        return self.__device.pins[pin]
+
+    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: 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 set()
+        return {
+            pin_index
+            for pin_index, pin in self.__device.pins.items()
+            if all(
+                getattr(pin, requirement) for requirement in function.pin_requirements
             )
-        return self.device.pins[pin]
+        }
+
+    # False positive as this is a client-facing function.
+    def get_functions_enabled(self) -> dict:  # dead: disable
+        """Return functions enabled for the device.
+
+        :return: Dictionary of function names to list of Persistence levels.
+        """
+        return self.__device.functions_enabled
 
     def __repr__(self):
         """Representation of the UOS device.
@@ -345,6 +376,6 @@ def __repr__(self):
         """
         return (
             f"<UOSDevice(address='{self.address}', identity='{self.identity}', "
-            f"device={self.device}, __device_interface='{self.__device_interface}', "
+            f"device={self.__device}, __device_interface='{self.__device_interface}', "
             f"__kwargs={self.__kwargs})>"
         )