BDPotentiometer 0.0.2__tar.gz → 0.0.3__tar.gz

{BDPotentiometer-0.0.2/src/BDPotentiometer.egg-info → BDPotentiometer-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: BDPotentiometer
-Version: 0.0.2
+Version: 0.0.3
 Summary: BD Digital Potentiometer
 Author-email: Anton Bondarenko <bond.anton@gmail.com>
 License: MIT License
@@ -32,10 +32,17 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gpiozero>=1.6.2
 Provides-Extra: dev
+Requires-Dist: gpiozero>=1.6.2; extra == "dev"
+Requires-Dist: numpy; extra == "dev"
 Provides-Extra: test
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: numpy; extra == "test"
 Provides-Extra: lint
-License-File: LICENSE
+Requires-Dist: pylint; extra == "lint"
 
 # BDPotentiometer
 

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3}/src/BDPotentiometer/__helpers.py

@@ -1,19 +1,29 @@
 """This module contains internal helper functions and not supposed to be used outside."""
 
 from numbers import Real, Integral
+from math import isnan
 from typing import Union, Callable
 
 
 def check_number(num: Union[float, int, Real]) -> Union[float, int]:
     """
     Checks if argument is a real number.
+    check_number does not allow argument to be `+inf` or `-inf`, or `NaN`.
+    Special float numbers `+0.0` and `-0.0` will be converted to just 0.0
+
     :param num: variable to check.
     :return: Unchanged `num` as float or int or raises ValueError if num is not a real number.
     """
     if not isinstance(num, Real):
-        raise ValueError(f"Expected integer or float number, got {type(num)}")
+        raise TypeError(f"Expected integer or float number, got {type(num)}")
     if isinstance(num, Integral):
         return int(num)
+    if num in [float("inf"), float("-inf")]:
+        raise ValueError(f"Expected integer or float number, got {num}")
+    if isnan(num):
+        raise ValueError("Expected integer or float number, not NaN")
+    if num == 0:
+        return 0.0
     return float(num)
 
 
@@ -57,11 +67,11 @@ def check_positive(num: Union[float, int]) -> Union[float, int]:
     return num
 
 
