lvbitpack 1.0.0__tar.gz

lvbitpack-1.0.0/.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+.venv/
+venv/
+build/
+dist/
+*.egg-info/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/

lvbitpack-1.0.0/CHANGELOG.md

@@ -0,0 +1,81 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2026-10-14
+
+First stable release, and the first one published on PyPI. The public API is the 21 names
+in `lvbitpack.__all__`; their names, signatures, defaults and error type are now stable.
+
+### Changed (from 0.2.0)
+
+- `pack_flattened` and `unpack_flattened` now read and write LabVIEW's real flattened
+  Boolean array: a big-endian I32 count, then one byte per element (0x01 / 0x00). In 0.2.0
+  they wrote the count followed by bit-packed bytes, which LabVIEW cannot unflatten.
+  `unpack_flattened` reads any nonzero byte as TRUE and refuses a negative count, missing
+  elements and bytes left over after the last element.
+- The byte functions (`number_to_bytes`, `bytes_to_number`, `bools_to_bytes`,
+  `bytes_to_bools`) default to big-endian, LabVIEW's flattened order; 0.2.0 defaulted to
+  little-endian.
+- Every refusal raises the new `BitpackError` (a `ValueError`). In 0.2.0 some bad input
+  leaked `TypeError` or `AttributeError` from inside, and some was silently accepted.
+- Boolean arrays are checked: a `str` or bytes object is refused (0.2.0 read each
+  character's truthiness, so `"0101"` gave 15), and elements must be booleans or 0/1.
+- Arrays may be any finite iterable; 0.2.0 needed indexing, so generators failed, and
+  `bools_to_number` refused NumPy arrays ("truth value of an array is ambiguous").
+- `IntType` refuses a non-`int` or `bool` width and a non-`bool` `signed`; 0.2.0 accepted
+  `IntType(8.0, "yes")`. `IntType.parse` accepts only the eight names (with `u`, `uint`, `i`,
+  `int` prefixes); 0.2.0 accepted forms such as `"u08"`. A NumPy or other `__index__`
+  width is accepted and stored as `int`, and a NumPy boolean `signed` is stored as `bool`.
+  `IntType.contains` answers False for `bool` and floats (0.2.0 said True for
+  `contains(1.0)` and `contains(True)`) and True for in-range `__index__` integers.
+- Byte arguments accept any buffer-protocol object and read its raw bytes, so a buffer
+  of wide items (an `array.array("H")`, a NumPy `uint16` array) is measured in bytes; 0.2.0
+  measured it in items. Lists of integers, which 0.2.0 read as bytes, are refused, and so
+  are buffers of Python objects (a NumPy `object` array), which 0.2.0 read as pointer bytes.
+- `number` and `count` are typed `SupportsIndex`, so NumPy integers pass a type checker.
+- `SignExtension(...)` with anything but a member or one of its three names raises
+  `BitpackError` (still a `ValueError`). `sign_extension=` takes only a `SignExtension`
+  member: 0.2.0 silently treated a string such as `"never"` as `IF_SIGNED`.
+- `IntType` and `SignExtension` are defined in private modules other than 0.2.0's
+  (`lvbitpack._types`, `lvbitpack._modes`); pickles made by 0.2.0 still load.
+- Numbers are checked: `bool` and non-integers are refused, `__index__` integers (NumPy)
+  accepted, and messages never print a huge integer (0.2.0 failed inside its own message
+  for integers beyond Python's 4300-digit printing limit).
+- The command line prefixes errors with `lvbitpack: error:`, bounds every message, exits 1
+  quietly when its output pipe closes, and runs as `python -m lvbitpack`. An unknown
+  `--type` is a usage error (exit 2, was 1). Bit strings also ignore `_`; `unpack` refuses
+  numbers longer than 100 characters or written with non-ASCII digits, and reads negative
+  prefixed numbers such as `-0x2` on every supported Python.
+- Public functions report `lvbitpack` as their module in `help()`; the classes keep the
+  module they are defined in, so source lookup and pickles find them.
+
+### Added
+
+- `BitpackError`.
+- `bit_order="msb" | "lsb"` on `pack_bools` and `unpack_bools`; `unpack_bools`'s `count` is
+  now optional (every bit by default).
+- `flatten` and `unflatten` commands.
+- `GUIDE.md` with executed examples.
+
+## [0.2.0] - not released
+
+- `bools_to_number` and `number_to_bools`: LabVIEW Boolean Array To Number and
+  Number To Boolean Array, element 0 the least significant bit, U8/U16/U32/U64 and
+  signed I8/I16/I32/I64 two's complement, extra elements dropped, and the three
+  documented sign-extension modes for short arrays.
+- `SignExtension` enum and the typed `IntType` value object with the `U8` to `I64`
+  presets, bounds, mask, and a `parse` helper.
+- `number_to_bytes`, `bytes_to_number`, `bools_to_bytes`, and `bytes_to_bools`.
+- `lvbitpack` command line interface: `pack` and `unpack`.
+
+## [0.1.0] - not released
+
+- `pack_bools` and `unpack_bools`: MSB-first bit packing with zero padding of the
+  final byte and count-aware unpacking.
+- `pack_flattened` and `unpack_flattened`: a four-byte big-endian element count
+  followed by the packed bits.

lvbitpack-1.0.0/CONTRIBUTING.md

@@ -0,0 +1,19 @@
+# Contributing
+
+Thanks for taking the time. This project keeps a small, predictable shape.
+
+## Setup
+
+```
+pip install -r requirements-dev.txt
+```
+
+## Before you open a pull request
+
+- Keep public API in `src/lvbitpack/__init__.py`; internals live in `_`-prefixed modules.
+- Add a test for the behaviour you change. Tests inject time, disk and network; they
+  never touch the real thing.
+- Run `scripts/check.ps1` (format, lint, types, tests) and make sure it passes.
+- One logical change per commit, imperative subject line.
+
+Open an issue first if the change is large or shifts the public API.

lvbitpack-1.0.0/GUIDE.md

@@ -0,0 +1,200 @@
+# lvbitpack guide
+
+Every example below runs as written; the test suite executes them.
+
+## Boolean Array To Number
+
+`bools_to_number(values, int_type, *, sign_extension=SignExtension.IF_SIGNED)` reads the
+array as the binary form of one integer. Element 0 is the least significant bit.
+
+```pycon
+>>> from lvbitpack import I8, I16, U8, SignExtension, bools_to_number
+>>> bools_to_number([False, True], U8)
+2
+>>> bools_to_number([True] * 8 + [False, True], U8)
+255
+>>> bools_to_number([], I16)
+0
+
+```
+
+Elements past the width are dropped. A shorter array is padded above its last element as
+the sign extension mode (set by right-clicking the node in LabVIEW) says:
+
+| Mode | Unsigned output pads with | Signed output pads with |
+| --- | --- | --- |
+| `SignExtension.NEVER` | FALSE | FALSE |
+| `SignExtension.IF_SIGNED` (LabVIEW's default) | FALSE | the last element |
+| `SignExtension.ALWAYS` | the last element | the last element |
+
+```pycon
+>>> from lvbitpack import I8, U8, SignExtension, bools_to_number
+>>> array = [False, False, True, False, True]
+>>> [bools_to_number(array, U8, sign_extension=mode) for mode in SignExtension]
+[20, 20, 244]
+>>> [bools_to_number(array, I8, sign_extension=mode) for mode in SignExtension]
+[20, -12, -12]
+
+```
+
+A signed output is the two's complement value; an empty array is 0 in every mode. The test
+suite replays about 2,900 results of this node and 200 of Number To Boolean Array produced
+by LabVIEW 2026 (all eight types, the three modes, arrays of 0 to 65 elements; see
+`tests/fixtures/labview2026`). There a node with no output representation set gave a U32
+(it was inserted by editing a VI file; NI does not document the default).
+
+## Number To Boolean Array
+
+`number_to_bools(number, int_type)` returns one element per bit of the type, element 0 the
+least significant bit of the two's complement form. A number outside the type raises
+`BitpackError` (LabVIEW would have coerced it to the wire's type first).
+
+```pycon
+>>> from lvbitpack import I8, U64, number_to_bools
+>>> number_to_bools(-2, I8)
+[False, True, True, True, True, True, True, True]
+>>> len(number_to_bools(5, U64))
+64
+
+```
+
+## Integer types
+
+`IntType(bits, signed)` takes 8, 16, 32 or 64 bits. `U8`, `U16`, `U32`, `U64`, `I8`, `I16`,
+`I32` and `I64` are ready-made, and `IntType.parse` reads names in any case.
+
+```pycon
+>>> from lvbitpack import IntType, I32
+>>> IntType.parse("int32") == I32
+True
+>>> I32.name, I32.min, I32.max, hex(I32.mask)
+('i32', -2147483648, 2147483647, '0xffffffff')
+>>> I32.contains(2**31)
+False
+
+```
+
+## Bytes of the number
+
+`number_to_bytes`, `bytes_to_number`, `bools_to_bytes` and `bytes_to_bools` lay the number
+out in exactly `bits // 8` bytes. The default is big-endian, LabVIEW's flattened order;
+pass `byteorder="little"` for the memory order of x86 and ARM machines. The element to bit
+mapping never changes with byte order.
+
+```pycon
+>>> from lvbitpack import I32, U16, bools_to_bytes, bytes_to_number, number_to_bytes
+>>> number_to_bytes(-19, I32).hex()
+'ffffffed'
+>>> bytes_to_number(bytes.fromhex("edffffff"), I32, byteorder="little")
+-19
+>>> bools_to_bytes([False, True], U16, byteorder="little")
+b'\x02\x00'
+
+```
+
+## Flattened Boolean arrays
+
+`pack_flattened` writes what LabVIEW's Flatten To String writes for a 1-D Boolean array with
+its "prepend array or string size?" input left at its default (TRUE): a big-endian I32
+element count, then one byte per element, 0x01 for TRUE and 0x00 for FALSE.
+`unpack_flattened` reads it back; any nonzero element byte is TRUE, and the input must hold
+exactly the counted elements.
+
+```pycon
+>>> from lvbitpack import pack_flattened, unpack_flattened
+>>> pack_flattened([True, False, True, True]).hex()
+'0000000401000101'
+>>> unpack_flattened(bytes.fromhex("00000002ff00"))
+[True, False]
+
+```
+
+## Dense bit packing
+
+`pack_bools` stores eight elements per byte with no header, filling unused bits of the last
+byte with zeros. `bit_order="msb"` (default) puts element 0 in bit 7 of byte 0; `"lsb"` puts
+it in bit 0, so each byte equals Boolean Array To Number of its eight elements as a U8.
+`unpack_bools(data, count=None)` reads `count` elements, or every bit when `count` is None.
+Current LabVIEW stores and flattens a Boolean as a whole byte; this form is for protocols
+and files that pack bits.
+
+```pycon
+>>> from lvbitpack import pack_bools, unpack_bools
+>>> pack_bools([True] * 9), pack_bools([True] * 9, bit_order="lsb")
+(b'\xff\x80', b'\xff\x01')
+>>> unpack_bools(b"\xd0", 4)
+[True, True, False, True]
+
+```
+
+## What counts as input
+
+- A Boolean array is any finite iterable (list, tuple, generator, NumPy array) of `True`,
+  `False`, 0, 1 (or `__index__` objects giving 0 or 1) or NumPy booleans; the hints say
+  `Iterable[bool | int]`. `str`, `bytes`, `bytearray` and `memoryview` are refused: `"0101"`
+  is not four Booleans. A set has no element order, so pass a sequence.
+- Numbers, counts and `IntType` widths accept any `__index__` integer except `bool`
+  (`number` and `count` are typed `SupportsIndex`; elsewhere a type checker wants `int(...)`
+  or `bool(...)` around NumPy scalars). `IntType.contains` answers False for anything else.
+- Bytes are any buffer-protocol object (`bytes`, `bytearray`, `memoryview`, `array.array`,
+  NumPy arrays, ctypes objects), read as raw bytes in memory order. Text, lists and buffers
+  of Python objects (a NumPy `object` array) are refused.
+
+```pycon
+>>> import array
+>>> from lvbitpack import U16, bytes_to_number
+>>> bytes_to_number(array.array("B", [1, 0]), U16)
+256
+
+```
+
+## Errors
+
+Every refusal raises `BitpackError`, a subclass of `ValueError`, including
+`SignExtension(value)` for any value that is not a member or one of its three names.
+Messages are printable ASCII, quote at most 40 characters of a bad value and describe
+integers wider than 128 bits by their size. Checks use an object's real type, never a
+`__class__` it claims. An object that cannot be iterated, indexed or read as a buffer at
+all is refused; any other exception your own object raises (from `__index__`, `__iter__`,
+while iterating, or from `__buffer__` on Python 3.12 and later, except a `ValueError`)
+passes through unchanged, as do ordinary call mistakes such as a missing argument.
+
+| Situation | Message starts with |
+| --- | --- |
+| number outside the type | `<n> is out of range for <type>` |
+| element that is not a Boolean | `element <i> must be a boolean` |
+| text or bytes as the array | `values must be an iterable of booleans` |
+| wrong byte count for a number | `<type> needs exactly <n> bytes` |
+| short flattened array | `a flattened array starts`, `the count says` |
+| negative count, extra bytes | `the element count is negative`, `<n> byte(s) follow(s)` |
+| bad option or `int_type` | the parameter's name |
+
+## Command line
+
+```
+$ lvbitpack pack 01 --type u8
+2
+$ lvbitpack pack 01 --type i8
+-2
+$ lvbitpack pack 0101 --type i8 --sign-extension always
+-6
+$ lvbitpack pack 1 --type u16 --base hex
+0x1
+$ lvbitpack unpack 0x80 --type u8
+00000001
+$ lvbitpack flatten 1011
+0000000401000101
+$ lvbitpack unflatten 0000000401000101
+1011
+```
+
+Bit strings list element 0 first; `1`, `t`, `T` are TRUE, `0`, `f`, `F` FALSE, and spaces,
+commas and underscores are ignored. `unpack` reads decimal or `0x`, `0o`, `0b` prefixed
+numbers in ASCII digits, negative ones included (`unpack -0x80 -t i8`). Data errors print
+`lvbitpack: error: ...` and exit 1; usage errors, an unknown `--type` included, exit 2.
+
+## Scope
+
+Boolean Array To Number can also produce a fixed-point number, and Number To Boolean Array
+accepts one; lvbitpack covers the eight integer types. Multi-dimensional arrays are not
+flattened here.

lvbitpack-1.0.0/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.

lvbitpack-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,103 @@
+# 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/pyproject.toml

@@ -0,0 +1,77 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lvbitpack"
+version = "1.0.0"
+description = "LabVIEW Boolean arrays in pure Python: Boolean Array To Number with its sign extension modes, Number To Boolean Array, flattening and bit packing"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Javier Lianes", email = "javier@lianes8studio.com" }]
+keywords = ["labview", "boolean", "bit", "bitpack", "flatten", "sign-extension", "ni", "binary"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["ruff", "mypy", "pytest", "build", "twine", "hatchling", "editables"]
+
+[project.scripts]
+lvbitpack = "lvbitpack._cli:main"
+
+[project.urls]
+Homepage = "https://lianes8studio.com"
+Source = "https://github.com/JaviLianes8/lvbitpack"
+Issues = "https://github.com/JaviLianes8/lvbitpack/issues"
+Changelog = "https://github.com/JaviLianes8/lvbitpack/blob/main/CHANGELOG.md"
+LinkedIn = "https://www.linkedin.com/in/jlianes/"
+Funding = "https://buymeacoffee.com/jlianesglrs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lvbitpack"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "src",
+    "tests",
+    "README.md",
+    "GUIDE.md",
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "LICENSE",
+    "pyproject.toml",
+    "requirements-dev.txt",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
+
+[tool.mypy]
+python_version = "3.10"
+strict = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-q"

lvbitpack-1.0.0/requirements-dev.txt

@@ -0,0 +1,3 @@
+# Development dependencies: the package in editable mode plus its dev extras
+# (ruff, mypy, pytest, build, twine). Install with:  pip install -r requirements-dev.txt
+-e .[dev]