lvtypedesc 0.2.0__py3-none-any.whl

lvtypedesc/__init__.py

@@ -0,0 +1,43 @@
+"""Parse LabVIEW type-descriptor byte strings into a readable, typed schema."""
+
+from __future__ import annotations
+
+from ._codes import Category, TypeCode, known_codes
+from ._emit import to_bytes
+from ._errors import TypeDescError
+from ._model import (
+    VARIABLE,
+    Array,
+    Boolean,
+    Cluster,
+    FixedPoint,
+    LVString,
+    Refnum,
+    Scalar,
+    TypeDesc,
+    describe,
+)
+from ._parser import parse_type_descriptor
+from ._pretty import pretty
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "VARIABLE",
+    "Array",
+    "Boolean",
+    "Category",
+    "Cluster",
+    "FixedPoint",
+    "LVString",
+    "Refnum",
+    "Scalar",
+    "TypeCode",
+    "TypeDesc",
+    "TypeDescError",
+    "describe",
+    "known_codes",
+    "parse_type_descriptor",
+    "pretty",
+    "to_bytes",
+]

lvtypedesc/_cli.py

@@ -0,0 +1,91 @@
+"""Command-line interface for lvtypedesc.
+
+Decode a hex type descriptor into a readable type, or list the codes the library
+knows. Errors are written to stderr and the process exits with status 1.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+
+from . import __version__
+from ._codes import known_codes
+from ._errors import TypeDescError
+from ._model import describe
+from ._parser import parse_type_descriptor
+from ._pretty import pretty
+
+_EXAMPLES = """\
+examples:
+  lvtypedesc decode 00040003                          -> I32
+  lvtypedesc decode "0004 000A"                       -> DBL (spaces are ignored)
+  lvtypedesc decode 000E00400001FFFFFFFF0004000A      -> 1D Array of DBL
+  lvtypedesc decode --tree 000E00500002000400030004000A
+  lvtypedesc codes                                    -> list every known type code
+"""
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="lvtypedesc",
+        description="Parse LabVIEW type-descriptor byte strings into a readable type.",
+        epilog=_EXAMPLES,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--version", action="version", version=f"lvtypedesc {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    decode = sub.add_parser(
+        "decode",
+        help="decode a hex type descriptor into a readable type",
+        description="Decode a hex type descriptor. Whitespace in the hex is ignored.",
+    )
+    decode.add_argument("hex", help="the type descriptor as hex, for example 00040003")
+    decode.add_argument(
+        "--tree",
+        action="store_true",
+        help="print an indented tree instead of a one-line summary",
+    )
+
+    sub.add_parser(
+        "codes",
+        help="list every type code the library recognises",
+        description="List every recognised type code, with its name and category.",
+    )
+    return parser
+
+
+def _run_decode(hex_text: str, tree: bool) -> int:
+    try:
+        data = bytes.fromhex(hex_text)
+    except ValueError as exc:
+        print(f"error: not valid hex: {exc}", file=sys.stderr)
+        return 1
+    try:
+        node = parse_type_descriptor(data)
+    except TypeDescError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+    print(pretty(node) if tree else describe(node))
+    return 0
+
+
+def _run_codes() -> int:
+    for code, name, category in known_codes():
+        print(f"0x{code:02X}  {name:<10} {category.value}")
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Entry point for the ``lvtypedesc`` console script."""
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    if args.command == "decode":
+        return _run_decode(args.hex, args.tree)
+    return _run_codes()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

lvtypedesc/_codes.py