-def coerce(
+def clamp(
     value: Union[float, int], min_value: Union[float, int], max_value: Union[float, int]
 ) -> Union[float, int]:
     """
-    Coerce `value` to given range between `min_value` and `max_value`.
+    Clamp `value` to given range between `min_value` and `max_value`.
 
     :param value: Either float or int number to be coerced.
     :param min_value: Lower coerce range boundary.
@@ -74,14 +84,18 @@ def coerce(
     if min_value > max_value:
         min_value, max_value = max_value, min_value
     if value < min_value:
+        if isinstance(value, float):
+            return float(min_value)
         return min_value
     if value > max_value:
+        if isinstance(value, float):
+            return float(max_value)
         return max_value
     return value
 
 
 def build_tuple(
-    value: Union[float, int, tuple, list],
+    value: Union[float, int, tuple[float, ...], list[float, ...]],
     num: Union[int, float],
     func: Union[Callable, None] = None,
 ) -> tuple[float, ...]:
@@ -103,24 +117,24 @@ def build_tuple(
         return val
 
     if not isinstance(value, (float, int, tuple, list)):
-        raise ValueError("Argument should be a number or list or tuple of numbers")
+        raise TypeError("Argument should be a number or list or tuple of numbers")
     num = check_integer(check_positive(num))
     if func is not None:
         if not callable(func):
-            raise ValueError("function must be callable or None")
+            raise TypeError("function must be callable or None")
     else:
         func = identity
 
-    if isinstance(value, (float, int)):
-        return tuple(float(func(value)) for _ in range(num))
     if isinstance(value, (list, tuple)):
         if len(value) != num:
             raise ValueError(f"A tuple or list of length {num} expected")
-        return tuple(float(func(value_i)) for value_i in value)
+        return tuple(float(func(check_number(value_i))) for value_i in value)
+    value = check_number(value)
+    return tuple(float(func(value)) for _ in range(num))
 
 
 def adjust_tuple(
-    value: Union[tuple[float], list[float]], num: int, default_value: float
+    value: Union[tuple[float, ...], list[float, ...]], num: int, default_value: float
 ) -> tuple[float, ...]:
     """
     Adjusts tuple or list of floats to a given length `num` and returns a tuple.
@@ -133,11 +147,14 @@ def adjust_tuple(
     :return: A tuple of floats of length `num`.
     """
     if not isinstance(value, (tuple, list)):
-        raise ValueError("Argument should be a list or a tuple of numbers")
+        raise TypeError("Argument should be a list or a tuple of numbers")
     num = check_integer(check_positive(num))
     default_value = float(check_number(default_value))
     if len(value) < num:
-        return tuple(list(value) + [default_value] * (num - len(value)))
+        return tuple(
+            [float(check_number(value_i)) for value_i in value]
+            + [default_value] * (num - len(value))
+        )
     if len(value) > num:
-        return tuple(value)[:num]
-    return tuple(value)
+        return tuple(float(check_number(value[i])) for i in range(num))
+    return tuple(float(check_number(value_i)) for value_i in value)

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3}/src/BDPotentiometer/__init__.py

@@ -2,7 +2,7 @@
 
 # pylint: disable=invalid-name
 
-__version__ = "0.0.2"
+__version__ = "0.0.3"
 
 from .potentiometer import Potentiometer
 from .digital_wiper import DigitalWiper, SpiDigitalWiper

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3}/src/BDPotentiometer/digital_potentiometer.py

@@ -200,6 +200,51 @@ class DigitalPotentiometerDevice:
         for i in range(self.channels_num):
             self.channels[i].value = value[i]
 
+    def set_invert(self, channel: Union[int, str] = 0, invert: bool = False) -> int:
+        """
+        Set the invert property for a given channel.
+
+        :param channel: Channel number or label (int | str)
+        :param invert: bool.
+        :return: Wiper position value as int.
+        """
+        channel_number = self._get_channel_number_by_label_or_id(channel)
+        if channel_number is None:
+            raise ValueError(f"Channel {channel} not found.")
+        self.channels[channel_number].invert = invert
+        return self.channels[channel_number].value
+
+    def get_invert(self, channel: Union[int, str] = 0) -> bool:
+        """
+        Get the invert property value for a given channel.
+
+        :param channel: Channel number or label (int | str)
+        :return: invert property value as bool.
+        """
+        channel_number = self._get_channel_number_by_label_or_id(channel)
+        if channel_number is None:
+            raise ValueError(f"Channel {channel} not found.")
+        return self.channels[channel_number].invert
+
+    @property
+    def invert(self) -> tuple[bool, ...]:
+        """
+        Tuple of the invert property of channels.
+
+        :return: Invert property values for all channels as a tuple of booleans.
+        """
+        return tuple(wiper.invert for _, wiper in self.channels.items())
+
+    @invert.setter
+    def invert(self, invert: Union[list[bool], tuple[bool, ...]]) -> None:
+        if len(invert) != self.channels_num:
+            raise ValueError(
+                f"A tuple or list of length {self.channels_num} is expected."
+            )
+        for channel, wiper in self.channels.items():
+            wiper.invert = invert[channel]
+
+
     def set_r_wb(self, channel: Union[int, str] = 0, resistance: float = 0) -> int:
         """
         Set the resistance for given channel between B and W terminals
@@ -384,19 +429,21 @@ class DigitalPotentiometerDevice:
         for channel, wiper in self.channels.items():
             wiper.r_load = resistance[channel]
 
-    def set_voltage_in(self, channel: Union[int, str] = 0, voltage: float = 0.0) -> int:
+    def set_voltage_in(
+        self, channel: Union[int, str] = 0, voltage: float = 0.0
+    ) -> float:
         """
         Set input voltage for a given channel number.
 
         :param channel: Channel number (int).
-        :param voltage: Voltage (float).
-        :return: Wiper position value (int).
+        :param voltage: Requested input voltage (float).
+        :return: Set input voltage (float)
         """
         channel_number = self._get_channel_number_by_label_or_id(channel)
         if channel_number is None:
             raise ValueError(f"Channel {channel} not found.")
         self.channels[channel_number].voltage_in = voltage
-        return self.channels[channel_number].value
+        return self.channels[channel_number].voltage_in
 
     def get_voltage_in(self, channel: Union[int, str] = 0) -> float:
         """
@@ -430,19 +477,19 @@ class DigitalPotentiometerDevice:
 
     def set_voltage_out(
         self, channel: Union[int, str] = 0, voltage: float = 0.0
-    ) -> int:
+    ) -> float:
         """
         Set voltage at wiper for a given channel number.
 
         :param channel: Channel number (int).
         :param voltage: Voltage requested (float).
-        :return: Wiper position value (int).
+        :return: Actual output voltage closest to requested (float).
         """
         channel_number = self._get_channel_number_by_label_or_id(channel)
         if channel_number is None:
             raise ValueError(f"Channel {channel} not found.")
         self.channels[channel_number].voltage_out = voltage
-        return self.channels[channel_number].value
+        return self.channels[channel_number].voltage_out
 
     def get_voltage_out(self, channel: Union[int, str] = 0) -> float:
         """

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3}/src/BDPotentiometer/digital_wiper.py

@@ -5,7 +5,7 @@ from typing import Union
 from gpiozero import SPI
 
 from .potentiometer import Potentiometer
-from .__helpers import check_integer, check_positive, check_not_negative, coerce
+from .__helpers import check_integer, check_positive, check_not_negative, clamp
 
 
 class DigitalWiper:
@@ -22,23 +22,30 @@ class DigitalWiper:
         self,
         potentiometer: Potentiometer,
         max_value: int = 128,
+        invert: bool = False,
         parameters_locked: bool = False,
     ) -> None:
-        self.__locked: bool = bool(parameters_locked)
-        self.__potentiometer = potentiometer
+        self.__parameters_locked: bool = bool(parameters_locked)
+        if isinstance(potentiometer, Potentiometer):
+            self.__potentiometer: Potentiometer = potentiometer
+        else:
+            raise TypeError(
+                f"Expected an instance of Potentiometer class, got {type(potentiometer)}"
+            )
         self.__channel: int = 0
+        self.__invert: bool = bool(invert)
         self.__max_value: int = check_integer(check_positive(max_value))
         self.__value: int = 0
         self.read()
 
     @property
-    def locked(self) -> bool:
+    def parameters_locked(self) -> bool:
         """
         Check if parameters of the wiper are locked.
 
         :return: True if locked and False otherwise
         """
-        return self.__locked
+        return self.__parameters_locked
 
     @property
     def potentiometer(self) -> Potentiometer:
@@ -57,6 +64,14 @@ class DigitalWiper:
     def channel(self, channel: int) -> None:
         self.__channel = check_integer(check_not_negative(channel))
 
+    @property
+    def invert(self) -> bool:
+        return self.__invert
+
+    @invert.setter
+    def invert(self, invert: bool) -> None:
+        self.__invert = bool(invert)
+
     @property
     def min_value(self) -> int:
         """
@@ -76,8 +91,9 @@ class DigitalWiper:
 
     @max_value.setter
     def max_value(self, max_value: int) -> None:
-        if not self.locked:
-            self.__max_value = check_integer(check_positive(max_value))
+        new_value = check_integer(check_positive(max_value))
+        if not self.parameters_locked:
+            self.__max_value = new_value
             self.value = self.__value
 
     def _set_value(self, value: int) -> int:
@@ -87,7 +103,9 @@ class DigitalWiper:
         :param value: Requested value as int.
         :return: Value actually set as int.
         """
