scietex.hal.dac 0.1.0__py3-none-any.whl

scietex/hal/dac/__helpers.py

@@ -0,0 +1,195 @@
+"""Internal validation helpers shared by the package.
+
+These functions are not part of the public API. They check the type of an
+argument first, raising `TypeError` for anything that is not a real number, and
+its value second, raising `ValueError` for infinities, `NaN`, and values outside
+the requested range.
+"""
+
+from math import isnan
+from numbers import Integral, Real
+
+
+def check_number(num: float | int | Real) -> float | int:
+    """
+    Check that `num` is a finite real number.
+
+    Infinity and `NaN` are rejected. `bool` is rejected as well even though it
+    is an `int` subclass: `True` and `False` are flags, not measurements, and
+    accepting them as numbers hides caller mistakes. Both `+0.0` and `-0.0` are
+    returned as `0.0`; integers are returned as int, all other numbers as float.
+
+    :param num: variable to check.
+    :return: Unchanged `num` as int or float.
+    :raises TypeError: If `num` is not a real number, or is a `bool`.
+    :raises ValueError: If `num` is infinite or `NaN`.
+    """
+    if isinstance(num, bool):
+        raise TypeError(
+            f"Expected a finite integer or float number, not bool {num!r} "
+            f"of type {type(num)}"
+        )
+    if not isinstance(num, Real):
+        raise TypeError(f"Expected a finite 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 a finite integer or float number, got {num}")
+    if isnan(num):
+        raise ValueError("Expected a finite integer or float number, not NaN")
+    if num == 0:
+        return 0.0
+    return float(num)
+
+
+def check_integer(num: float | int | Real) -> int:
+    """
+    Check that `num` is an integer and convert it to int.
+
+    :param num: Number (either int or float) to be checked.
+    :return: int representation of `num`.
+    :raises TypeError: If `num` is not a real number, or is a `bool`.
+    :raises ValueError: If `num` is infinite, `NaN`, or has a fractional part.
+    """
+    num = check_number(num)
+    if isinstance(num, float) and not num.is_integer():
+        raise ValueError(f"Expected an integer number, got {num}")
+    return int(num)
+
+
+def check_bool(value: bool) -> bool:
+    """
+    Check that `value` is a boolean.
+
+    :param value: variable to check.
+    :return: Unchanged `value` as bool.
+    :raises TypeError: If `value` is not a boolean.
+    """
+    if not isinstance(value, bool):
+        raise TypeError(f"Expected a boolean, got {value!r} of type {type(value)}")
+    return value
+
+
+LABEL_MAX_LENGTH = 64
+
+
+def check_label(value: str) -> str:
+    """
+    Check that `value` is a non-empty string usable as a channel label.
+
+    Non-string input is rejected instead of coerced, so a label can never be
+    confused with a channel number. Surrounding whitespace is stripped and the
+    stripped text is returned, so `" a "` and `"a"` are the same label and an
+    all-whitespace string is empty.
+
+    :param value: Label to check.
+    :return: Stripped label as str.
+    :raises TypeError: If `value` is not a str.
+    :raises ValueError: If `value` is empty after stripping, or longer than
+        `LABEL_MAX_LENGTH` characters.
+    """
+    if not isinstance(value, str):
+        raise TypeError(f"Expected a string label, got {value!r} of type {type(value)}")
+    text = value.strip()
+    if not text:
+        raise ValueError("Expected a non-empty label")
+    if len(text) > LABEL_MAX_LENGTH:
+        raise ValueError(
+            f"Expected a label of at most {LABEL_MAX_LENGTH} characters, "
+            f"got {len(text)}"
+        )
+    return text
+
+
+def check_positive(num: float | int) -> float | int:
+    """
+    Check that `num` is a positive number.
+
+    `bool` is rejected as a type error even though it is an `int` subclass; pass
+    `1` explicitly when a numeric flag is intended.
+
+    :param num: Either float or int number.
+    :return: `num` unchanged.
+    :raises TypeError: If `num` is not a real number, or is a `bool`.
+    :raises ValueError: If `num` is zero, negative, infinite, or `NaN`.
+    """
+    num = check_number(num)
+    if num <= 0:
+        raise ValueError(f"Expected a positive number, got {num}")
+    return num
+
+
+def clamp(
+    value: float | int, min_value: float | int, max_value: float | int
+) -> float | int:
+    """
+    Clamp `value` to the range between `min_value` and `max_value`.
+
+    The bounds may be passed in any order: swapped bounds are normalized before
+    the comparison. A float `value` always stays a float, even when it is
+    clamped to an int bound. All three arguments reject `bool` even though it
+    is an `int` subclass; pass `0` or `1` explicitly when a numeric flag is
+    intended.
+
+    :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 the given range.
+    :raises TypeError: If an argument is not a real number, or is a `bool`.
+    :raises ValueError: If an argument is infinite or `NaN`.
+    """
+    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 check_reference(value: float | None) -> float | None:
+    """
+    Check an optional reference: `None` passes through, a number must be positive.
+
+    The reference is unit-neutral: it is a full-scale value in volts for a
+    voltage output and in amperes for a current output, so only its positivity
+    is enforced here.
+
+    :param value: Reference value, or None when the scaling is unknown.
+    :return: `None`, or the reference as float.
+    :raises TypeError: If `value` is not a real number, or is a `bool`.
+    :raises ValueError: If `value` is zero, negative, infinite, or `NaN`.
+    """
+    if value is None:
+        return None
+    return float(check_positive(value))
+
+
+def check_grounded(value: str) -> str:
+    """
+    Check the terminal a divider output is grounded at.
+
+    Only `"A"` and `"B"` are meaningful: grounding B makes the output rise with
+    the code, grounding A makes it fall. Anything else is rejected instead of
+    coerced, so a typo cannot silently pick a direction.
+
+    :param value: Terminal name, either `"A"` or `"B"`.
+    :return: Unchanged terminal name.
+    :raises TypeError: If `value` is not a str.
+    :raises ValueError: If `value` is neither `"A"` nor `"B"`.
+    """
+    if not isinstance(value, str):
+        raise TypeError(
+            f'Expected "A" or "B" as a grounded terminal, '
+            f"got {value!r} of type {type(value)}"
+        )
+    if value not in ("A", "B"):
+        raise ValueError(f'Expected "A" or "B" as a grounded terminal, got {value!r}')
+    return value