@@ -0,0 +1,131 @@
+"""The type codes this library understands.
+
+The names and values follow the community-documented LabVIEW type-descriptor
+table (see the project README for provenance). These codes are not an official
+NI byte specification and can change between LabVIEW versions, so they are kept
+in one place rather than scattered through the parser.
+"""
+
+from __future__ import annotations
+
+from enum import Enum, IntEnum
+
+
+class TypeCode(IntEnum):
+    """Every raw type code this library recognises, by name.
+
+    Member names are Python identifiers. The human label used in output comes
+    from the name tables below (for example ``BOOLEAN16`` is labelled
+    ``Boolean16``).
+    """
+
+    I8 = 0x01
+    I16 = 0x02
+    I32 = 0x03
+    I64 = 0x04
+    U8 = 0x05
+    U16 = 0x06
+    U32 = 0x07
+    U64 = 0x08
+    SGL = 0x09
+    DBL = 0x0A
+    EXT = 0x0B
+    CSG = 0x0C
+    CDB = 0x0D
+    CXT = 0x0E
+    BOOLEAN16 = 0x20
+    BOOLEAN = 0x21
+    STRING = 0x30
+    PATH = 0x32
+    PICTURE = 0x33
+    ARRAY = 0x40
+    CLUSTER = 0x50
+    FXP = 0x5F
+    REFNUM = 0x70
+
+
+SCALAR_NAMES: dict[int, str] = {
+    0x01: "I8",
+    0x02: "I16",
+    0x03: "I32",
+    0x04: "I64",
+    0x05: "U8",
+    0x06: "U16",
+    0x07: "U32",
+    0x08: "U64",
+    0x09: "SGL",
+    0x0A: "DBL",
+    0x0B: "EXT",
+    0x0C: "CSG",
+    0x0D: "CDB",
+    0x0E: "CXT",
+}
+
+BOOLEAN_NAMES: dict[int, str] = {
+    0x20: "Boolean16",
+    0x21: "Boolean",
+}
+
+STRING_NAMES: dict[int, str] = {
+    0x30: "String",
+    0x32: "Path",
+    0x33: "Picture",
+}
+
+ARRAY_CODE = 0x40
+CLUSTER_CODE = 0x50
+FXP_CODE = 0x5F
+REFNUM_CODE = 0x70
+
+# Recognised by LabVIEW but outside this library's scope. Their payloads are not
+# documented well enough to parse honestly, so the parser refuses them with a
+# named message instead of a bare "unknown code".
+UNSUPPORTED_NAMES: dict[int, str] = {
+    0x15: "EnumU8",
+    0x16: "EnumU16",
+    0x17: "EnumU32",
+    0x53: "Variant",
+    0x54: "Waveform",
+}
+
+
+class Category(Enum):
+    """The structural family a type code belongs to."""
+
+    SCALAR = "scalar"
+    BOOLEAN = "boolean"
+    STRING = "string"
+    ARRAY = "array"
+    CLUSTER = "cluster"
+    FXP = "fxp"
+    REFNUM = "refnum"
+
+
+def classify(code: int) -> tuple[Category, str] | None:
+    """Map a type code to its category and name, or None if out of scope."""
+    if code in SCALAR_NAMES:
+        return Category.SCALAR, SCALAR_NAMES[code]
+    if code in BOOLEAN_NAMES:
+        return Category.BOOLEAN, BOOLEAN_NAMES[code]
+    if code in STRING_NAMES:
+        return Category.STRING, STRING_NAMES[code]
+    if code == ARRAY_CODE:
+        return Category.ARRAY, "Array"
+    if code == CLUSTER_CODE:
+        return Category.CLUSTER, "Cluster"
+    if code == FXP_CODE:
+        return Category.FXP, "FXP"
+    if code == REFNUM_CODE:
+        return Category.REFNUM, "Refnum"
+    return None
+
+
+def known_codes() -> list[tuple[int, str, Category]]:
+    """Return every recognised ``(code, name, category)`` row, sorted by code."""
+    rows: list[tuple[int, str, Category]] = []
+    for code in range(0x100):
+        kind = classify(code)
+        if kind is not None:
+            category, name = kind
+            rows.append((code, name, category))
+    return rows

lvtypedesc/_emit.py