-        value = int(round(coerce(value, 0, self.max_value)))
+        value = int(round(clamp(value, 0, self.max_value)))
+        if self.invert:
+            return self.max_value - value
         return value
 
     def _read_value(self) -> int:
@@ -112,11 +130,13 @@ class DigitalWiper:
         :return: Wiper position value (int).
         """
         self.read()
+        if self.invert:
+            return self.max_value - self.__value
         return self.__value
 
     @value.setter
     def value(self, value: int) -> None:
-        value = check_integer(coerce(value, 0, self.max_value))
+        value = clamp(check_integer(value), 0, self.max_value)
         data = self._set_value(value)
         self.__value = data
 
@@ -130,7 +150,7 @@ class DigitalWiper:
 
     @value_relative.setter
     def value_relative(self, value: float) -> None:
-        value = coerce(value, 0, 1)
+        value = clamp(value, 0, 1)
         value_int = int(round(value * self.max_value))
         self.value = value_int
 
@@ -141,7 +161,7 @@ class DigitalWiper:
 
         :return: Resistance between terminals B and W (float).
         """
-        return self.potentiometer.r_wb(self.value / self.max_value)
+        return self.potentiometer.r_wb(self.value_relative)
 
     @r_wb.setter
     def r_wb(self, resistance: float) -> None:
@@ -156,7 +176,7 @@ class DigitalWiper:
 
         :return: Resistance between terminals A and W (float).
         """
-        return self.potentiometer.r_wa(self.value / self.max_value)
+        return self.potentiometer.r_wa(self.value_relative)
 
     @r_wa.setter
     def r_wa(self, resistance: float) -> None:

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3}/src/BDPotentiometer/mcp4xxx/mcp4xx1.py

@@ -68,7 +68,7 @@ class MCP4251(MCP4xx1):
 
 
 class MCP4261(MCP4xx1):
-    """8-bit, dual channel pot with volatile wiper"""
+    """8-bit, dual channel pot with non-volatile wiper"""
 
     def __init__(self, r_ab: float = 10e3, **spi_args) -> None:
         super().__init__(r_ab=r_ab, max_value=256, channels=2, **spi_args)

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3}/src/BDPotentiometer/mcp4xxx/mcp4xxx.py

@@ -107,7 +107,7 @@ class MCP4xxxPotentiometer(Potentiometer):
 
     def __init__(self, r_ab: float, rheostat: bool = False) -> None:
         r_ab = _coerce_r_ab(r_ab)
-        super().__init__(r_ab=r_ab, r_w=75, rheostat=rheostat, locked=True)
+        super().__init__(r_ab=r_ab, r_w=75, rheostat=rheostat, parameters_locked=True)
 
 
 class MCP4xxxWiper(SpiDigitalWiper):

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3}/src/BDPotentiometer/potentiometer.py

@@ -2,7 +2,7 @@
 
 import math as m
 
-from .__helpers import coerce, check_number, check_positive, check_not_negative
+from .__helpers import clamp, check_number, check_positive, check_not_negative
 
 
 class Potentiometer:
@@ -78,11 +78,15 @@ class Potentiometer:
     # pylint: disable=too-many-instance-attributes
 
     def __init__(
-        self, r_ab: float, r_w: float = 0, rheostat: bool = False, locked: bool = False
+        self,
+        r_ab: float,
+        r_w: float = 0,
+        rheostat: bool = False,
+        parameters_locked: bool = False,
     ) -> None:
-        self.__locked: bool = bool(locked)
-        self.__r_ab: float = check_positive(r_ab)
-        self.__r_w: float = check_not_negative(r_w)
+        self.__parameters_locked: bool = bool(parameters_locked)
+        self.__r_ab: float = float(check_positive(r_ab))
+        self.__r_w: float = float(check_not_negative(r_w))
         self.__rheostat: bool = bool(rheostat)
 
         self.__r_lim: float = 0
@@ -100,8 +104,8 @@ class Potentiometer:
 
     @r_ab.setter
     def r_ab(self, resistance: float) -> None:
-        if not self.locked:
-            self.__r_ab = check_positive(resistance)
+        if not self.parameters_locked:
+            self.__r_ab = float(check_positive(resistance))
 
     @property
     def r_w(self) -> float:
@@ -114,17 +118,17 @@ class Potentiometer:
 
     @r_w.setter
     def r_w(self, r_w: float) -> None:
-        if not self.locked:
+        if not self.parameters_locked:
             self.__r_w = float(check_not_negative(r_w))
 
     @property
-    def locked(self) -> bool:
+    def parameters_locked(self) -> bool:
         """
         Check if parameters of the potentiometer are locked.
 
         :return: True if locked and False otherwise
         """
-        return self.__locked
+        return self.__parameters_locked
 
     @property
     def rheostat(self) -> bool:
@@ -143,7 +147,7 @@ class Potentiometer:
 
     @r_lim.setter
     def r_lim(self, r_lim: float) -> None:
-        self.__r_lim = check_not_negative(r_lim)
+        self.__r_lim = float(check_not_negative(r_lim))
 
     @property
     def r_load(self) -> float:
@@ -152,7 +156,7 @@ class Potentiometer:
 
     @r_load.setter
     def r_load(self, r_load: float) -> None:
-        self.__r_load = check_not_negative(r_load)
+        self.__r_load = float(check_not_negative(r_load))
 
     @property
     def voltage_in(self) -> float:
@@ -165,7 +169,7 @@ class Potentiometer:
 
     @voltage_in.setter
     def voltage_in(self, voltage: float) -> None:
-        self.__voltage_in = check_number(voltage)
+        self.__voltage_in = float(check_number(voltage))
 
     def r_wa(self, wiper_position: float) -> float:
         """