scietex/hal/dac/__init__.py

@@ -0,0 +1,30 @@
+"""Digital-to-analog converters."""
+
+from .channel import (
+    CurrentChannel,
+    DACChannel,
+    DACUnit,
+    DividerChannel,
+    VoltageChannel,
+)
+from .dac import DAC
+from .errors import DACCodeError, DACError, DACReferenceError
+from .mcp4xxx import MCP4231, MCP4241, MCP4251, MCP4261
+from .version import __version__
+
+__all__ = [
+    "__version__",
+    "DAC",
+    "DACChannel",
+    "DACUnit",
+    "VoltageChannel",
+    "CurrentChannel",
+    "DividerChannel",
+    "DACError",
+    "DACReferenceError",
+    "DACCodeError",
+    "MCP4231",
+    "MCP4241",
+    "MCP4251",
+    "MCP4261",
+]

scietex/hal/dac/__logger.py

@@ -0,0 +1,80 @@
+"""Logger factory used by every device class.
+
+Each device gets its own named logger so that a single device can be traced
+without enabling logging for the whole package.
+
+Loggers keep ``propagate = True``: a record emitted here also reaches the
+application's root handlers. If the application installs its own handler at the
+root (or on a parent logger), the same record may be printed twice. Disable
+propagation on the returned logger if that is not wanted.
+"""
+
+import logging
+import threading
+
+# Guards handler installation so that two threads calling `get_logger` for the
+# same label cannot attach two handlers.
+_LOCK = threading.Lock()
+
+_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+
+# Marks the one handler this module owns. Tagging the handler keeps the package
+# handler distinguishable from handlers the application installs on the same
+# logger, so an explicit level is never applied to application handlers.
+_PACKAGE_HANDLER_ATTR = "_dac_package_handler"
+
+
+def _package_handler(logger: logging.Logger) -> logging.Handler | None:
+    """Return the handler installed by this module, if it is still attached."""
+    for handler in logger.handlers:
+        if getattr(handler, _PACKAGE_HANDLER_ATTR, False):
+            return handler
+    return None
+
+
+def get_logger(label: str, log_level: int | str | None = None) -> logging.Logger:
+    """
+    Return the named logger `label`, configured once.
+
+    The level defaults to `logging.ERROR` when `log_level` is None. On first use
+    the logger gets exactly one tagged `logging.StreamHandler` with the package
+    format. Later calls with `log_level=None` leave the level and handlers
+    untouched unless the package handler was removed, in which case it is
+    re-attached at the logger's current level. An explicit `log_level` is
+    applied on every call to the logger and to the package handler only;
+    handlers installed by the application are never re-leveled. Any int level,
+    including `logging.NOTSET`, is applied as given; only `None` selects the
+    default `logging.ERROR`.
+
+    The logger keeps ``propagate = True``, so its records also reach the
+    application's root handlers and may be duplicated if the application adds
+    its own handler.
+
+    :param label: Logger name, also used to look up an already configured logger.
+    :param log_level: Logging level such as `logging.DEBUG`; defaults to `logging.ERROR`.
+    :return: Configured logger.
+    """
+    logger = logging.getLogger(label)
+    with _LOCK:
+        handler = _package_handler(logger)
+        if handler is None:
+            if log_level is not None:
+                level = log_level
+                logger.setLevel(level)
+            elif logger.level == logging.NOTSET:
+                level = logging.ERROR
+                logger.setLevel(level)
+            else:
+                # Re-attach after application code cleared the handlers without
+                # discarding the level configured by an earlier call.
+                level = logger.level
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter(_FORMAT))
+            handler.setLevel(level)
+            setattr(handler, _PACKAGE_HANDLER_ATTR, True)
+            logger.addHandler(handler)
+        elif log_level is not None:
+            logger.setLevel(log_level)
+            handler.setLevel(log_level)
+        logger.propagate = True
+    return logger

scietex/hal/dac/channel.py