@@ -0,0 +1,59 @@
+"""Re-emit a typed tree as a canonical short-form type descriptor.
+
+``to_bytes`` is the inverse of :func:`parse_type_descriptor` for every node type
+this library models. It writes the short-form descriptor (16-bit length) and
+raises :class:`TypeDescError` when a tree is too large for that form, rather than
+guessing the long-form layout.
+"""
+
+from __future__ import annotations
+
+from ._errors import TypeDescError
+from ._model import (
+    VARIABLE,
+    Array,
+    Boolean,
+    Cluster,
+    FixedPoint,
+    LVString,
+    Refnum,
+    Scalar,
+    TypeDesc,
+)
+
+_HEADER = 4
+_U32_VARIABLE = 0xFFFFFFFF
+_MAX_LENGTH = 0xFFFF
+
+
+def to_bytes(node: TypeDesc) -> bytes:
+    """Serialise ``node`` back into a canonical short-form type descriptor."""
+    body = _body(node)
+    length = _HEADER + len(body)
+    if length > _MAX_LENGTH:
+        raise TypeDescError(f"descriptor of {length} bytes is too large for the short form")
+    return _u16(length) + _u16(node.code & 0xFFFF) + body
+
+
+def _body(node: TypeDesc) -> bytes:
+    if isinstance(node, (Scalar, Boolean)):
+        return b""
+    if isinstance(node, LVString):
+        size = _U32_VARIABLE if node.size == VARIABLE else node.size
+        return _u32(size)
+    if isinstance(node, Array):
+        dims = b"".join(_u32(_U32_VARIABLE if d == VARIABLE else d) for d in node.dimensions)
+        return _u16(node.rank) + dims + to_bytes(node.element)
+    if isinstance(node, Cluster):
+        return _u16(len(node.fields)) + b"".join(to_bytes(f) for f in node.fields)
+    if isinstance(node, (FixedPoint, Refnum)):
+        return node.payload
+    raise TypeDescError(f"cannot serialise node of type {type(node).__name__}")
+
+
+def _u16(value: int) -> bytes:
+    return int(value).to_bytes(2, "big")
+
+
+def _u32(value: int) -> bytes:
+    return int(value).to_bytes(4, "big")

lvtypedesc/_errors.py

@@ -0,0 +1,11 @@
+"""The single error type raised for malformed or unsupported input."""
+
+from __future__ import annotations
+
+
+class TypeDescError(ValueError):
+    """Raised when a byte string is not a type descriptor this library can parse.
+
+    Covers truncated input, an impossible length word, and type codes that are
+    unknown or outside the supported subset.
+    """

lvtypedesc/_model.py

