lvbitpack 1.0.0__py3-none-any.whl

lvbitpack/__init__.py

@@ -0,0 +1,60 @@
+"""LabVIEW Boolean arrays in Python: Boolean Array To Number, its inverse, and flattening.
+
+>>> import lvbitpack
+>>> lvbitpack.bools_to_number([False, True], lvbitpack.I8)
+-2
+>>> from lvbitpack import I8, I16, I32, I64, U8, U16, U32, U64
+>>> [t.name for t in (U8, U16, U32, U64, I8, I16, I32, I64)]
+['u8', 'u16', 'u32', 'u64', 'i8', 'i16', 'i32', 'i64']
+"""
+
+from ._bytes import bools_to_bytes, bytes_to_bools, bytes_to_number, number_to_bytes
+from ._errors import BitpackError
+from ._flatten import pack_flattened, unpack_flattened
+from ._modes import SignExtension
+from ._number import bools_to_number, number_to_bools
+from ._pack import pack_bools, unpack_bools
+from ._types import I8, I16, I32, I64, U8, U16, U32, U64, IntType
+
+__version__ = "1.0.0"
+
+# Functions show lvbitpack as their module in help(); classes keep their real module so
+# that inspect.getsource and pickles find them where they are defined.
+for _public in (
+    bools_to_bytes,
+    bools_to_number,
+    bytes_to_bools,
+    bytes_to_number,
+    number_to_bools,
+    number_to_bytes,
+    pack_bools,
+    pack_flattened,
+    unpack_bools,
+    unpack_flattened,
+):
+    _public.__module__ = __name__
+del _public
+
+__all__ = [
+    "I8",
+    "I16",
+    "I32",
+    "I64",
+    "U8",
+    "U16",
+    "U32",
+    "U64",
+    "BitpackError",
+    "IntType",
+    "SignExtension",
+    "bools_to_bytes",
+    "bools_to_number",
+    "bytes_to_bools",
+    "bytes_to_number",
+    "number_to_bools",
+    "number_to_bytes",
+    "pack_bools",
+    "pack_flattened",
+    "unpack_bools",
+    "unpack_flattened",
+]

lvbitpack/__main__.py

@@ -0,0 +1,7 @@
+"""Run the command line interface with ``python -m lvbitpack``."""
+
+from __future__ import annotations
+
+from ._cli import main
+
+raise SystemExit(main())

lvbitpack/_bytes.py