@@ -0,0 +1,296 @@
+"""Channel objects for digital-to-analog converters."""
+
+from enum import Enum
+from typing import TYPE_CHECKING, ClassVar, cast
+
+from .__helpers import (
+    check_grounded,
+    check_integer,
+    check_number,
+    check_reference,
+    clamp,
+)
+from .errors import DACCodeError, DACReferenceError
+
+if TYPE_CHECKING:
+    from .dac import DAC
+
+
+class DACUnit(str, Enum):
+    """Physical quantity a channel drives."""
+
+    VOLTAGE = "V"
+    CURRENT = "A"
+
+    def __str__(self) -> str:
+        """Return the unit symbol, so the enum prints like the bare suffix."""
+        return self.value
+
+
+class DACChannel:
+    """
+    One output of a `DAC` device.
+
+    The channel keeps no register state: reading `value` asks the device every
+    time, and the setter writes the code through to it. `output` scales that
+    code by the reference and stays None while no reference is configured,
+    because the library will not guess a full scale.
+
+    A device may scale each channel differently, so `reference_override` wins
+    over the device reference for this channel only.
+    """
+
+    UNIT: ClassVar[DACUnit] = DACUnit.VOLTAGE
+
+    def __init__(self, dac: "DAC", index: int) -> None:
+        self._dac = dac
+        self.index = check_integer(index)
+        self._reference_override: float | None = None
+        self._reported_code: int | None = None
+
+    @property
+    def max_code(self) -> int:
+        """Largest raw code the device accepts for this channel."""
+        return self._dac.max_code
+
+    @property
+    def unit(self) -> DACUnit:
+        """Physical quantity this channel drives."""
+        return self.UNIT
+
+    @property
+    def reference_override(self) -> float | None:
+        """Per-channel reference that wins over the device reference."""
+        return self._reference_override
+
+    @reference_override.setter
+    def reference_override(self, reference: float | None) -> None:
+        """
+        Set a per-channel reference, or clear it with None.
+
+        :param reference: Positive reference, or None to fall back to the
+            device reference (float | None).
+        :raises TypeError: If `reference` is not a real number, or is a `bool`.
+        :raises ValueError: If `reference` is zero, negative, infinite, or `NaN`.
+        """
+        self._reference_override = check_reference(reference)
+
+    @property
+    def reference(self) -> float | None:
+        """Reference this channel scales by: the override, else the device's."""
+        override = self.reference_override
+        if override is not None:
+            return override
+        return self._dac.reference
+
+    @property
+    def value(self) -> int:
+        """
+        Raw code of the output, read from the device.
+
+        :return: Code in `0..max_code` (int).
+        """
+        return self._read_code()
+
+    @value.setter
+    def value(self, code: int) -> None:
+        """
+        Write a raw code to the device.
+
+        :param code: Code in `0..max_code` (int).
+        :raises TypeError: If `code` is not a real number, or is a `bool`.
+        :raises ValueError: If `code` is fractional, infinite, or `NaN`.
+        :raises DACCodeError: If `code` is outside `0..max_code`.
+        """
+        self._reported_code = self._write_code(self._check_code(code))
+
+    @property
+    def output(self) -> float | None:
+        """
+        Canonical output scaled by the channel reference.
+
+        Units follow the channel: volts for a voltage output, amperes for a
+        current output. The value is the code fraction times the reference, so
+        the top code reaches the reference itself.
+
+        :return: Scaled output, or None when the channel has no reference.
+        """
+        reference = self.reference
+        if reference is None:
+            return None
+        return self._code_to_fraction(self.value) * reference
+
+    @output.setter
+    def output(self, output: float | None) -> None:
+        """
+        Set the output from a scaled value.
+
+        The value is clamped into `0..reference` without an error, so a caller
+        asking for slightly more than full scale gets full scale instead of a
+        rejected write.
+
+        :param output: Output in the channel unit (float).
+        :raises TypeError: If `output` is not a real number, is a `bool`, or is
+            None.
+        :raises ValueError: If `output` is infinite or `NaN`.
+        :raises DACReferenceError: If the channel has no reference.
+        """
+        reference = self.reference
+        if reference is None:
+            raise DACReferenceError(
+                f"Channel {self.index} has no reference configured; "
+                "set the device reference or a channel override first"
+            )
+        # None must reach check_number, which is what rejects it with TypeError.
+        value = clamp(check_number(cast(float, output)), 0.0, reference)
+        self.value = self._fraction_to_code(value / reference)
+
+    def _check_code(self, code: int) -> int:
+        """
+        Validate a raw code before it reaches the device.
+
+        :param code: Candidate code (int).
+        :return: Code as int, unchanged.
+        :raises TypeError: If `code` is not a real number, or is a `bool`.
+        :raises ValueError: If `code` is fractional, infinite, or `NaN`.
+        :raises DACCodeError: If `code` is outside `0..max_code`.
+        """
+        code = check_integer(code)
+        if not 0 <= code <= self.max_code:
+            raise DACCodeError(f"Expected a code within 0..{self.max_code}, got {code}")
+        return code
+
+    def _read_code(self) -> int:
+        """
+        Read the raw code from the device.
+
+        :return: Code in `0..max_code`.
+        :raises NotImplementedError: Always, the base class has no codec.
+        """
+        raise NotImplementedError
+
+    def _write_code(self, code: int) -> int:
+        """
+        Write a validated raw code and return the code the device reports.
+
+        :param code: Code already validated by `_check_code`.
+        :return: Code the device reports after the write.
+        :raises NotImplementedError: Always, the base class has no codec.
+        """
+        raise NotImplementedError
+
+    def _code_to_fraction(self, code: int) -> float:
+        """
+        Map a raw code to the fraction of full scale it selects.
+
+        :param code: Code in `0..max_code`.
+        :return: Fraction in `0..1`.
+        """
+        return code / self.max_code
+
+    def _fraction_to_code(self, fraction: float) -> int:
+        """
+        Map a fraction of full scale to the nearest raw code.
+
+        :param fraction: Fraction in `0..1`.
+        :return: Code in `0..max_code`.
+        """
+        return int(round(fraction * self.max_code))
+
+    def __repr__(self) -> str:
+        """Official string representation (used in debugging)."""
+        return (
+            f"{type(self).__name__}(index={self.index}, code={self._reported_code!r})"
+        )
+
+
+class VoltageChannel(DACChannel):
+    """Channel that drives a voltage output."""
+
+    UNIT: ClassVar[DACUnit] = DACUnit.VOLTAGE
+
+    @property
+    def voltage(self) -> float | None:
+        """Output voltage in volts, an alias of `output`."""
+        return self.output
+
+    @voltage.setter
+    def voltage(self, voltage: float | None) -> None:
+        """Set the output voltage in volts, an alias of `output`."""
+        self.output = voltage
+
+    @property
+    def v_ref(self) -> float | None:
+        """Reference voltage this channel scales by."""
+        return self.reference
+
+    @v_ref.setter
+    def v_ref(self, v_ref: float | None) -> None:
+        """Set a per-channel reference voltage, an alias of `reference_override`."""
+        self.reference_override = v_ref
+
+
+class CurrentChannel(DACChannel):
+    """Channel that drives a current output."""
+
+    UNIT: ClassVar[DACUnit] = DACUnit.CURRENT
+
+    @property
+    def current(self) -> float | None:
+        """Output current in amperes, an alias of `output`."""
+        return self.output
+
+    @current.setter
+    def current(self, current: float | None) -> None:
+        """Set the output current in amperes, an alias of `output`."""
+        self.output = current
+
+    @property
+    def i_full_scale(self) -> float | None:
+        """Full-scale current in amperes this channel scales by."""
+        return self.reference
+
+    @i_full_scale.setter
+    def i_full_scale(self, i_full_scale: float | None) -> None:
+        """Set a per-channel full-scale current, an alias of `reference_override`."""
+        self.reference_override = i_full_scale
+
+
+class DividerChannel(VoltageChannel):
+    """
+    Voltage output of a resistor divider with one terminal grounded.
+
+    Grounding B makes the output rise from 0 V at code 0 to the reference at
+    full code; grounding A mirrors that curve, so the output falls from the
+    reference at code 0 to 0 V at full code.
+    """
+
+    def __init__(self, dac: "DAC", index: int, *, grounded: str) -> None:
+        """
+        Build a divider channel.
+
+        :param dac: Device the channel belongs to (DAC).
+        :param index: Channel index, 0-based (int).
+        :param grounded: Terminal tied to ground, `"A"` or `"B"` (str).
+        :raises TypeError: If `grounded` is not a str.
+        :raises ValueError: If `grounded` is neither `"A"` nor `"B"`.
+        """
+        super().__init__(dac, index)
+        self._grounded = check_grounded(grounded)
+
+    @property
+    def grounded(self) -> str:
+        """Terminal tied to ground: `"B"` rises with the code, `"A"` falls."""
+        return self._grounded
+
+    def _code_to_fraction(self, code: int) -> float:
+        """Map a code to the output fraction of the reference."""
+        if self._grounded == "B":
+            return code / self.max_code
+        return (self.max_code - code) / self.max_code
+
+    def _fraction_to_code(self, fraction: float) -> int:
+        """Map an output fraction of the reference to the nearest code."""
+        if self._grounded == "B":
+            return int(round(fraction * self.max_code))
+        return int(round((1 - fraction) * self.max_code))