@@ -175,7 +179,7 @@ class Potentiometer:
         :param wiper_position: Wiper position in the range [0: 1]
         :return: Resistance between terminals A and W (float).
         """
-        wiper_position = coerce(wiper_position, 0, 1)
+        wiper_position = clamp(wiper_position, 0, 1)
         return self.r_w + (1 - wiper_position) * self.r_ab
 
     def r_wb(self, wiper_position: float) -> float:
@@ -186,7 +190,7 @@ class Potentiometer:
         :param wiper_position: Wiper position in the range [0: 1]
         :return: Resistance between terminals B and W (float).
         """
-        wiper_position = coerce(wiper_position, 0, 1)
+        wiper_position = clamp(wiper_position, 0, 1)
         return self.r_w + wiper_position * self.r_ab
 
     def r_wa_to_position(self, r_wa: float) -> float:
@@ -197,7 +201,7 @@ class Potentiometer:
         :param r_wa: Resistance between terminals A and W (float)
         :return: Wiper position in the range [0: 1] (float).
         """
-        r_wa = coerce(r_wa, self.r_w, self.r_w + self.r_ab)
+        r_wa = clamp(r_wa, self.r_w, self.r_w + self.r_ab)
         return 1 - (r_wa - self.r_w) / self.r_ab
 
     def r_wb_to_position(self, r_wb: float) -> float:
@@ -208,7 +212,7 @@ class Potentiometer:
         :param r_wb: Resistance between terminals B and W (float)
         :return: Wiper position in the range [0: 1] (float).
         """
-        r_wb = coerce(r_wb, self.r_w, self.r_w + self.r_ab)
+        r_wb = clamp(r_wb, self.r_w, self.r_w + self.r_ab)
         return (r_wb - self.r_w) / self.r_ab
 
     def voltage_out(self, wiper_position: float) -> float:
@@ -218,6 +222,7 @@ class Potentiometer:
         :param wiper_position: Wiper position as float number between 0 and 1.
         :return: Voltage (float).
         """
+        wiper_position = clamp(wiper_position, 0, 1)
         if self.rheostat:
             r_total = self.r_load + self.r_lim + self.r_wb(wiper_position)
             return self.voltage_in * self.r_load / r_total
@@ -234,6 +239,7 @@ class Potentiometer:
         :param voltage_out: Output voltage (float).
         :return: Wiper position as float number between 0 and 1.
         """
+        voltage_out = check_number(voltage_out)
         if voltage_out == 0 or self.r_load == 0 or self.voltage_in == 0:
             return 0
         if (self.voltage_in / voltage_out) / abs(self.voltage_in / voltage_out) < 0:

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3/src/BDPotentiometer.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: BDPotentiometer
-Version: 0.0.2
+Version: 0.0.3
 Summary: BD Digital Potentiometer
 Author-email: Anton Bondarenko <bond.anton@gmail.com>
 License: MIT License
@@ -32,10 +32,17 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: gpiozero>=1.6.2
 Provides-Extra: dev
+Requires-Dist: gpiozero>=1.6.2; extra == "dev"
+Requires-Dist: numpy; extra == "dev"
 Provides-Extra: test
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: numpy; extra == "test"
 Provides-Extra: lint
-License-File: LICENSE
+Requires-Dist: pylint; extra == "lint"
 
 # BDPotentiometer
 

{BDPotentiometer-0.0.2 → BDPotentiometer-0.0.3}/src/BDPotentiometer.egg-info/SOURCES.txt

@@ -16,8 +16,4 @@ src/BDPotentiometer/mcp4xxx/__init__.py
 src/BDPotentiometer/mcp4xxx/mcp4xx1.py
 src/BDPotentiometer/mcp4xxx/mcp4xx2.py
 src/BDPotentiometer/mcp4xxx/mcp4xxx.py
-tests/test_digital_potentiometer.py
-tests/test_digital_wiper.py
-tests/test_helpers.py
-tests/test_potentiometer.py
 tests/test_version.py

BDPotentiometer-0.0.3/tests/test_version.py

@@ -0,0 +1,51 @@
+""" Test package version is correctly set """
+import unittest
+
+try:
+    from src.BDPotentiometer import __version__ as version
+except ModuleNotFoundError:
+    from BDPotentiometer import __version__ as version
+
+
+class TestVersion(unittest.TestCase):
+    """
+    Test _version.py has correct version number assigned to global __version__ variable.
+    """
+
+    def test_check_version_numbering(self) -> None:
+        """
+        Version must be string with three integers separated by dot.
+        Example: `0.1.4` or `2.0.0`.
+        All three digits must not negative and must not be equal to zero at the same time.
+        """
+        # Assert version is a string.
+        self.assertTrue(isinstance(version, str))
+
+        # Assert no extra space present. Example: " 0.1.1  " is not correct, "0.1.1" is correct.
+        self.assertEqual(len(version), len(version.strip()))
+
+        # Assert all three parts are present
+        v_l = version.split(".")
+        self.assertEqual(len(v_l), 3)
+
+        # Assert no extra space present in each part.
+        # Example: "0. 1 .1" is not correct, "0.1.1" is correct
+        for i in range(3):
+            self.assertEqual(len(v_l[i]), len(v_l[i].strip()))
+
+        # Convert all parts of the version to int values
+        v_maj = int(v_l[0])
+        v_min = int(v_l[1])
+        v_patch = int(v_l[2])
+
+        # Assert all version numbers are not negative
+        self.assertTrue(v_maj >= 0)
+        self.assertTrue(v_min >= 0)
+        self.assertTrue(v_patch >= 0)
+
+        # Assert all version numbers are not equal to zero at the same time
+        self.assertTrue(v_maj + v_min + v_patch > 0)
+
+
+if __name__ == "__main__":
+    unittest.main()