@@ -0,0 +1,96 @@
+"""Fixed-width bytes for the numbers Boolean Array To Number produces.
+
+The element to bit mapping (element 0 is the least significant bit) never depends on byte
+order; byte order only lays the finished integer out across its bytes. The default is
+big-endian, the order of LabVIEW's Flatten To String and Type Cast.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Literal, SupportsIndex
+
+from ._errors import BitpackError, Buffer, as_buffer, as_int, plain_str, quote
+from ._modes import SignExtension
+from ._number import bools_to_number, number_to_bools
+from ._types import IntType, check_type
+
+ByteOrder = Literal["big", "little"]
+
+
+def _check_order(byteorder: object) -> Literal["big", "little"]:
+    text = plain_str(byteorder)
+    if text == "big":
+        return "big"
+    if text == "little":
+        return "little"
+    raise BitpackError(f"byteorder must be 'big' or 'little', not {quote(byteorder)}")
+
+
+def number_to_bytes(
+    number: SupportsIndex, int_type: IntType, *, byteorder: ByteOrder = "big"
+) -> bytes:
+    """The ``int_type.bits // 8`` bytes of ``number``, big-endian unless told otherwise.
+
+    >>> from lvbitpack import I16, number_to_bytes
+    >>> number_to_bytes(-2, I16), number_to_bytes(-2, I16, byteorder="little")
+    (b'\\xff\\xfe', b'\\xfe\\xff')
+    """
+    int_type = check_type(int_type)
+    order = _check_order(byteorder)
+    value = as_int(number, "number")
+    if not int_type.contains(value):
+        raise BitpackError(
+            f"{quote(value)} is out of range for {int_type.name} [{int_type.min}, {int_type.max}]"
+        )
+    return value.to_bytes(int_type.bits // 8, order, signed=int_type.signed)
+
+
+def bytes_to_number(data: Buffer, int_type: IntType, *, byteorder: ByteOrder = "big") -> int:
+    """Read a number from exactly ``int_type.bits // 8`` bytes.
+
+    ``data`` is any buffer-protocol object (``bytes``, ``bytearray``, ``memoryview``,
+    ``array.array``, NumPy arrays), read as its raw bytes in memory order.
+
+    >>> from lvbitpack import I16, U16, bytes_to_number
+    >>> bytes_to_number(b"\\xff\\xfe", I16), bytes_to_number(b"\\xff\\xfe", U16)
+    (-2, 65534)
+    """
+    int_type = check_type(int_type)
+    order = _check_order(byteorder)
+    raw = as_buffer(data)
+    width = int_type.bits // 8
+    if len(raw) != width:
+        unit = "byte" if width == 1 else "bytes"
+        raise BitpackError(f"{int_type.name} needs exactly {width} {unit}, got {len(raw)}")
+    return int.from_bytes(raw, order, signed=int_type.signed)
+
+
+def bools_to_bytes(
+    values: Iterable[bool | int],
+    int_type: IntType,
+    *,
+    sign_extension: SignExtension = SignExtension.IF_SIGNED,
+    byteorder: ByteOrder = "big",
+) -> bytes:
+    """``bools_to_number`` followed by ``number_to_bytes``.
+
+    >>> from lvbitpack import U16, bools_to_bytes
+    >>> bools_to_bytes([False, True], U16), bools_to_bytes([False, True], U16, byteorder="little")
+    (b'\\x00\\x02', b'\\x02\\x00')
+    """
+    int_type = check_type(int_type)
+    order = _check_order(byteorder)
+    number = bools_to_number(values, int_type, sign_extension=sign_extension)
+    return number_to_bytes(number, int_type, byteorder=order)
+
+
+def bytes_to_bools(data: Buffer, int_type: IntType, *, byteorder: ByteOrder = "big") -> list[bool]:
+    """``bytes_to_number`` followed by ``number_to_bools``; element 0 is the low bit.
+
+    >>> from lvbitpack import U16, bytes_to_bools
+    >>> bytes_to_bools(b"\\x00\\x02", U16)[:3]
+    [False, True, False]
+    """
+    number = bytes_to_number(data, int_type, byteorder=byteorder)
+    return number_to_bools(number, int_type)

lvbitpack/_cli.py

@@ -0,0 +1,154 @@
+"""Command line interface: Boolean arrays to numbers and flattened bytes, and back."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+
+from . import __version__
+from ._cli_io import MESSAGE_LIMIT, Parser, finish, write
+from ._errors import BitpackError, quote
+from ._flatten import pack_flattened, unpack_flattened
+from ._modes import SignExtension
+from ._number import bools_to_number, number_to_bools
+from ._types import IntType
+
+_TRUE, _FALSE, _SKIP = frozenset("1tT"), frozenset("0fF"), frozenset(" ,_")
+_NUMBER_LIMIT = 100  # characters; a 64-bit value never needs more
+
+_EXAMPLES = """\
+examples:
+  lvbitpack pack 01 --type u8                    -> 2
+  lvbitpack pack 01 --type i8                    -> -2
+  lvbitpack pack 0101 --type i8 -s never         -> 10
+  lvbitpack pack 0101 --type i8 -s always        -> -6
+  lvbitpack pack 01 --type i8 --base hex         -> 0xfe
+  lvbitpack unpack 2 --type u8                   -> 01000000
+  lvbitpack unpack -2 --type i8                  -> 01111111
+  lvbitpack flatten 1011                         -> 0000000401000101
+  lvbitpack unflatten 0000000401000101           -> 1011
+
+Bit strings list element 0 first; element 0 is the least significant bit of the number.
+1/t/T is TRUE, 0/f/F is FALSE; spaces, commas and underscores are ignored. flatten prints
+LabVIEW's Flatten To String bytes of the Boolean array as hex. Data errors print to stderr
+and exit 1; usage errors exit 2.
+"""
+
+
+def _bits(text: str) -> list[bool]:
+    bits: list[bool] = []
+    for position, char in enumerate(text):
+        if char in _SKIP:
+            continue
+        if char in _TRUE or char in _FALSE:
+            bits.append(char in _TRUE)
+        else:
+            raise BitpackError(f"character {position} is {quote(char)}; use 0/1, f/t or F/T")
+    return bits
+
+
+def _number(text: str) -> int:
+    if len(text) > _NUMBER_LIMIT:
+        raise BitpackError(f"the number has {len(text)} characters; at most 100 are read")
+    try:
+        if not text.isascii():  # int() would also read other scripts' digits
+            raise ValueError(text)
+        return int(text, 0)
+    except ValueError:
+        raise BitpackError(f"not an integer: {quote(text)}") from None
+
+
+def _hex(text: str) -> bytes:
+    cleaned = text.strip().removeprefix("0x").removeprefix("0X").replace("_", "")
+    try:
+        return bytes.fromhex(cleaned)
+    except ValueError:
+        raise BitpackError(f"not valid hex: {quote(text)}") from None
+
+
+def _int_type(text: str) -> IntType:
+    try:
+        return IntType.parse(text)
+    except BitpackError as error:
+        raise argparse.ArgumentTypeError(str(error)) from None
+
+
+def _show(bits: list[bool]) -> str:
+    return "".join("1" if bit else "0" for bit in bits)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = Parser(
+        prog="lvbitpack",
+        description="LabVIEW Boolean Array To Number, Number To Boolean Array and flattening.",
+        epilog=_EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version=f"lvbitpack {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+    types = "u8, u16, u32, u64, i8, i16, i32 or i64"
+
+    pack = sub.add_parser("pack", help="Boolean array to number")
+    pack.add_argument("bits", help="bit string, element 0 (the LSB) first, e.g. 01 or 0,1")
+    pack.add_argument("--type", "-t", required=True, type=_int_type, help=f"integer type: {types}")
+    pack.add_argument(
+        "--sign-extension",
+        "-s",
+        choices=[mode.value for mode in SignExtension],
+        default=SignExtension.IF_SIGNED.value,
+        help="padding of a short array (default: if_signed, LabVIEW's default)",
+    )
+    pack.add_argument("--base", choices=["dec", "hex"], default="dec", help="output base")
+
+    unpack = sub.add_parser("unpack", help="number to Boolean array")
+    unpack.add_argument("number", help="integer: decimal, or 0x/0o/0b prefixed")
+    unpack.add_argument(
+        "--type", "-t", required=True, type=_int_type, help=f"integer type: {types}"
+    )
+
+    flatten = sub.add_parser("flatten", help="Boolean array to LabVIEW flattened bytes (hex)")
+    flatten.add_argument("bits", help="bit string, element 0 first")
+    unflatten = sub.add_parser("unflatten", help="LabVIEW flattened bytes (hex) to bit string")
+    unflatten.add_argument("hex", help="the flattened bytes as hex")
+    return parser
+
+
+def _run(args: argparse.Namespace) -> str:
+    if args.command == "pack":
+        int_type = args.type
+        mode = SignExtension(args.sign_extension)
+        number = bools_to_number(_bits(args.bits), int_type, sign_extension=mode)
+        return f"0x{number & int_type.mask:x}" if args.base == "hex" else str(number)
+    if args.command == "unpack":
+        int_type = args.type
+        return _show(number_to_bools(_number(args.number), int_type))
+    if args.command == "flatten":
+        return pack_flattened(_bits(args.bits)).hex()
+    return _show(unpack_flattened(_hex(args.hex)))
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Entry point for the ``lvbitpack`` console command.
+
+    Exit codes: 0 done, 1 bad data (or the reader of the output went away), 2 bad usage.
+
+    >>> from lvbitpack._cli import main
+    >>> main(["pack", "01", "--type", "i8"])
+    -2
+    0
+    """
+    parser = _build_parser()
+    try:
+        args = parser.parse_args(argv)
+    except SystemExit as stop:
+        return stop.code if isinstance(stop.code, int) else 2
+    try:
+        output = _run(args)
+    except BitpackError as error:
+        write("stderr", f"lvbitpack: error: {str(error)[:MESSAGE_LIMIT]}\n")
+        return finish(1)
+    return finish(0 if write("stdout", output + "\n") else 1)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

lvbitpack/_cli_io.py

@@ -0,0 +1,83 @@
+"""Command line plumbing: bounded usage errors and quiet exits when a pipe goes away."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import sys
+from typing import TYPE_CHECKING, Any, NoReturn
+
+from ._text import printable
+
+if TYPE_CHECKING:
+    from _typeshed import SupportsWrite
+
+# Usage and data error messages are cut here, so a huge argument is never echoed back.
+MESSAGE_LIMIT = 300
+
+
+def silence(stream: object) -> None:
+    """Point ``stream``'s descriptor at the null device after its reader went away.
+
+    Python flushes the streams at exit; on a closed pipe that flush fails and the process
+    exits 120 with a warning. Redirecting the descriptor makes every later write succeed.
+    Only the failing stream is touched.
+    """
+    try:
+        fd = stream.fileno()  # type: ignore[attr-defined]
+    except (AttributeError, OSError, ValueError):
+        return
+    null = os.open(os.devnull, os.O_WRONLY)
+    if null != fd:  # a closed fd is reused by open(): then it already is the null device
+        os.dup2(null, fd)
+        os.close(null)
+
+
+def finish(code: int) -> int:
+    """Flush both streams and return ``code``; a stream whose reader left is silenced."""
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.flush()
+        except (AttributeError, OSError, ValueError):
+            silence(stream)
+    return code
+
+
+def write(stream_name: str, text: str) -> bool:
+    """Write ``text`` to stdout or stderr; return False when the reader went away."""
+    stream = sys.stdout if stream_name == "stdout" else sys.stderr
+    try:
+        stream.write(text)  # every message is printable ASCII, so any stream can encode it
+        stream.flush()
+    except (AttributeError, OSError, ValueError):
+        silence(stream)
+        return False
+    return True
+
+
+class Parser(argparse.ArgumentParser):
+    """An argument parser whose errors are bounded and survive a closed stderr."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        # Before Python 3.14 only -<digits> counted as a negative number, so -0x2 or -1_0
+        # were taken for options; read any dash followed by a digit as a value.
+        self._negative_number_matcher = re.compile(r"^-\.?\d")
+
+    def error(self, message: str) -> NoReturn:
+        message = printable(message)
+        if len(message) > MESSAGE_LIMIT:
+            message = message[:MESSAGE_LIMIT] + "..."
+        self.exit(2, f"{self.format_usage()}{self.prog}: error: {message}\n")
+
+    lost_output = False  # set on the instance when help or version text could not be written
+
+    def exit(self, status: int = 0, message: str | None = None) -> NoReturn:
+        if message:
+            write("stderr", message)
+        raise SystemExit(finish(1 if status == 0 and self.lost_output else status))
+
+    def _print_message(self, message: str, file: SupportsWrite[str] | None = None) -> None:
+        if message and not write("stderr" if file is sys.stderr else "stdout", message):
+            self.lost_output = True

lvbitpack/_errors.py

@@ -0,0 +1,138 @@
+"""The library's error type and the input checks every public function shares.
+
+Every check looks at ``type(value)``, never at ``value.__class__``, so an object that lies
+about its class (or whose attribute lookup fails) cannot slip past or raise its own error.
+"""
+
+from __future__ import annotations
+
+import operator
+import re
+from collections.abc import Iterable
+from typing import Protocol
+
+from ._text import plain_str, quote, type_name
+
+__all__ = ["BitpackError", "Buffer", "as_bool", "as_bools", "as_buffer", "as_int"]
+__all__ += ["is_integer", "numpy_bool", "plain_str", "quote", "type_name"]
+
+_NUMPY_BOOL_NAMES = frozenset({"bool", "bool_"})
+_BYTE_STRINGS = (bytes, bytearray, memoryview)
+_FIELD_NAME = re.compile(r":[^:]*:")  # struct-format field names, which may contain an O
+
+
+class Buffer(Protocol):
+    """Any object with the buffer protocol: bytes, bytearray, memoryview, array, NumPy."""
+
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+
+
+class BitpackError(ValueError):
+    """Raised for any input lvbitpack refuses: a bad value, a bad type or a bad size.
+
+    It subclasses ``ValueError``, so ``except ValueError`` keeps working.
+
+    >>> from lvbitpack import BitpackError, U8, number_to_bools
+    >>> try:
+    ...     number_to_bools(256, U8)
+    ... except BitpackError as error:
+    ...     print(error)
+    256 is out of range for u8 [0, 255]
+    """
+
+
+def is_integer(value: object) -> bool:
+    """Whether ``value``'s type has ``__index__`` and is not ``bool``."""
+    kind = type(value)
+    if kind is bool or numpy_bool(value) is not None:
+        return False
+    try:
+        return hasattr(kind, "__index__")
+    except Exception:  # a metaclass whose attribute lookup fails
+        return False
+
+
+def as_int(value: object, what: str) -> int:
+    """``value`` as a plain ``int``; ``bool`` and non-integers are refused."""
+    if type(value) is bool or numpy_bool(value) is not None:
+        raise BitpackError(f"{what} must be an integer, not bool")
+    try:
+        return int(operator.index(value))  # type: ignore[arg-type]
+    except TypeError:
+        raise BitpackError(f"{what} must be an integer, not {type_name(value)}") from None
+
+
+def numpy_bool(value: object) -> bool | None:
+    """The truth of a NumPy boolean scalar, or None when ``value`` is not one."""
+    kind = type(value)
+    try:
+        module = type.__dict__["__module__"].__get__(kind, type)
+    except Exception:
+        return None
+    if type_name(value) not in _NUMPY_BOOL_NAMES or type(module) is not str:
+        return None
+    if module != "numpy" and not module.startswith("numpy."):
+        return None
+    try:
+        truth = bool(value)
+    except Exception:
+        return None
+    return truth
+
+
+def as_bool(value: object, index: int) -> bool:
+    """One array element as a ``bool``: True/False, 0/1, or a NumPy boolean."""
+    kind = type(value)
+    if kind is bool:
+        return value  # type: ignore[return-value]
+    if kind is int:  # the common 0/1 case, before the slower checks
+        if value in (0, 1):
+            return value == 1
+        raise BitpackError(
+            f"element {index} must be a boolean (True/False or 0/1), not {quote(value)}"
+        )
+    truth = numpy_bool(value)
+    if truth is not None:
+        return truth
+    try:
+        number = int(operator.index(value))  # type: ignore[arg-type]
+    except TypeError:
+        number = None
+    if number in (0, 1):
+        return number == 1
+    raise BitpackError(f"element {index} must be a boolean (True/False or 0/1), not {quote(value)}")
+
+
+def as_bools(values: Iterable[object]) -> list[bool]:
+    """A finite iterable of booleans as a list; text and byte strings are refused."""
+    kind = type(values)
+    if issubclass(kind, (str, *_BYTE_STRINGS)):
+        what = "a string" if issubclass(kind, str) else "a byte string"
+        raise BitpackError(
+            f"values must be an iterable of booleans, not {type_name(values)}; "
+            f"{what} is not a Boolean array"
+        )
+    try:
+        items = iter(values)
+    except TypeError:
+        raise BitpackError(
+            f"values must be an iterable of booleans, not {type_name(values)}"
+        ) from None
+    return [as_bool(item, index) for index, item in enumerate(items)]
+
+
+def as_buffer(data: object, what: str = "data") -> bytes:
+    """The raw bytes of any buffer-protocol object; text and everything else is refused."""
+    if not issubclass(type(data), str):
+        try:
+            with memoryview(data) as view:  # type: ignore[arg-type]
+                if "O" in _FIELD_NAME.sub("", view.format):  # object pointers are not data
+                    raise BitpackError(f"{what} holds Python objects, not bytes")
+                return view.tobytes()  # raw bytes in memory order, any item format
+        except TypeError:
+            pass
+        except BitpackError:
+            raise
+        except ValueError:  # a released view, or a buffer of a kind Python cannot export
+            raise BitpackError(f"{what} cannot be read as bytes ({type_name(data)})") from None
+    raise BitpackError(f"{what} must be a bytes-like object, not {type_name(data)}")

lvbitpack/_flatten.py

@@ -0,0 +1,56 @@
+"""LabVIEW's flattened form of a 1-D Boolean array: an I32 count, then one byte per element.
+
+This is what Flatten To String writes for a Boolean array (and what front-panel datalogs
+hold): the count is big-endian, TRUE is written as 0x01 and FALSE as 0x00, and on reading
+any nonzero byte is TRUE.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from ._errors import BitpackError, Buffer, as_bools, as_buffer
+
+_HEADER = 4
+_MAX_COUNT = 0x7FFFFFFF
+
+
+def _follow(count: int) -> str:
+    return "1 byte follows" if count == 1 else f"{count} bytes follow"
+
+
+def pack_flattened(values: Iterable[bool | int]) -> bytes:
+    """Flatten a 1-D Boolean array the way LabVIEW's Flatten To String does.
+
+    >>> from lvbitpack import pack_flattened
+    >>> pack_flattened([True, False, True, True]).hex()
+    '0000000401000101'
+    """
+    bits = as_bools(values)
+    if len(bits) > _MAX_COUNT:
+        raise BitpackError(f"a LabVIEW array holds at most {_MAX_COUNT} elements")
+    return len(bits).to_bytes(_HEADER, "big") + bytes(bits)
+
+
+def unpack_flattened(data: Buffer) -> list[bool]:
+    """Read a flattened 1-D Boolean array: the I32 count, then exactly that many bytes.
+
+    Any nonzero element byte is TRUE. A negative count, missing bytes or bytes left over
+    after the last element raise ``BitpackError``.
+
+    >>> from lvbitpack import unpack_flattened
+    >>> unpack_flattened(bytes.fromhex("0000000401000101"))
+    [True, False, True, True]
+    """
+    raw = as_buffer(data)
+    if len(raw) < _HEADER:
+        raise BitpackError(f"a flattened array starts with a 4-byte count; got {len(raw)} bytes")
+    count = int.from_bytes(raw[:_HEADER], "big", signed=True)
+    if count < 0:
+        raise BitpackError(f"the element count is negative ({count})")
+    body = len(raw) - _HEADER
+    if body < count:
+        raise BitpackError(f"the count says {count} elements but only {_follow(body)}")
+    if body > count:
+        raise BitpackError(f"{_follow(body - count)} the last of the {count} elements")
+    return [byte != 0 for byte in raw[_HEADER:]]

lvbitpack/_modes.py

@@ -0,0 +1,49 @@
+"""The sign extension modes of Boolean Array To Number."""
+
+from __future__ import annotations
+
+import enum
+from typing import Any
+
+from ._errors import BitpackError, plain_str, quote
+
+
+class _ModeLookup(enum.EnumMeta):
+    """Looks a mode up by its exact text, and refuses anything else with ``BitpackError``.
+
+    The standard lookup hashes the value and prints its repr before asking ``_missing_``,
+    so a huge integer or a hostile object would raise its own error instead of ours.
+    """
+
+    def __call__(cls, value: Any, *args: Any, **kwargs: Any) -> Any:
+        if args or kwargs:  # the functional API cannot extend an enum that has members
+            raise BitpackError("SignExtension takes exactly one value")
+        if type(value) is cls:
+            return value
+        text = plain_str(value)
+        for member in cls:  # type: ignore[var-annotated]
+            if text is not None and member.value == text:
+                return member
+        raise BitpackError(f"no sign extension mode {quote(value)}; use never, if_signed or always")
+
+
+class SignExtension(enum.Enum, metaclass=_ModeLookup):
+    """How Boolean Array To Number pads an array shorter than the integer width.
+
+    LabVIEW sets this by right-clicking the node; ``IF_SIGNED`` is LabVIEW's default.
+
+    - ``NEVER``: pad with FALSE.
+    - ``IF_SIGNED``: pad unsigned outputs with FALSE and signed outputs with the last element.
+    - ``ALWAYS``: pad with the last element.
+
+    >>> from lvbitpack import I8, SignExtension, bools_to_number
+    >>> array = [False, True, False, True]
+    >>> [bools_to_number(array, I8, sign_extension=mode) for mode in SignExtension]
+    [10, -6, -6]
+    >>> SignExtension("always")
+    <SignExtension.ALWAYS: 'always'>
+    """
+
+    NEVER = "never"
+    IF_SIGNED = "if_signed"
+    ALWAYS = "always"

lvbitpack/_number.py

@@ -0,0 +1,88 @@
+"""LabVIEW's Boolean Array To Number and Number To Boolean Array for integer outputs.
+
+Element 0 of the array is the least significant bit. The bits map straight onto one
+fixed-width integer; there is no count and no byte per element, unlike a flattened array.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import SupportsIndex
+
+from ._errors import BitpackError, as_bools, as_int, quote
+from ._modes import SignExtension
+from ._types import IntType, check_type
+
+
+def _check_mode(mode: object) -> SignExtension:
+    if type(mode) is not SignExtension:
+        raise BitpackError(f"sign_extension must be a SignExtension, not {quote(mode)}")
+    return mode
+
+
+def _pad_bit(bits: list[bool], int_type: IntType, mode: SignExtension) -> int:
+    """The bit that fills every position above the supplied elements."""
+    if mode is SignExtension.NEVER or not bits:
+        return 0
+    if mode is SignExtension.IF_SIGNED and not int_type.signed:
+        return 0
+    return 1 if bits[-1] else 0
+
+
+def bools_to_number(
+    values: Iterable[bool | int],
+    int_type: IntType,
+    *,
+    sign_extension: SignExtension = SignExtension.IF_SIGNED,
+) -> int:
+    """Convert a Boolean array to an integer, as LabVIEW's Boolean Array To Number does.
+
+    Element 0 is the least significant bit. Elements beyond the width are dropped; a short
+    array is padded as ``sign_extension`` says (LabVIEW's default is ``IF_SIGNED``). A signed
+    type gives the two's complement value. ``values`` is any finite iterable of
+    ``True``/``False``, ``0``/``1`` or NumPy booleans; a string is refused.
+
+    >>> from lvbitpack import I8, U8, SignExtension, bools_to_number
+    >>> bools_to_number([False, True], U8), bools_to_number([False, True], I8)
+    (2, -2)
+    >>> bools_to_number([False, False, True, False, True], U8, sign_extension=SignExtension.ALWAYS)
+    244
+    >>> bools_to_number([True] * 9, U8)
+    255
+    """
+    int_type = check_type(int_type)
+    mode = _check_mode(sign_extension)
+    bits = as_bools(values)
+    width = int_type.bits
+    raw = 0
+    for index, bit in enumerate(bits[:width]):
+        if bit:
+            raw |= 1 << index
+    if len(bits) < width and _pad_bit(bits, int_type, mode):
+        raw |= int_type.mask ^ ((1 << len(bits)) - 1)
+    if int_type.signed and raw > int_type.max:
+        raw -= 1 << width
+    return raw
+
+
+def number_to_bools(number: SupportsIndex, int_type: IntType) -> list[bool]:
+    """Convert an integer to a Boolean array, as LabVIEW's Number To Boolean Array does.
+
+    The result has one element per bit of the type (8, 16, 32 or 64); element 0 holds the
+    least significant bit of the two's complement form. ``number`` must fit the type: LabVIEW
+    would have coerced it to the wire's type first, so a value outside it is refused.
+
+    >>> from lvbitpack import I8, U8, number_to_bools
+    >>> number_to_bools(2, U8)
+    [False, True, False, False, False, False, False, False]
+    >>> number_to_bools(-2, I8) == [False] + [True] * 7
+    True
+    """
+    int_type = check_type(int_type)
+    value = as_int(number, "number")
+    if not int_type.contains(value):
+        raise BitpackError(
+            f"{quote(value)} is out of range for {int_type.name} [{int_type.min}, {int_type.max}]"
+        )
+    raw = value & int_type.mask
+    return [bool((raw >> index) & 1) for index in range(int_type.bits)]

lvbitpack/_pack.py

@@ -0,0 +1,72 @@
+"""Compact bit packing of Boolean arrays: eight elements per byte, no header.
+
+LabVIEW itself stores a Boolean as one byte; this is the dense form for wire protocols,
+register maps and files that want one bit per element.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Literal, SupportsIndex
+
+from ._errors import BitpackError, Buffer, as_bools, as_buffer, as_int, plain_str, quote
+
+BitOrder = Literal["msb", "lsb"]
+
+
+def _check_order(bit_order: object) -> bool:
+    """True for least-significant-bit first."""
+    text = plain_str(bit_order)
+    if text in ("msb", "lsb"):
+        return text == "lsb"
+    raise BitpackError(f"bit_order must be 'msb' or 'lsb', not {quote(bit_order)}")
+
+
+def pack_bools(values: Iterable[bool | int], *, bit_order: BitOrder = "msb") -> bytes:
+    """Pack Booleans eight to a byte, zero-filling the unused bits of the last byte.
+
+    With ``bit_order="msb"`` (default) element 0 is bit 7 (0x80) of byte 0. With ``"lsb"``
+    element 0 is bit 0 of byte 0, so each byte equals Boolean Array To Number of its eight
+    elements as a U8.
+
+    >>> from lvbitpack import pack_bools
+    >>> array = [True, True, False, True]
+    >>> pack_bools(array), pack_bools(array, bit_order="lsb")
+    (b'\\xd0', b'\\x0b')
+    """
+    lsb = _check_order(bit_order)
+    bits = as_bools(values)
+    out = bytearray((len(bits) + 7) // 8)
+    for index, bit in enumerate(bits):
+        if bit:
+            shift = index % 8 if lsb else 7 - index % 8
+            out[index // 8] |= 1 << shift
+    return bytes(out)
+
+
+def unpack_bools(
+    data: Buffer, count: SupportsIndex | None = None, *, bit_order: BitOrder = "msb"
+) -> list[bool]:
+    """Unpack ``count`` Booleans (default: every bit) from bytes written by ``pack_bools``.
+
+    ``count`` drops the fill bits of the last byte; it must be between 0 and ``8 * len(data)``.
+    The fill bits are not checked.
+
+    >>> from lvbitpack import unpack_bools
+    >>> unpack_bools(b"\\xd0", 4)
+    [True, True, False, True]
+    >>> unpack_bools(b"\\x0b", 4, bit_order="lsb")
+    [True, True, False, True]
+    """
+    lsb = _check_order(bit_order)
+    raw = as_buffer(data)
+    total = len(raw) * 8
+    wanted = total if count is None else as_int(count, "count")
+    if wanted < 0:
+        raise BitpackError(f"count must not be negative, got {quote(wanted)}")
+    if wanted > total:
+        raise BitpackError(f"count is {quote(wanted)}, more than the {total} bits in data")
+    return [
+        bool(raw[index // 8] >> (index % 8 if lsb else 7 - index % 8) & 1)
+        for index in range(wanted)
+    ]

lvbitpack/_text.py

@@ -0,0 +1,63 @@
+"""Safe text for error messages: short and printable ASCII, whatever the object does."""
+
+from __future__ import annotations
+
+import reprlib
+
+# Values quoted in messages are cut to this many characters, so huge input is never echoed.
+_QUOTE_LIMIT = 40
+
+
+class _ShortRepr(reprlib.Repr):
+    """``reprlib`` with byte strings cut before their repr is built."""
+
+    def repr_bytes(self, value: bytes, level: int) -> str:
+        return repr(bytes(value[: self.maxstring]))
+
+    def repr_bytearray(self, value: bytearray, level: int) -> str:
+        return repr(bytearray(value[: self.maxstring]))
+
+
+_REPR = _ShortRepr()
+_REPR.maxstring = _REPR.maxother = _QUOTE_LIMIT + 10
+_REPR.maxlist = _REPR.maxtuple = _REPR.maxdict = _REPR.maxset = 4
+
+
+def printable(text: str) -> str:
+    """``text`` with control characters and non-ASCII escaped, so it cannot drive a terminal."""
+    return "".join(
+        char if " " <= char <= "~" else char.encode("unicode_escape").decode("ascii")
+        for char in text
+    )
+
+
+def _cut(text: str) -> str:
+    text = printable(text)
+    return text if len(text) <= _QUOTE_LIMIT else text[:_QUOTE_LIMIT] + "..."
+
+
+def type_name(value: object) -> str:
+    """The type name of ``value``, cut for messages; a metaclass cannot change it."""
+    try:
+        name = type.__dict__["__name__"].__get__(type(value), type)
+        return _cut(str.__str__(name))
+    except Exception:
+        return "object"
+
+
+def quote(value: object) -> str:
+    """A short, safe, printable description of ``value`` for an error message."""
+    try:
+        if issubclass(type(value), int) and type(value) is not bool:
+            size = int.bit_length(value)  # type: ignore[arg-type]  # a subclass cannot lie
+            if size > 128:
+                return f"an integer of {size} bits"
+            return int.__repr__(value)
+        return _cut(str.__str__(_REPR.repr(value)))
+    except Exception:  # a hostile object must not replace our error with its own
+        return f"<{type_name(value)} object>"
+
+
+def plain_str(value: object) -> str | None:
+    """``value`` as an exact ``str`` without calling a subclass's methods, else None."""
+    return str.__str__(value) if issubclass(type(value), str) else None

lvbitpack/_types.py

@@ -0,0 +1,150 @@
+"""The integer representations and the sign extension modes of Boolean Array To Number."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ._errors import BitpackError, as_int, is_integer, numpy_bool, plain_str, quote, type_name
+
+_VALID_BITS = (8, 16, 32, 64)
+_PREFIXES = (("uint", False), ("int", True), ("u", False), ("i", True))
+
+
+@dataclass(frozen=True)
+class IntType:
+    """A LabVIEW integer representation: 8, 16, 32 or 64 bits, signed or unsigned.
+
+    ``U8`` to ``I64`` are ready-made; equal types compare and hash equal.
+
+    >>> from lvbitpack import IntType, U16
+    >>> IntType(16, False) == U16
+    True
+    >>> from lvbitpack import BitpackError
+    >>> try:
+    ...     IntType(12, False)
+    ... except BitpackError as error:
+    ...     print(error)
+    bits must be 8, 16, 32 or 64, not 12
+    """
+
+    bits: int
+    signed: bool
+
+    def __post_init__(self) -> None:
+        bits = as_int(self.bits, "bits")
+        if bits not in _VALID_BITS:
+            raise BitpackError(f"bits must be 8, 16, 32 or 64, not {quote(bits)}")
+        object.__setattr__(self, "bits", bits)  # a NumPy or other __index__ width is stored as int
+        signed = self.signed if type(self.signed) is bool else numpy_bool(self.signed)
+        if signed is None:
+            raise BitpackError(f"signed must be a bool, not {type_name(self.signed)}")
+        object.__setattr__(self, "signed", signed)
+
+    @property
+    def name(self) -> str:
+        """The short lower-case name.
+
+        >>> from lvbitpack import I32
+        >>> I32.name
+        'i32'
+        """
+        return f"{'i' if self.signed else 'u'}{self.bits}"
+
+    @property
+    def mask(self) -> int:
+        """All ones over the type's width.
+
+        >>> from lvbitpack import U16
+        >>> hex(U16.mask)
+        '0xffff'
+        """
+        return (1 << self.bits) - 1
+
+    @property
+    def min(self) -> int:
+        """The smallest value the type holds.
+
+        >>> from lvbitpack import I8, U8
+        >>> I8.min, U8.min
+        (-128, 0)
+        """
+        return -(1 << (self.bits - 1)) if self.signed else 0
+
+    @property
+    def max(self) -> int:
+        """The largest value the type holds.
+
+        >>> from lvbitpack import I8, U8
+        >>> I8.max, U8.max
+        (127, 255)
+        """
+        return (1 << (self.bits - 1)) - 1 if self.signed else self.mask
+
+    def contains(self, number: object) -> bool:
+        """Whether ``number`` is an integer within the type's range.
+
+        Any ``__index__`` integer counts; ``bool``, floats and other types are never contained.
+
+        >>> from lvbitpack import I8
+        >>> I8.contains(-128), I8.contains(128), I8.contains(1.0), I8.contains(True)
+        (True, False, False, False)
+        """
+        if not is_integer(number):
+            return False
+        try:
+            value = as_int(number, "number")
+        except BitpackError:  # an __index__ that refuses, such as a NumPy array's
+            return False
+        return self.min <= value <= self.max
+
+    @classmethod
+    def parse(cls, text: str) -> IntType:
+        """Read a name such as ``"u8"``, ``"I16"``, ``"uint32"`` or ``"int64"``.
+
+        Case and surrounding white space are ignored.
+
+        >>> from lvbitpack import IntType
+        >>> IntType.parse("I16"), IntType.parse(" uint8 ")
+        (IntType(bits=16, signed=True), IntType(bits=8, signed=False))
+        """
+        plain = plain_str(text)
+        if plain is None:
+            raise BitpackError(f"an integer type name must be str, not {type_name(text)}")
+        key = plain.strip().lower()
+        for prefix, signed in _PREFIXES:
+            digits = key[len(prefix) :]
+            if key.startswith(prefix) and digits in ("8", "16", "32", "64"):
+                return cls(int(digits), signed)
+        raise BitpackError(
+            f"unknown integer type {quote(text)}; use u8, u16, u32, u64, i8, i16, i32 or i64"
+        )
+
+
+U8 = IntType(8, False)
+U16 = IntType(16, False)
+U32 = IntType(32, False)
+U64 = IntType(64, False)
+I8 = IntType(8, True)
+I16 = IntType(16, True)
+I32 = IntType(32, True)
+I64 = IntType(64, True)
+
+
+def check_type(int_type: object) -> IntType:
+    """``int_type`` as a plain ``IntType``; anything else is refused.
+
+    A subclass is rebuilt from its two fields, so overridden methods change nothing.
+    """
+    kind = type(int_type)
+    if not issubclass(kind, IntType):
+        raise BitpackError(f"int_type must be an IntType such as U8, not {type_name(int_type)}")
+    try:
+        bits = object.__getattribute__(int_type, "bits")
+        signed = object.__getattribute__(int_type, "signed")
+        extra = len(object.__getattribute__(int_type, "__dict__")) != 2  # a shadowed method
+    except Exception:  # never initialised, or a subclass whose field lookup fails
+        raise BitpackError("int_type is an IntType that was never initialised") from None
+    plain = not extra and type(bits) is int and type(signed) is bool
+    if kind is IntType and plain and bits in (8, 16, 32, 64):
+        return int_type  # type: ignore[return-value]
+    return IntType(bits, signed)  # rebuilt, so a subclass or a tampered value is checked

lvbitpack-1.0.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.5
+Name: lvbitpack
+Version: 1.0.0
+Summary: LabVIEW Boolean arrays in pure Python: Boolean Array To Number with its sign extension modes, Number To Boolean Array, flattening and bit packing
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Source, https://github.com/JaviLianes8/lvbitpack
+Project-URL: Issues, https://github.com/JaviLianes8/lvbitpack/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/lvbitpack/blob/main/CHANGELOG.md
+Project-URL: LinkedIn, https://www.linkedin.com/in/jlianes/
+Project-URL: Funding, https://buymeacoffee.com/jlianesglrs
+Author-email: Javier Lianes <javier@lianes8studio.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: binary,bit,bitpack,boolean,flatten,labview,ni,sign-extension
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: editables; extra == 'dev'
+Requires-Dist: hatchling; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# lvbitpack
+
+LabVIEW Boolean arrays in pure Python: **Boolean Array To Number** with its three sign
+extension modes, **Number To Boolean Array**, the flattened form LabVIEW writes for a Boolean
+array, and compact bit packing. No dependencies, fully typed, Python 3.10 or newer.
+
+The full reference is the [guide](https://github.com/JaviLianes8/lvbitpack/blob/main/GUIDE.md);
+every release is described in the
+[changelog](https://github.com/JaviLianes8/lvbitpack/blob/main/CHANGELOG.md).
+
+## Install
+
+```
+pip install lvbitpack
+```
+
+## The problem
+
+A LabVIEW program that reads digital lines, status registers or flag words often turns a
+Boolean array into one integer with Boolean Array To Number, and back with Number To Boolean
+Array. Element 0 is the least significant bit, elements past the width are dropped, and a
+short array is padded by a per-node setting (Sign Extension Mode) that most people never
+look at, yet it decides whether `{FALSE, TRUE}` as an I8 is 2 or -2. Getting the same
+numbers in Python means reproducing those rules exactly.
+
+## Quick start
+
+```python
+from lvbitpack import I8, U8, U16, SignExtension, bools_to_number, number_to_bools
+
+# Element 0 is the least significant bit.
+assert bools_to_number([False, True], U8) == 2
+
+# LabVIEW's default mode pads a signed output with the last element: {F, T} as I8 is -2.
+assert bools_to_number([False, True], I8) == -2
+assert bools_to_number([False, True, False, True], I8, sign_extension=SignExtension.NEVER) == 10
+assert bools_to_number([False, True, False, True], I8, sign_extension=SignExtension.ALWAYS) == -6
+
+# Elements beyond the width are dropped.
+assert bools_to_number([True] * 9, U8) == 255
+
+# The inverse returns one element per bit of the type.
+assert number_to_bools(-2, I8) == [False, True, True, True, True, True, True, True]
+assert len(number_to_bools(1, U16)) == 16
+```
+
+Bytes, LabVIEW's flattened array and dense bit packing:
+
+```python
+from lvbitpack import U16, bools_to_bytes, pack_bools, pack_flattened, unpack_flattened
+
+# The number's bytes, big-endian by default like LabVIEW's Flatten To String.
+assert bools_to_bytes([False, True], U16) == b"\x00\x02"
+assert bools_to_bytes([False, True], U16, byteorder="little") == b"\x02\x00"
+
+# Flatten To String of a Boolean array: an I32 count, then one byte per element.
+assert pack_flattened([True, False, True, True]).hex() == "0000000401000101"
+assert unpack_flattened(bytes.fromhex("0000000401000101")) == [True, False, True, True]
+
+# Eight elements per byte, first element in the high bit (or the low bit with "lsb").
+assert pack_bools([True, True, False, True]) == b"\xd0"
+assert pack_bools([True, True, False, True], bit_order="lsb") == b"\x0b"
+```
+
+Anything refused (a value out of range, a string where a Boolean array belongs, a truncated
+flattened array) raises `lvbitpack.BitpackError`, a `ValueError`.
+
+## Command line
+
+```
+$ lvbitpack pack 01 --type i8
+-2
+$ lvbitpack pack 0101 --type i8 --sign-extension never
+10
+$ lvbitpack unpack -2 --type i8
+01111111
+$ lvbitpack flatten 1011
+0000000401000101
+```
+
+Bit strings list element 0 first. `python -m lvbitpack` works too.
+
+## Why this library
+
+- It follows LabVIEW's own rules: the three Sign Extension Mode settings, truncation of long
+  arrays, the 8, 16, 32 and 64-bit signed and unsigned outputs, and the flattened Boolean
+  array layout, checked against NI's documentation and against output of LabVIEW 2026.
+- NumPy's `packbits` packs 0/1 arrays into `uint8` bytes (high or low bit first) but has no
+  notion of LabVIEW's integer widths or sign extension, and needs NumPy. `bitarray` (a C
+  extension) and `bitstring` (which depends on `tibs`) are general bit containers; neither
+  reproduces Boolean Array To Number. lvbitpack is small, pure Python and dependency free.
+
+What it does not cover: Boolean Array To Number with a fixed-point output (see the guide).
+
+## License
+
+MIT. See [LICENSE](https://github.com/JaviLianes8/lvbitpack/blob/main/LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

lvbitpack-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+lvbitpack/__init__.py,sha256=tcHX4zzK0r0cZm537mEzRa6BpAiqHYm8o9b4FA3yVwY,1557
+lvbitpack/__main__.py,sha256=LorHK61MyWjMAULC9zVNqUNX5LAzvugBaz8tq_3Zl6E,153
+lvbitpack/_bytes.py,sha256=R2tl08DqBzmTxam2nLauzKEDTS0PbNtl4JkoLfSMfWE,3626
+lvbitpack/_cli.py,sha256=gK3SpHX9byw1RvZtOelp1mpbjriY359YGXZ4VAvzrD0,5849
+lvbitpack/_cli_io.py,sha256=AbTBEBc-J713mgPT6dLjYL6tViV7bymJcwqjiPjBe50,3077
+lvbitpack/_errors.py,sha256=aRtNDTXEFocZuGUC7R08DzfFAbrhiloZqXTGexmX8w8,5157
+lvbitpack/_flatten.py,sha256=o3zo0e8jqKBvT8goqwkhtocDO3yBhqt8MS3P2hsKUbI,2082
+lvbitpack/_modes.py,sha256=IM63e0KBteiBrqPpbwP8_mweCQan1gGbCCJYGLoFV8M,1817
+lvbitpack/_number.py,sha256=soz4V21wcRHnwaCkZSPvLW45j7dQGQ-uHisGAmn-vrQ,3393
+lvbitpack/_pack.py,sha256=3YUBblGr-dy33aE0bNAFG-pxFwEyS5asXTlRgaO1uNM,2608
+lvbitpack/_text.py,sha256=ReycP95uHqcqw9c38mB_5nISQxhTx1krC5Hk65ACD10,2219
+lvbitpack/_types.py,sha256=mbFWzyrYDq88y8_Iz-cAt2b0tmNsibBoW34ZiPww_Rc,5168
+lvbitpack/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lvbitpack-1.0.0.dist-info/METADATA,sha256=iFcA7lDqTJqRvpIiA8p-ymk80DH5QRUtydIT7dT6Drs,5900
+lvbitpack-1.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lvbitpack-1.0.0.dist-info/entry_points.txt,sha256=vsHCk8Ovlmpthqam4kAYJKt-Nc72ufl2FIkZQBDkLTQ,50
+lvbitpack-1.0.0.dist-info/licenses/LICENSE,sha256=wirD5nCA2aQa5UusK_1YHLBogI3CGcw23xAnulp3L_U,1091
+lvbitpack-1.0.0.dist-info/RECORD,,

lvbitpack-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

lvbitpack-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lvbitpack = lvbitpack._cli:main

lvbitpack-1.0.0.dist-info/licenses/LICENSE

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