scietex/hal/dac/dac.py

@@ -0,0 +1,249 @@
+"""Base class for digital-to-analog converters."""
+
+from collections.abc import Sequence
+from types import TracebackType
+from typing import Any
+
+from .__helpers import check_integer, check_label, check_reference
+from .__logger import get_logger
+from .channel import DACChannel
+
+
+class DAC:
+    """
+    Container for the channels of a digital-to-analog converter.
+
+    The device is transport-agnostic: it wraps a backend object that owns the
+    bus, and its channels are built once from the class-level geometry.
+    `channels` holds them in index order and never changes.
+
+    `reference` is unit-neutral: it is the full scale the outputs map to, in
+    volts for a voltage device and in amperes for a current device. While it is
+    None the scaled `output` of every channel is None, because the library will
+    not guess a full scale.
+
+    The object can be used as a context manager; leaving the block closes the
+    backend.
+    """
+
+    _CHANNELS: int = 0
+    _RESOLUTION: int = 8
+    _CHANNEL_CLASS: type[DACChannel] = DACChannel
+
+    def __init__(
+        self,
+        *,
+        backend: object,
+        reference: float | None = None,
+        channel_count: int | None = None,
+        label: str | None = None,
+        log_level: int | str | None = None,
+    ) -> None:
+        """
+        Build the device around a backend that owns the bus.
+
+        :param backend: Object the device delegates bus access and lifecycle to;
+            it needs `close()` and may expose `transport`, `spi`, and `closed`.
+        :param reference: Full-scale value the channels scale by, or None while
+            it is unknown (float | None).
+        :param channel_count: Number of channels to expose, defaults to the
+            device geometry (int | None).
+        :param label: Logger name, defaults to the class name (str).
+        :param log_level: Logging level such as `logging.DEBUG`; defaults to
+            `logging.ERROR`.
+        :raises TypeError: If `reference` or `label` has the wrong type.
+        :raises ValueError: If `reference` is not positive, `label` is empty,
+            or `channel_count` is outside `1..channels`.
+        """
+        # Duck-typed on purpose: the base class only probes attributes such as
+        # `transport` and calls `close()`, and a device family supplies the
+        # concrete backend.
+        self._backend: Any = backend
+        self._closed = False
+        self.reference = reference
+        self.label = None if label is None else check_label(label)
+        self.logger = get_logger(self.label or type(self).__name__, log_level)
+        count = (
+            self._CHANNELS if channel_count is None else check_integer(channel_count)
+        )
+        if not 1 <= count <= self._CHANNELS:
+            raise ValueError(
+                f"Expected a channel count within 1..{self._CHANNELS}, got {count}"
+            )
+        self.channels: tuple[DACChannel, ...] = tuple(
+            self._make_channel(index) for index in range(count)
+        )
+
+    @property
+    def reference(self) -> float | None:
+        """Full scale the channels map to, or None when it is unknown."""
+        return self._reference
+
+    @reference.setter
+    def reference(self, reference: float | None) -> None:
+        """
+        Set the full scale used by the channel `output` properties.
+
+        :param reference: Positive full scale, or None (float | None).
+        :raises TypeError: If `reference` is not a real number, or is a `bool`.
+        :raises ValueError: If `reference` is zero, negative, infinite, or `NaN`.
+        """
+        self._reference = check_reference(reference)
+
+    @property
+    def v_ref(self) -> float | None:
+        """Alias of `reference`, the conventional name on a voltage device."""
+        return self.reference
+
+    @v_ref.setter
+    def v_ref(self, v_ref: float | None) -> None:
+        """Set the full scale, an alias of `reference`."""
+        self.reference = v_ref
+
+    @property
+    def resolution(self) -> int:
+        """Number of bits in a raw code."""
+        return self._RESOLUTION
+
+    @property
+    def max_code(self) -> int:
+        """Largest raw code the device accepts, `(1 << resolution) - 1`."""
+        return (1 << self.resolution) - 1
+
+    def channel(self, index: int) -> DACChannel:
+        """
+        Return the channel at `index`.
+
+        :param index: Channel index, 0-based (int).
+        :return: `DACChannel` for that output.
+        :raises IndexError: If `index` is outside `0..channels - 1`.
+        """
+        if not 0 <= index < len(self.channels):
+            raise IndexError(f"Channel {index} does not exist")
+        return self.channels[index]
+
+    def read_all(self) -> tuple[int, ...]:
+        """
+        Read every channel.
+
+        No value is cached: each element is a separate bus transaction.
+
+        :return: Raw codes in channel index order (tuple of int).
+        """
+        return tuple(channel.value for channel in self.channels)
+
+    def write_all(self, values: Sequence[int]) -> tuple[int, ...]:
+        """
+        Write one raw code per channel.
+
+        The whole sequence is validated before the first bus transaction, so a
+        rejected element cannot leave the device partially updated.
+
+        :param values: One code per channel (Sequence of int).
+        :return: Codes that were written, in channel index order.
+        :raises TypeError: If `values` is not a sequence, or an element is not
+            a real number, or is a `bool`.
+        :raises ValueError: If the length differs from the channel count, or an
+            element is fractional, infinite, or `NaN`.
+        :raises DACCodeError: If an element is outside `0..max_code`.
+        """
+        if len(values) != len(self.channels):
+            raise ValueError(f"Expected {len(self.channels)} codes, got {len(values)}")
+        codes = tuple(
+            channel._check_code(value)
+            for channel, value in zip(self.channels, values, strict=True)
+        )
+        for channel, code in zip(self.channels, codes, strict=True):
+            channel.value = code
+        return codes
+
+    def _make_channel(self, index: int) -> DACChannel:
+        """
+        Build the channel object for `index`.
+
+        :param index: Channel index, 0-based (int).
+        :return: Channel of the device's channel class.
+        """
+        return self._CHANNEL_CLASS(self, index)
+
+    def _read_code(self, index: int) -> int:
+        """
+        Read one channel as a raw code.
+
+        The base class has no frame format; a device family implements it.
+
+        :param index: Channel index, 0-based (int).
+        :return: Raw code of that channel.
+        :raises NotImplementedError: Always, the base class has no codec.
+        """
+        raise NotImplementedError
+
+    def _write_code(self, index: int, code: int) -> int:
+        """
+        Write one channel as a raw code.
+
+        The base class has no frame format; a device family implements it.
+
+        :param index: Channel index, 0-based (int).
+        :param code: Raw code already validated by the channel.
+        :return: Code the device reports after the write.
+        :raises NotImplementedError: Always, the base class has no codec.
+        """
+        raise NotImplementedError
+
+    @property
+    def transport(self) -> Any:
+        """Bus transport of the backend, or the backend when it exposes none."""
+        return getattr(self._backend, "transport", None) or self._backend
+
+    @property
+    def spi(self) -> Any:
+        """Backend's SPI handle: its `spi`, then its `raw`, then the backend."""
+        spi = getattr(self._backend, "spi", None)
+        if spi is not None:
+            return spi
+        raw = getattr(self._backend, "raw", None)
+        return self._backend if raw is None else raw
+
+    @property
+    def closed(self) -> bool:
+        """
+        True when `close()` has run or the backend reports itself closed.
+
+        A callable `closed` attribute is called first and its result is coerced
+        with `bool`. A backend whose `closed` probe raises counts as not closed;
+        the device's own flag still applies.
+        """
+        try:
+            reported = getattr(self._backend, "closed", False)
+            if callable(reported):
+                reported = reported()
+            reported = bool(reported)
+        except Exception:  # noqa: BLE001 - a broken probe must not leak
+            reported = False
+        return self._closed or reported
+
+    def close(self) -> None:
+        """
+        Close the backend and mark the device closed.
+
+        The device is marked closed even when the backend's `close()` raises;
+        the exception is still propagated.
+        """
+        try:
+            self._backend.close()
+        finally:
+            self._closed = True
+
+    def __enter__(self) -> "DAC":
+        """Return the device itself."""
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Close the backend when leaving the context."""
+        self.close()

scietex/hal/dac/errors.py

@@ -0,0 +1,13 @@
+"""Errors raised by the DAC package."""
+
+
+class DACError(Exception):
+    """Base class for errors raised by this package."""
+
+
+class DACReferenceError(DACError, ValueError):
+    """Raised when output is requested or set with no reference configured."""
+
+
+class DACCodeError(DACError, ValueError):
+    """Raised when a raw code falls outside `0..max_code`."""

scietex/hal/dac/mcp4xxx/__init__.py

@@ -0,0 +1,5 @@
+"""MCP4xxx digital potentiometers."""
+
+from .mcp4xx1 import MCP4231, MCP4241, MCP4251, MCP4261
+
+__all__ = ["MCP4231", "MCP4241", "MCP4251", "MCP4261"]

scietex/hal/dac/mcp4xxx/mcp4xx1.py

@@ -0,0 +1,58 @@
+"""Dual-channel MCP4xx1 digital potentiometers."""
+
+from BDPotentiometer.mcp4xxx.mcp4xx1 import (
+    MCP4231 as _BDMCP4231,
+)
+from BDPotentiometer.mcp4xxx.mcp4xx1 import (
+    MCP4241 as _BDMCP4241,
+)
+from BDPotentiometer.mcp4xxx.mcp4xx1 import (
+    MCP4251 as _BDMCP4251,
+)
+from BDPotentiometer.mcp4xxx.mcp4xx1 import (
+    MCP4261 as _BDMCP4261,
+)
+
+from .mcp4xxx import MCP4xxx
+
+
+class MCP4xx1(MCP4xxx):
+    """Base for the dual-channel members of the MCP4xx1 family."""
+
+    _CHANNELS = 2
+
+
+class MCP4231(MCP4xx1):
+    """MCP4231: two 7-bit volatile channels, codes `0..127`."""
+
+    _RESOLUTION = 7
+    _POT_CLASS = _BDMCP4231
+
+
+class MCP4241(MCP4xx1):
+    """MCP4241: two 7-bit channels, codes `0..127`.
+
+    The part keeps a non-volatile wiper value, but this package has no commit
+    path, so only the volatile register is written.
+    """
+
+    _RESOLUTION = 7
+    _POT_CLASS = _BDMCP4241
+
+
+class MCP4251(MCP4xx1):
+    """MCP4251: two 8-bit volatile channels, codes `0..255`."""
+
+    _RESOLUTION = 8
+    _POT_CLASS = _BDMCP4251
+
+
+class MCP4261(MCP4xx1):
+    """MCP4261: two 8-bit channels, codes `0..255`.
+
+    The part keeps a non-volatile wiper value, but this package has no commit
+    path, so only the volatile register is written.
+    """
+
+    _RESOLUTION = 8
+    _POT_CLASS = _BDMCP4261

scietex/hal/dac/mcp4xxx/mcp4xxx.py

@@ -0,0 +1,135 @@
+"""MCP4xxx digital potentiometers exposed as DAC divider channels."""
+
+from typing import Any, cast
+
+from scietex.hal.spi import SpiTransport
+
+from ..__helpers import check_grounded, check_reference
+from ..channel import DACChannel, DividerChannel
+from ..dac import DAC
+
+
+class MCP4xxxChannel(DividerChannel):
+    """One wiper of an MCP4xxx potentiometer, wired as a grounded divider."""
+
+    def _read_code(self) -> int:
+        """Read the wiper register; the wrapped device owns the frame format."""
+        return cast("MCP4xxx", self._dac).device.get_value(self.index)
+
+    def _write_code(self, code: int) -> int:
+        """Write the wiper register and return the code read back."""
+        return cast("MCP4xxx", self._dac).device.set_value(self.index, code)
+
+
+class MCP4xxx(DAC):
+    """
+    Base class for the dual-channel MCP4xxx digital potentiometers.
+
+    The device composes a `BDPotentiometer` part instead of subclassing it:
+    the wrapped object is built first, because it opens the bus and reads every
+    wiper register during construction, and is then handed to the DAC layer as
+    the backend. `reference` and `grounded` are validated before the wrapped
+    part is built, so a rejected keyword never touches the bus.
+
+    The chip classes narrow the raw code to `2**bits - 1`: the pot model counts
+    `2**bits` steps, but code `2**bits` is never written, so the top code is
+    127 on a 7-bit part and 255 on an 8-bit part.
+    """
+
+    _RESOLUTION: int
+    _POT_CLASS: type[Any]
+    _CHANNEL_CLASS = MCP4xxxChannel
+
+    def __init__(  # noqa: PLR0913
+        self,
+        r_ab: float = 10e3,
+        channels: int | None = None,
+        *,
+        reference: float | None = None,
+        grounded: str = "B",
+        transport: SpiTransport | None = None,
+        spi: SpiTransport | None = None,
+        port: Any = None,
+        device: Any = None,
+        clock_pin: Any = None,
+        mosi_pin: Any = None,
+        miso_pin: Any = None,
+        select_pin: Any = None,
+        label: str | None = None,
+        log_level: int | str | None = None,
+    ) -> None:
+        """
+        Build the potentiometer and expose its wipers as divider channels.
+
+        :param r_ab: Total resistance in ohms; the wrapped part accepts 5k,
+            10k, 50k, and 100k (float).
+        :param channels: Channel count, 1..2; None uses every channel the part
+            provides (int | None).
+        :param reference: Full-scale voltage in volts, or None while unknown
+            (float | None).
+        :param grounded: Terminal tied to ground, `"A"` or `"B"`; grounding B
+            makes the output rise with the code (str).
+        :param transport: Canonical SPI transport, forwarded to the part
+            (SpiTransport | None).
+        :param spi: Legacy alias for `transport`, used when `transport` is
+            None (SpiTransport | None).
+        :param port: spidev bus number, used when no transport is supplied.
+        :param device: spidev chip-select line, used when no transport is
+            supplied.
+        :param clock_pin: GPIO clock pin; any pin keyword selects the gpiozero
+            backend.
+        :param mosi_pin: GPIO MOSI pin; selects the gpiozero backend.
+        :param miso_pin: GPIO MISO pin; selects the gpiozero backend.
+        :param select_pin: GPIO chip-select pin; selects the gpiozero backend.
+        :param label: Logger name, defaults to the class name (str).
+        :param log_level: Logging level such as `logging.DEBUG`; defaults to
+            `logging.ERROR`.
+        :raises TypeError: If `grounded` or `reference` has the wrong type, or
+            if `invert`/`max_value` is passed.
+        :raises ValueError: If `grounded` is not `"A"` or `"B"`, `reference`
+            is not positive, `r_ab` is unsupported, or `label` is empty.
+        :raises ImportError: If the optional package for the selected backend
+            is missing.
+        """
+        self._grounded = check_grounded(grounded)
+        reference = check_reference(reference)
+        self._pot = self._POT_CLASS(
+            r_ab=r_ab,
+            channels=channels,
+            transport=transport,
+            spi=spi,
+            port=port,
+            device=device,
+            clock_pin=clock_pin,
+            mosi_pin=mosi_pin,
+            miso_pin=miso_pin,
+            select_pin=select_pin,
+            invert=False,
+        )
+        try:
+            super().__init__(
+                backend=self._pot,
+                reference=reference,
+                channel_count=len(self._pot.channels),
+                label=label,
+                log_level=log_level,
+            )
+        except BaseException:
+            # The wrapped part owns the bus this constructor opened; release it
+            # when the DAC layer rejects a later keyword.
+            self._pot.close()
+            raise
+
+    @property
+    def grounded(self) -> str:
+        """Terminal tied to ground: `"B"` rises with the code, `"A"` falls."""
+        return self._grounded
+
+    @property
+    def device(self) -> Any:
+        """The wrapped `BDPotentiometer` device, for escape-hatch access."""
+        return self._pot
+
+    def _make_channel(self, index: int) -> DACChannel:
+        """Build a divider channel wired the same way as the device."""
+        return MCP4xxxChannel(self, index, grounded=self._grounded)

scietex/hal/dac/version.py

@@ -0,0 +1,8 @@
+"""
+Module containing the package version information.
+
+Attributes:
+    __version__ (str): The current version of the package.
+"""
+
+__version__ = "0.1.0"

scietex_hal_dac-0.1.0.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: scietex.hal.dac
+Version: 0.1.0
+Summary: Digital-to-analog converters and digital potentiometers
+Author-email: Anton Bondarenko <bond.anton@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 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/scietex.hal.dac
+Project-URL: Bug Tracker, https://github.com/bond-anton/scietex.hal.dac/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: BDPotentiometer<1.0.0,>=0.4.0
+Requires-Dist: scietex.hal.spi<1.0.0,>=0.1.0
+Provides-Extra: spi
+Requires-Dist: scietex.hal.spi[spi]; extra == "spi"
+Provides-Extra: gpiozero
+Requires-Dist: scietex.hal.spi[gpiozero]; extra == "gpiozero"
+Provides-Extra: dev
+Requires-Dist: tox>=4.46.0; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff==0.17.4; extra == "lint"
+Requires-Dist: ty==0.0.99; extra == "lint"
+Dynamic: license-file
+
+# scietex.hal.dac
+
+Digital-to-analog converters: a `DAC` device owns its output channels, and each
+channel converts between a raw code and a scaled output. The package ships the
+Microchip MCP4xx1 dual digital potentiometers, exposed as grounded resistor
+dividers driven over a plain SPI transport.
+
+The abstraction is unit-neutral: the device reference is a full scale in volts
+for a voltage device and in amperes for a current device, and a channel may
+override it. Scaled outputs stay `None` while no reference is configured.
+
+## Parts
+
+| Part | Codes | Wiper storage |
+| --- | --- | --- |
+| MCP4231 | 7-bit, `0..127` | volatile |
+| MCP4241 | 7-bit, `0..127` | non-volatile |
+| MCP4251 | 8-bit, `0..255` | volatile |
+| MCP4261 | 8-bit, `0..255` | non-volatile |
+
+The non-volatile parts keep a wiper value across power cycles, but this package
+has no commit path: only the volatile register is written, exactly as on the
+volatile parts.
+
+## Install
+
+```bash
+pip install scietex.hal.dac[spi]        # Linux spidev backend
+pip install scietex.hal.dac[gpiozero]   # gpiozero backend
+```
+
+The base package installs without either backend. A device built from the
+default keywords needs `spidev`; pin keywords (`clock_pin`, `mosi_pin`,
+`miso_pin`, `select_pin`) need `gpiozero`. A missing backend raises
+`ImportError` naming the extra to install.
+
+## Wiring
+
+| Signal | Connection |
+| --- | --- |
+| SCLK | SPI clock |
+| SDI | SPI MOSI |
+| SDO | SPI MISO |
+| CS | SPI chip select |
+| V_DD | Supply, 2.7 V to 5.5 V |
+| V_SS | Ground |
+
+Each wiper is a three-terminal divider: terminal A and terminal B are the ends
+of the resistor, W is the wiper. One end is tied to ground and the other to the
+reference, so the wiper voltage is a fraction of that reference.
+
+## Usage
+
+```python
+from scietex.hal.dac import MCP4251
+
+device = MCP4251(port=0, device=1, reference=3.3)  # /dev/spidev0.1
+try:
+    code = device.channel(0).value  # raw 8-bit code, 0..255
+    voltage = device.channel(0).voltage
+    print(code, voltage)
+finally:
+    device.close()
+```
+
+`MCP4251(port=0, device=1, reference=3.3)` is also a context manager; leaving the
+`with` block closes the transport:
+
+```python
+with MCP4251(port=0, device=1, reference=3.3) as device:
+    print(device.read_all())
+```
+
+Constructor keywords:
+
+| Keyword | Meaning |
+| --- | --- |
+| `r_ab` | Total resistance in ohms; 5k, 10k, 50k, or 100k (default 10k) |
+| `channels` | Channels to expose, 1..2; omitted uses both |
+| `reference` | Full-scale voltage in volts, or omitted while unknown |
+| `grounded` | Terminal tied to ground, `"B"` (default) or `"A"` |
+| `transport` (alias `spi`) | Any object with `transfer(tx)` and `close()` |
+| `port`, `device` | spidev bus and chip select |
+| `clock_pin`, `mosi_pin`, `miso_pin`, `select_pin` | gpiozero pin wiring |
+| `label`, `log_level` | Logger name and level |
+
+`invert` and `max_value` are not part of the constructor: the wiper is always
+built uninverted, and the code range is fixed by the part. Passing either
+keyword raises `TypeError`.
+
+## Codes and outputs
+
+`channel.value` is the raw code the wiper register holds. It is a live read:
+every access is a new bus transaction, nothing is cached. The range is
+`0..max_code`, which is `127` on a 7-bit part and `255` on an 8-bit part.
+
+`channel.output` scales that code by the reference (grounded B shown here; see
+[Grounding](#grounding)):
+
+```
+output = code / max_code * reference
+```
+
+With no reference configured, `output` is `None` — the library will not guess a
+reference. Setting `device.reference = 3.3` later starts scaling new readings;
+the codes themselves never change. `device.v_ref` and `channel.v_ref` are
+aliases.
+
+The setter clamps instead of rejecting: an output below zero becomes the bottom
+of the scale (code 0 when grounded B) and an output above the reference becomes
+the top code. Setting `output` while no reference is configured raises
+`DACReferenceError`.
+
+## Grounding
+
+`grounded="B"` makes the output rise with the code: code 0 is 0 V, the top code
+is the reference. `grounded="A"` mirrors the curve: code 0 is the reference and
+the top code is 0 V. The raw `value` is the same under either wiring; only the
+scaled `output` changes direction.
+
+## Geometry
+
+| Part | Channels | Resolution | Top code |
+| --- | --- | --- | --- |
+| MCP4231 | 2 | 7 | 127 |
+| MCP4241 | 2 | 7 | 127 |
+| MCP4251 | 2 | 8 | 255 |
+| MCP4261 | 2 | 8 | 255 |
+
+`device.channels` is a tuple in index order and `channel(n)` raises `IndexError`
+outside the range. A part built with `channels=1` exposes channel 0 only.
+
+## Reading and writing
+
+```python
+codes = device.read_all()  # one code per channel
+written = device.write_all((0, 128))
+```
+
+Both return tuples in index order. Every element is a separate bus transaction —
+the calls read and write the device, they do not replay a cached buffer.
+
+A single write is two transactions: the wiper command followed by a register
+read-back, so the value a channel reports afterwards is what the device
+returned, not what the caller submitted. `write_all` validates the whole
+sequence before the first transaction, so a rejected code cannot leave the
+device partially updated.
+
+## Errors
+
+- `TransportError` and `TransportClosed` (from `scietex.hal.spi`) mean the bus
+  transaction failed or the transport was already closed.
+- `DACCodeError` (a `ValueError`) means a raw code is outside `0..max_code`.
+- `DACReferenceError` (a `ValueError`) means an output was requested while no
+  reference is configured.
+- A malformed device answer is rejected by the wrapped potentiometer with a
+  `ValueError` naming the frame.
+
+## Testing
+
+```bash
+pytest                 # unit tests, no hardware needed
+RUN_HARDWARE_TESTS=1 pytest tests/test_hardware.py
+```
+
+The unit tests drive a scripted transport and never open a real bus. The
+hardware test needs an MCP4251 on `/dev/spidev0.1` and is skipped unless
+`RUN_HARDWARE_TESTS=1` is set; CI never enables it.
+
+Other checks:
+
+```bash
+tox -e format,lint,type
+```
+
+## License
+
+This project is licensed under the **MIT License** - see the LICENSE file for
+details.

scietex_hal_dac-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+scietex/hal/dac/__helpers.py,sha256=Z8fNY1ObX66LUjXAIoPwS5gWR4nJ5wfjUS5mMxxU6BU,7084
+scietex/hal/dac/__init__.py,sha256=LFGg3vTgvBdPz4aHQkIkpGzPVhMnS16P2iPmYcRKWo4,588
+scietex/hal/dac/__logger.py,sha256=nti4Iqn7yCDZrarjCE7wDKSC17fZkNnsNYEsNLObrGo,3426
+scietex/hal/dac/channel.py,sha256=bO3kdtYQPHE36wdR7zK9BrJEzLzIXaLyEYrRWS74XKU,10049
+scietex/hal/dac/dac.py,sha256=I_kiSHy4N_aUW-EfWtkJCXmSvQX3z77Xed2iLixGcPE,9137
+scietex/hal/dac/errors.py,sha256=vG3I3L8lroqCEKseYFt6U4Qg2dSHSJmD9Atqj-haWcI,359
+scietex/hal/dac/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scietex/hal/dac/version.py,sha256=-6LRwSS3coyMIQkeofZjGTMXkVG7dm2gwquyq8O_vF0,154
+scietex/hal/dac/mcp4xxx/__init__.py,sha256=IVCUkNOHMiLjzWQvsMRpAKU-wRXn-N-Z_wzukJrXFPU,151
+scietex/hal/dac/mcp4xxx/mcp4xx1.py,sha256=9ryA8ygYktW6q6HY78Rz9jVeI45nKLc8zPiPAc9_oN0,1304
+scietex/hal/dac/mcp4xxx/mcp4xxx.py,sha256=Rcm8ErmmxMStu01aHLCPZAcvkhrsXi8XhRIWWVYjbg0,5351
+scietex_hal_dac-0.1.0.dist-info/licenses/LICENSE,sha256=Kv8K8tNh4XWlpCNncypg7EhUWm4drfJp0zCGNsrp6So,1072
+scietex_hal_dac-0.1.0.dist-info/METADATA,sha256=j49E88O-ihrX5kLX1vxcDZxYOd_IxCzZXjZC9cFh774,8494
+scietex_hal_dac-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+scietex_hal_dac-0.1.0.dist-info/top_level.txt,sha256=AyNTe2f94XrlwxyUGMuitoEj6mqEacwNkt8nU47GjvI,8
+scietex_hal_dac-0.1.0.dist-info/RECORD,,

scietex_hal_dac-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

scietex_hal_dac-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 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.

scietex_hal_dac-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+scietex