@@ -0,0 +1,96 @@
+"""The typed tree a parsed type descriptor becomes, and a readable rendering."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+# A dimension or string whose size is not fixed in the descriptor. LabVIEW
+# stores this as 0xFFFFFFFF; the actual size lives in the flattened data.
+VARIABLE = -1
+
+
+@dataclass(frozen=True)
+class TypeDesc:
+    """Base node. ``code`` is the raw type code, ``name`` its documented label."""
+
+    code: int
+    name: str
+
+
+@dataclass(frozen=True)
+class Scalar(TypeDesc):
+    """A fixed-width numeric type, for example I32 or DBL."""
+
+
+@dataclass(frozen=True)
+class Boolean(TypeDesc):
+    """A LabVIEW boolean."""
+
+
+@dataclass(frozen=True)
+class LVString(TypeDesc):
+    """A variable-length string, path or picture.
+
+    ``size`` is the descriptor's 32-bit size word: ``VARIABLE`` when the size is
+    not fixed (``0xFFFFFFFF``), otherwise the fixed byte count.
+    """
+
+    size: int = VARIABLE
+
+
+@dataclass(frozen=True)
+class Array(TypeDesc):
+    """An n-dimensional array of one element type."""
+
+    element: TypeDesc
+    dimensions: tuple[int, ...] = field(default_factory=tuple)
+
+    @property
+    def rank(self) -> int:
+        """The number of dimensions."""
+        return len(self.dimensions)
+
+
+@dataclass(frozen=True)
+class Cluster(TypeDesc):
+    """An ordered group of named-by-position field types."""
+
+    fields: tuple[TypeDesc, ...] = field(default_factory=tuple)
+
+
+@dataclass(frozen=True)
+class FixedPoint(TypeDesc):
+    """A LabVIEW fixed-point number (FXP).
+
+    The word, delta and offset encoding inside an FXP descriptor is
+    version-specific and not fully documented, so the type-specific bytes are
+    preserved verbatim in ``payload`` rather than parsed into fields. This keeps
+    round-trip exact without inventing an interpretation.
+    """
+
+    payload: bytes = b""
+
+
+@dataclass(frozen=True)
+class Refnum(TypeDesc):
+    """A LabVIEW refnum (a handle to a queue, VISA resource, control, ...).
+
+    ``subtype`` is the first payload word, which identifies the refnum kind. Its
+    meaning is only partly documented, so it is surfaced best-effort and the full
+    type-specific bytes are kept in ``payload`` for exact round-trip.
+    """
+
+    subtype: int = 0
+    payload: bytes = b""
+
+
+def describe(node: TypeDesc) -> str:
+    """Render a parsed descriptor as a compact, readable one-line string."""
+    if isinstance(node, Array):
+        return f"{node.rank}D Array of {describe(node.element)}"
+    if isinstance(node, Cluster):
+        inner = ", ".join(describe(f) for f in node.fields)
+        return f"Cluster {{ {inner} }}"
+    if isinstance(node, Refnum):
+        return f"Refnum(subtype=0x{node.subtype:02x})"
+    return node.name

lvtypedesc/_parser.py

@@ -0,0 +1,125 @@
+"""Recursive descent over a LabVIEW type descriptor byte string.
+
+Layout of the common types, all big-endian:
+
+- header: a 16-bit length (bytes in this descriptor, including the length) and a
+  16-bit type-code word whose low byte is the type code.
+- scalar, boolean: header only.
+- string, path, picture: header plus a 32-bit size word (0xFFFFFFFF = variable).
+- array: header, a 16-bit dimension count, one 32-bit size per dimension, then
+  the element descriptor.
+- cluster: header, a 16-bit field count, then that many descriptors in order.
+- fxp, refnum: header plus a type-specific payload kept as raw bytes, because its
+  internal layout is version-specific and not fully documented.
+"""
+
+from __future__ import annotations
+
+from ._codes import UNSUPPORTED_NAMES, Category, classify
+from ._errors import TypeDescError
+from ._model import (
+    VARIABLE,
+    Array,
+    Boolean,
+    Cluster,
+    FixedPoint,
+    LVString,
+    Refnum,
+    Scalar,
+    TypeDesc,
+)
+
+_HEADER = 4
+_U32_VARIABLE = 0xFFFFFFFF
+
+
+def parse_type_descriptor(data: bytes) -> TypeDesc:
+    """Parse the leading type descriptor in ``data`` into a typed tree.
+
+    Trailing bytes (such as the flattened data that follows a descriptor) are
+    ignored. Raises :class:`TypeDescError` on truncated or unsupported input.
+    """
+    if not isinstance(data, (bytes, bytearray)):
+        raise TypeDescError("expected bytes")
+    node, _ = _parse(bytes(data), 0)
+    return node
+
+
+def _u16(data: bytes, offset: int) -> int:
+    if offset + 2 > len(data):
+        raise TypeDescError(f"truncated: need 2 bytes at offset {offset}")
+    return int.from_bytes(data[offset : offset + 2], "big")
+
+
+def _u32(data: bytes, offset: int) -> int:
+    if offset + 4 > len(data):
+        raise TypeDescError(f"truncated: need 4 bytes at offset {offset}")
+    return int.from_bytes(data[offset : offset + 4], "big")
+
+
+def _parse(data: bytes, offset: int) -> tuple[TypeDesc, int]:
+    length = _u16(data, offset)
+    code = _u16(data, offset + 2) & 0xFF
+    end = offset + length
+    if length < _HEADER:
+        raise TypeDescError(f"length {length} too small at offset {offset}")
+    if end > len(data):
+        raise TypeDescError(f"descriptor at offset {offset} runs past the input")
+
+    kind = classify(code)
+    if kind is None:
+        name = UNSUPPORTED_NAMES.get(code)
+        detail = f"unsupported type {name}" if name else "unknown type code"
+        raise TypeDescError(f"{detail} 0x{code:02x} at offset {offset}")
+
+    category, name = kind
+    if category is Category.SCALAR:
+        return Scalar(code, name), end
+    if category is Category.BOOLEAN:
+        return Boolean(code, name), end
+    if category is Category.STRING:
+        return _parse_string(data, offset, end, code, name), end
+    if category is Category.ARRAY:
+        return _parse_array(data, offset, code, name), end
+    if category is Category.CLUSTER:
+        return _parse_cluster(data, offset, code, name), end
+    if category is Category.FXP:
+        return FixedPoint(code, name, payload=data[offset + _HEADER : end]), end
+    return _parse_refnum(data, offset, end, code, name), end
+
+
+def _parse_string(data: bytes, offset: int, end: int, code: int, name: str) -> LVString:
+    if end - offset >= _HEADER + 4:
+        raw = _u32(data, offset + _HEADER)
+        size = VARIABLE if raw == _U32_VARIABLE else raw
+    else:
+        size = VARIABLE
+    return LVString(code, name, size=size)
+
+
+def _parse_array(data: bytes, offset: int, code: int, name: str) -> Array:
+    rank = _u16(data, offset + _HEADER)
+    pos = offset + _HEADER + 2
+    dims: list[int] = []
+    for _ in range(rank):
+        size = _u32(data, pos)
+        dims.append(VARIABLE if size == _U32_VARIABLE else size)
+        pos += 4
+    element, _ = _parse(data, pos)
+    return Array(code, name, element=element, dimensions=tuple(dims))
+
+
+def _parse_cluster(data: bytes, offset: int, code: int, name: str) -> Cluster:
+    count = _u16(data, offset + _HEADER)
+    pos = offset + _HEADER + 2
+    fields: list[TypeDesc] = []
+    for _ in range(count):
+        child, pos = _parse(data, pos)
+        fields.append(child)
+    return Cluster(code, name, fields=tuple(fields))
+
+
+def _parse_refnum(data: bytes, offset: int, end: int, code: int, name: str) -> Refnum:
+    payload = data[offset + _HEADER : end]
+    subtype = _u16(data, offset + _HEADER) if end - offset >= _HEADER + 2 else 0
+    return Refnum(code, name, subtype=subtype, payload=payload)

lvtypedesc/_pretty.py

@@ -0,0 +1,54 @@
+"""Render a parsed type descriptor as an indented, multi-line tree.
+
+This complements the one-line :func:`describe`. It is meant for reading a nested
+descriptor at a glance, so it spells out ranks, dimensions and field positions.
+"""
+
+from __future__ import annotations
+
+from ._model import (
+    VARIABLE,
+    Array,
+    Cluster,
+    FixedPoint,
+    LVString,
+    Refnum,
+    TypeDesc,
+)
+
+_STEP = "  "
+
+
+def pretty(node: TypeDesc) -> str:
+    """Return a multi-line, indented rendering of ``node`` and its children."""
+    return "\n".join(_lines(node, 0))
+
+
+def _dim(value: int) -> str:
+    return "variable" if value == VARIABLE else str(value)
+
+
+def _lines(node: TypeDesc, depth: int) -> list[str]:
+    pad = _STEP * depth
+    if isinstance(node, Array):
+        dims = ", ".join(_dim(d) for d in node.dimensions)
+        head = f"{pad}Array (rank {node.rank}, dims [{dims}])"
+        return [head, *_lines(node.element, depth + 1)]
+    if isinstance(node, Cluster):
+        head = f"{pad}Cluster ({len(node.fields)} fields)"
+        out = [head]
+        for index, child in enumerate(node.fields):
+            label = f"{_STEP * (depth + 1)}[{index}]"
+            child_lines = _lines(child, depth + 2)
+            first = child_lines[0].lstrip()
+            out.append(f"{label} {first}")
+            out.extend(child_lines[1:])
+        return out
+    if isinstance(node, LVString):
+        size = "variable" if node.size == VARIABLE else f"{node.size} bytes"
+        return [f"{pad}{node.name} (size {size})"]
+    if isinstance(node, Refnum):
+        return [f"{pad}Refnum (subtype 0x{node.subtype:02x})"]
+    if isinstance(node, FixedPoint):
+        return [f"{pad}FXP ({len(node.payload)}-byte payload)"]
+    return [f"{pad}{node.name}"]

lvtypedesc-0.2.0.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.5
+Name: lvtypedesc
+Version: 0.2.0
+Summary: Parse LabVIEW type-descriptor byte strings into a readable, typed schema
+Project-URL: Homepage, https://lianes8studio.com
+Project-URL: Repository, https://github.com/JaviLianes8/lvtypedesc
+Project-URL: Issues, https://github.com/JaviLianes8/lvtypedesc/issues
+Project-URL: Changelog, https://github.com/JaviLianes8/lvtypedesc/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
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: build; 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
+
+# lvtypedesc
+
+Parse LabVIEW type-descriptor byte strings into a readable, typed schema
+
+## Install
+
+```
+pip install lvtypedesc
+```
+
+A LabVIEW type descriptor is the small, length-prefixed block of type codes that
+precedes flattened LabVIEW data. This library turns that block into a typed tree
+you can inspect, which is the schema a generic unflatten needs.
+
+## Usage
+
+```python
+from lvtypedesc import parse_type_descriptor, describe, pretty, to_bytes
+
+# A 1D array of clusters, each holding an I32 and a string.
+data = bytes.fromhex(
+    "001C 0040 0001 FFFFFFFF 0012 0050 0002 0004 0003 0008 0030 FFFFFFFF".replace(" ", "")
+)
+
+node = parse_type_descriptor(data)
+print(describe(node))  # 1D Array of Cluster { I32, String }
+print(node.rank)  # 1
+print(node.element.fields[0].name)  # I32
+print(to_bytes(node) == data)  # True, round-trips exactly
+print(pretty(node))
+# Array (rank 1, dims [variable])
+#   Cluster (2 fields)
+#     [0] I32
+#     [1] String (size variable)
+```
+
+The tree is built from frozen dataclasses: `Scalar`, `Boolean`, `LVString` (with
+`size`), `Array` (with `element` and `dimensions`), `Cluster` (with `fields`),
+`FixedPoint` and `Refnum`. A dimension or string whose size is not fixed in the
+descriptor uses the sentinel `VARIABLE`. Trailing bytes, such as the flattened
+data after the descriptor, are ignored. Truncated, unknown or out-of-scope input
+raises `TypeDescError`.
+
+`to_bytes` re-emits the canonical short-form descriptor for any node the library
+models, so `parse_type_descriptor` and `to_bytes` are inverses for the supported
+subset. `TypeCode` exposes the recognised codes by name and `known_codes()`
+returns the full table.
+
+## Command line
+
+Installing the package also installs a `lvtypedesc` console script:
+
+```
+$ lvtypedesc decode 00040003
+I32
+$ lvtypedesc decode 000E00400001FFFFFFFF0004000A
+1D Array of DBL
+$ lvtypedesc decode --tree 000E00500002000400030004000A
+Cluster (2 fields)
+  [0] I32
+  [1] DBL
+$ lvtypedesc codes          # list every recognised type code
+$ lvtypedesc --version
+```
+
+Whitespace in the hex is ignored. Errors go to stderr with exit code 1. Run
+`lvtypedesc --help` for the full list of examples.
+
+## Supported subset
+
+Fully parsed: the numeric scalars (`I8` to `U64`, `SGL`, `DBL`, `EXT` and the
+complex variants), booleans, strings, paths, pictures, n-dimensional arrays and
+clusters, nested to any depth. Fixed-point (`FXP`) and refnum descriptors are
+recognised and their type-specific bytes preserved, but their internal layout is
+not interpreted (see provenance below).
+
+Not covered, and reported with a clear error: enums, variants and waveforms,
+whose payloads are not documented well enough to parse honestly.
+
+## Provenance (please read)
+
+The type-descriptor code table used here is **community reverse-engineering**,
+documented at the [LabVIEW wiki](https://labviewwiki.org/wiki/Type_descriptor).
+It is consistent with the fragments NI has published but it is **not** an
+official, byte-exact NI specification. Two further caveats:
+
+- Codes can change between LabVIEW versions, so treat them as the common
+  documented set rather than a guarantee for every build.
+- The in-memory 16-bit-word form and the flattened byte form can differ. This
+  library parses the flattened byte form.
+
+Because of this, anything that cannot be verified is treated as provisional:
+unknown codes raise an honest error instead of a guess, and the fixed-point and
+refnum payloads are kept as raw bytes rather than invented into fields. The
+refnum `subtype` word is surfaced best-effort and is itself provisional.
+
+## Why
+
+LabVIEW ships flattened data with a leading type descriptor, and decoding it in
+Python needs that descriptor parsed into a schema first. OpenG's Variant Data
+Library parses descriptors inside LabVIEW, but it is LabVIEW VIs, not Python. The
+existing PyPI packages read LabVIEW source files instead: `pylabview` and `lvkit`
+parse the `.vi` binary, `pylavi` validates VI files. None of them exposes a parser
+for the raw runtime type-descriptor byte string that precedes flattened data or
+sits inside a variant. This library fills that gap with a zero-dependency, fully
+typed reader for the common documented types.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+## Links
+
+- Website: https://lianes8studio.com
+- GitHub: https://github.com/JaviLianes8
+- LinkedIn: https://www.linkedin.com/in/jlianes/

lvtypedesc-0.2.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+lvtypedesc/__init__.py,sha256=qWMcxYKoxepoPwbrYag-v30l7xmObb-Ic0SYWWQ7PEE,782
+lvtypedesc/_cli.py,sha256=vTPtSt8g2WKzwf4YMFKKpq5VpsTxnQ19eVDHOqMxfM8,2919
+lvtypedesc/_codes.py,sha256=6M72TfbblERaL0XAMKfFw7UmuicOpBzbQSFWUozbR_4,3186
+lvtypedesc/_emit.py,sha256=MIHK0Lg1HXBL4QjXcy_ltQ2mk8thwqjsyaoA6LODJL8,1815
+lvtypedesc/_errors.py,sha256=yFS7B0CyC7wIUHQ4B_L3cORJFMqKhW0LDmqyX5x06HA,357
+lvtypedesc/_model.py,sha256=szDUs52GuCazK6BozpHHuJcaPHc6ghvkTe8PMMTMvRw,2723
+lvtypedesc/_parser.py,sha256=NEpe39QQwnBZGWI2uFptBLeBAJ8f3Lbs5q1no9QN3cw,4459
+lvtypedesc/_pretty.py,sha256=40EmR7CpMeWAIiYcxoocRHGa_8M4RhxnSJ7H_plxS5k,1747
+lvtypedesc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lvtypedesc-0.2.0.dist-info/METADATA,sha256=nztOqEr8I3KyUIILg5CA-IRoJKJJLhHaV1q0yp6Q0lE,5433
+lvtypedesc-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+lvtypedesc-0.2.0.dist-info/entry_points.txt,sha256=cFKuuV3WevGGmQy_2KFN801j22pVqEwTkiLsWJhb0uk,52
+lvtypedesc-0.2.0.dist-info/licenses/LICENSE,sha256=wirD5nCA2aQa5UusK_1YHLBogI3CGcw23xAnulp3L_U,1091
+lvtypedesc-0.2.0.dist-info/RECORD,,

lvtypedesc-0.2.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

lvtypedesc-0.2.0.dist-info/entry_points.txt

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

lvtypedesc-0.2.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.