BDPotentiometer 0.0.1__tar.gz → 0.0.3__tar.gz

BDPotentiometer-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Anton Bondarenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

BDPotentiometer-0.0.3/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: BDPotentiometer
+Version: 0.0.3
+Summary: BD Digital Potentiometer
+Author-email: Anton Bondarenko <bond.anton@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2023 Anton Bondarenko
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://github.com/bond-anton/BDPotentiometer
+Project-URL: Bug Tracker, https://github.com/bond-anton/BDPotentiometer/issues
+Project-URL: Documentation, https://bdpotentiometer.readthedocs.io
+Classifier: Programming Language :: Python :: 3
+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
+Requires-Dist: pylint; extra == "lint"
+
+# BDPotentiometer
+
+![Build](https://github.com/bond-anton/BDPotentiometer/actions/workflows/python-package.yml/badge.svg)
+[![Documentation Status](https://readthedocs.org/projects/bdpotentiometer/badge/?version=latest)](https://bdpotentiometer.readthedocs.io/en/latest/?badge=latest)
+
+Module to operate Digital Potentiometer over SPI bus. Extends gpiozero SPIDev class.
+
+## Installation
+
+To install BDPotentiometer use pip
+```shell
+$ pip install BDPotentiometer
+```
+
+## Usage
+
+Just import the correct potentiometer class, for example MCP4231, and start operating your pot.
+
+```python
+from BDPotentiometer.mcp4xxx import MCP4231
+
+
+my_pot = MCP4231(r_ab=10e3, device=0)
+my_pot.channels[0].value = 43
+```
+
+Please see the [examples](examples) directory for more usage examples.
+
+Detailed documentation is available at https://bdpotentiometer.readthedocs.io
+
+## License
+
+BDPotentiometer is free open source software licensed under MIT License

BDPotentiometer-0.0.3/README.md

@@ -0,0 +1,33 @@
+# BDPotentiometer
+
+![Build](https://github.com/bond-anton/BDPotentiometer/actions/workflows/python-package.yml/badge.svg)
+[![Documentation Status](https://readthedocs.org/projects/bdpotentiometer/badge/?version=latest)](https://bdpotentiometer.readthedocs.io/en/latest/?badge=latest)
+
+Module to operate Digital Potentiometer over SPI bus. Extends gpiozero SPIDev class.
+
+## Installation
+
+To install BDPotentiometer use pip
+```shell
+$ pip install BDPotentiometer
+```
+
+## Usage
+
+Just import the correct potentiometer class, for example MCP4231, and start operating your pot.
+
+```python
+from BDPotentiometer.mcp4xxx import MCP4231
+
+
+my_pot = MCP4231(r_ab=10e3, device=0)
+my_pot.channels[0].value = 43
+```
+
+Please see the [examples](examples) directory for more usage examples.
+
+Detailed documentation is available at https://bdpotentiometer.readthedocs.io
+
+## License
+
+BDPotentiometer is free open source software licensed under MIT License

BDPotentiometer-0.0.3/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "BDPotentiometer"
+dynamic = ["version"]
+description = "BD Digital Potentiometer"
+authors = [
+  { name = "Anton Bondarenko", email = "bond.anton@gmail.com" },
+]
+license = { file = "LICENSE" }
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+requires-python = ">=3.9"
+dependencies = [
+  "gpiozero>=1.6.2",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/bond-anton/BDPotentiometer"
+"Bug Tracker" = "https://github.com/bond-anton/BDPotentiometer/issues"
+"Documentation" = "https://bdpotentiometer.readthedocs.io"
+
+[project.optional-dependencies]
+dev = ["gpiozero>=1.6.2", "numpy"]
+test = ["flake8", "pytest", "numpy"]
+lint = ["pylint"]
+
+[tool.setuptools.dynamic]
+version = {attr = "BDPotentiometer.__version__"}
+
+[tool.mypy]
+python_version = "3.9"
+
+[[tool.mypy.overrides]]
+module = ["gpiozero.*"]
+ignore_missing_imports = true

BDPotentiometer-0.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

BDPotentiometer-0.0.3/src/BDPotentiometer/__gpiozero_helpers.py

@@ -0,0 +1,83 @@
+"""Some helpers for gpiozero."""
+
+try:
+    from gpiozero import Device
+    from gpiozero.pins.local import LocalPiHardwareSPI, LocalPiHardwareSPIShared
+    from gpiozero.pins.rpigpio import RPiGPIOFactory
+except ModuleNotFoundError:
+    pass
+
+
+def fix_gpiozero_dual_cs_spi() -> None:
+    """
+    A workaround written by slghb GitHub user to use two spi devices with hardware spi.
+    Taken from https://github.com/gpiozero/gpiozero/issues/1015
+
+    :return: None.
+    """
+
+    class LocalPiHardwareSPIFixed(LocalPiHardwareSPI):
+        """Custom conflict checker"""
+
+        # pylint: disable=too-few-public-methods
+        def _conflicts_with(self, other):
+            # pylint: disable=protected-access
+            return not (
+                isinstance(other, LocalPiHardwareSPI)
+                and (self._port, self._device) != (other._port, other._device)
+            )
+
+        @property
+        def value(self):
+            """
+            Returns a value representing the device's state. Frequently, this is a
+            boolean value, or a number between 0 and 1 but some devices use larger
+            ranges (e.g. -1 to +1) and composite devices usually use tuples to
+            return the states of all their subordinate components.
+            """
+            raise NotImplementedError
+
+    class LocalPiHardwareSPISharedFixed(LocalPiHardwareSPIShared):
+        """Custom Shared SPI hardware class inheriting from fixed Hardware SPI class above"""
+
+        def _conflicts_with(self, other):
+            # pylint: disable=protected-access
+            return not (
+                isinstance(other, LocalPiHardwareSPI)
+                and (self._port, self._device) != (other._port, other._device)
+            )
+
+        @property
+        def value(self):
+            """
+            Returns a value representing the device's state. Frequently, this is a
+            boolean value, or a number between 0 and 1 but some devices use larger
+            ranges (e.g. -1 to +1) and composite devices usually use tuples to
+            return the states of all their subordinate components.
+            """
+            raise NotImplementedError
+
+    class FixedRPiGPIOFactory(RPiGPIOFactory):
+        """Fixed RPiGPIOFactory"""
+
+        def _get_spi_class(self, shared, hardware):
+            """
+            Return a Fixed SPI class if shared hardware SPI port between two devices
+
+            :param shared: Flag for shared usage of SPI port.
+            :param hardware: Flag for hardware SPI usage.
+            :return:
+            """
+            if hardware:
+                if shared:
+                    return LocalPiHardwareSPISharedFixed
+                return LocalPiHardwareSPIFixed
+            return super()._get_spi_class(shared, hardware)
+
+    Device.pin_factory = FixedRPiGPIOFactory()
+
+
+def fix_gpiozero_dual_cs_spi_dummy() -> None:
+    """
+    A stub function if there will be problems importing above function
+    """

BDPotentiometer-0.0.3/src/BDPotentiometer/__helpers.py

@@ -0,0 +1,160 @@
+"""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 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)
+
+
+def check_integer(num: Union[float, int, Real]) -> int:
+    """
+    Checks if `num` is an integer and converts it to int, otherwise raises ValueError.
+
+    :param num: Number (either int or float) to be checked.
+    :return: int representation of `num` or rises ValueError.
+    """
+    num = check_number(num)
+    if isinstance(num, float):
+        if not num.is_integer():
+            raise ValueError("Argument should be integer number")
+    return int(num)
+
+
+def check_not_negative(num: Union[float, int]) -> Union[float, int]:
+    """
+    Checks if `num` is a not negative number, otherwise rises ValueError.
+
+    :param num: Either float or int number.
+    :return: `num` if it is not negative or rises ValueError.
+    """
+    num = check_number(num)
+    if num < 0:
+        raise ValueError("Argument should be not negative number")
+    return num
+
+
+def check_positive(num: Union[float, int]) -> Union[float, int]:
+    """
+    Checks if `num` is a positive number, otherwise rises ValueError.
+
+    :param num: Either float or int number.
+    :return: `num` if it is positive or rises ValueError.
+    """
+    num = check_number(num)
+    if num <= 0:
+        raise ValueError("Argument should be a positive number")
+    return num
+
+
+def clamp(
+    value: Union[float, int], min_value: Union[float, int], max_value: Union[float, int]
+) -> Union[float, int]:
+    """
+    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.
+    :param max_value: Upper coerce range boundary.
+    :return: Value coerced to given range.
+    """
+    value = check_number(value)
+    min_value = check_number(min_value)
+    max_value = check_number(max_value)
+    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[float, ...], list[float, ...]],
+    num: Union[int, float],
+    func: Union[Callable, None] = None,
+) -> tuple[float, ...]:
+    """
+    Builds tuple of floats of given length by applying a callable `func` to value.
+    If `value` is an iterable (either list or tuple) its length must be equal to `num`.
+    The `func` will be applied to each element of the iterable.
+    If `value` is a number the resulting tuple of length `num` will be built of same `func(value)`
+    elements converted to float.
+    If `func` is None the `value` will enter resulting tuple unchanged.
+
+    :param value: Iterable (either list or tuple) or a number.
+    :param num: A number of elements in a tuple.
+    :param func: Callable to be applied to `value` or None for identity function.
+    :return: A tuple of floats of length `num` produced by application of `func` to `value`.
+    """
+
+    def identity(val: float) -> float:
+        return val
+
+    if not isinstance(value, (float, int, tuple, list)):
+        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 TypeError("function must be callable or None")
+    else:
+        func = identity
+
+    if isinstance(value, (list, tuple)):
+        if len(value) != num:
+            raise ValueError(f"A tuple or list of length {num} expected")
+        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
+) -> tuple[float, ...]:
+    """
+    Adjusts tuple or list of floats to a given length `num` and returns a tuple.
+    if `num` is less than initial length of the tuple it will be truncated to first `num` elements,
+    otherwise it will be appended using `default_value` parameter.
+
+    :param value: Initial iterable (either tuple or list) of float values.
+    :param num: Final length of the tuple.
+    :param default_value: Default value to populate the tuple if it needs to be grown.
+    :return: A tuple of floats of length `num`.
+    """
+    if not isinstance(value, (tuple, list)):
+        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(
+            [float(check_number(value_i)) for value_i in value]
+            + [default_value] * (num - len(value))
+        )
+    if len(value) > num:
+        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.3/src/BDPotentiometer/__init__.py

@@ -0,0 +1,16 @@
+""" Module to operate SPI digital potentiometer devices """
+
+# pylint: disable=invalid-name
+
+__version__ = "0.0.3"
+
+from .potentiometer import Potentiometer
+from .digital_wiper import DigitalWiper, SpiDigitalWiper
+from .digital_potentiometer import DigitalPotentiometerDevice
+
+try:
+    from .__gpiozero_helpers import fix_gpiozero_dual_cs_spi
+except ModuleNotFoundError:
+    from .__gpiozero_helpers import (
+        fix_gpiozero_dual_cs_spi_dummy as fix_gpiozero_dual_cs_spi,
+    )