lvkit 0.6.2__tar.gz → 0.7.0__tar.gz

{lvkit-0.6.2 → lvkit-0.7.0}/.gitignore

@@ -133,3 +133,10 @@ experiments/
 
 # Claude Code agent worktrees (transient)
 .claude/worktrees/
+
+# CI deploy keys — never commit
+pragmatest_deploy
+pragmatest_deploy.pub
+
+# @vscode/test-web downloads VS Code Web here (cwd-dependent) — ignore anywhere
+.vscode-test-web/

{lvkit-0.6.2 → lvkit-0.7.0}/.pre-commit-config.yaml

@@ -15,8 +15,13 @@ repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v5.0.0
     hooks:
+      # Issue-repro fixtures under tests/corpus/ are attached verbatim and are
+      # hashed in each PROVENANCE.md — they must stay byte-identical, so the
+      # whitespace/line-ending fixers skip them.
       - id: trailing-whitespace
+        exclude: ^tests/corpus/
       - id: end-of-file-fixer
+        exclude: ^tests/corpus/
       - id: check-yaml
       - id: check-toml
       - id: check-added-large-files
@@ -24,6 +29,7 @@ repos:
       - id: check-merge-conflict
       - id: mixed-line-ending
         args: ["--fix=lf"]
+        exclude: ^tests/corpus/
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.14.14

{lvkit-0.6.2 → lvkit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lvkit
-Version: 0.6.2
+Version: 0.7.0
 Summary: Understand and convert LabVIEW VIs to Python without a LabVIEW license
 Project-URL: Repository, https://github.com/pragmatest-dev/lvkit
 Project-URL: Issues, https://github.com/pragmatest-dev/lvkit/issues

{lvkit-0.6.2 → lvkit-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lvkit"
-version = "0.6.2"
+version = "0.7.0"
 description = "Understand and convert LabVIEW VIs to Python without a LabVIEW license"
 readme = "README.md"
 requires-python = ">=3.10"

lvkit-0.7.0/scripts/build_example_pages.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+# Regenerate the pragmatest.com lvkit example pages from PUBLIC sources cloned at
+# build time — no local corpus, no hand-staged fixtures. Every input is a public
+# git ref, so this runs identically on a fresh CI runner and on a dev box.
+#
+#   scripts/build_example_pages.sh <output-dir>
+#
+# Produces, under <output-dir>:
+#   render/testcase.html  — JKI VI Tester TestCase/run.vi @ tag 3.0.0
+#   diff/testcase.html    — that VI 3.0.0 (base) -> 3.0.1 (head)
+#   render/md5.html       — OpenG MD5 Message Digest (Binary String)__ogtk.vi
+#
+# Sources (both OSI-approved, redistributable):
+#   JKI-VI-Tester   BSD-3-Clause   github.com/JKISoftware/JKI-VI-Tester
+#   OpenG Toolkit   BSD-3-Clause   reproduced from upstream .vip via scripts/
+set -euo pipefail
+
+OUT="${1:?usage: build_example_pages.sh <output-dir>}"
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+mkdir -p "$OUT/render" "$OUT/diff"
+OUT="$(cd "$OUT" && pwd)"  # absolute — lvk() renders from $ROOT, OUT must not be relative to it
+WORK="$(mktemp -d)"
+trap 'rm -rf "$WORK"' EXIT
+
+lvk() { ( cd "$ROOT" && uv run lvkit "$@" ); }
+
+# --- JKI VI Tester: TestCase/run.vi at 3.0.0 (base) vs 3.0.1 (head) -----------
+# run_base = the committed run.vi at tag 3.0.0; run_head = the same file at 3.0.1
+# (JKI wrapped several nodes in a new Case between those releases). Both are real
+# public commits — extracted with `git show`, never hand-edited.
+JKI="$WORK/JKI-VI-Tester"
+RUNVI="source/Classes/TestCase/run.vi"
+echo "clone JKI-VI-Tester (BSD-3-Clause)"
+git clone --quiet https://github.com/JKISoftware/JKI-VI-Tester.git "$JKI"
+git -C "$JKI" show 3.0.0:"$RUNVI" > "$WORK/run_base.vi"
+git -C "$JKI" show 3.0.1:"$RUNVI" > "$WORK/run_head.vi"
+
+echo "→ render: testcase  ($OUT/render/testcase.html)"
+lvk render "$WORK/run_base.vi" --format html --search-path "$JKI/source" \
+    --no-cache -o "$OUT/render/testcase.html"
+
+echo "→ diff:   testcase  ($OUT/diff/testcase.html)"
+lvk diff "$WORK/run_base.vi" "$WORK/run_head.vi" --format html \
+    --search-path "$JKI/source" --no-cache -o "$OUT/diff/testcase.html"
+
+# --- OpenG MD5 (BSD-3-Clause), reproduced from upstream .vip packages ---------
+OPENG="$WORK/openg"
+echo "reproduce OpenG corpus (BSD-3-Clause; fetches upstream .vip)"
+uv run python "$ROOT/scripts/reproduce_openg_corpus.py" "$OPENG"
+MD5="$OPENG/File Group 0/user.lib/_OpenG.lib/md5/md5.llb/MD5 Message Digest (Binary String)__ogtk.vi"
+
+echo "→ render: md5       ($OUT/render/md5.html)"
+lvk render "$MD5" --format html --search-path "$OPENG" \
+    --no-cache -o "$OUT/render/md5.html"
+
+echo "done → $OUT"

{lvkit-0.6.2 → lvkit-0.7.0}/src/lvkit/__init__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-__version__ = "0.6.2"
+__version__ = "0.7.0"
 
 # The public API is exposed LAZILY (PEP 562 module ``__getattr__``): the graph /
 # parser / structure stacks (networkx, pydantic, pylabview, PIL — ~230 ms) load

{lvkit-0.6.2 → lvkit-0.7.0}/src/lvkit/_pylabview_patches.py

@@ -44,6 +44,7 @@ with warnings.catch_warnings():
     warnings.simplefilter("ignore", SyntaxWarning)
     import pylabview.LVblock as _lv_block  # type: ignore[import-untyped]
     import pylabview.LVdatatype as _lv_datatype  # type: ignore[import-untyped]
+    import pylabview.LVheap as _lv_heap  # type: ignore[import-untyped]
     import pylabview.LVmisc as _lv_misc  # type: ignore[import-untyped]
     import pylabview.LVrsrcontainer as _lv_rsrc  # type: ignore[import-untyped]
     import pylabview.LVxml as _lv_xml  # type: ignore[import-untyped]
@@ -283,4 +284,46 @@ def install_pylabview_patches() -> None:
     _resilient_tdlist.__wrapped__ = _orig_tdlist  # type: ignore[attr-defined]
     _lv_block.VCTP.exportXMLTypeDescList = _resilient_tdlist
 
+    # (7) HeapNodeString.prepareContentXML — byte-EXACT binary DefaultData.
+    # pylabview serializes every string heap value by decoding the raw bytes
+    # through a text codec (``self.content.decode(self.vi.textEncoding)``). For a
+    # binary ``DefaultData`` value — a constant's FLATTENED bytes: a 4-byte
+    # big-endian length prefix + content — any byte >= 0x80 is not representable
+    # in the mac_roman -> native transcode (``normalize_extracted_xml``) and
+    # collapses to U+FFFD, which our ``decode_xml_entities_to_bytes`` recovers as
+    # 0xFD. So a 250-byte string whose length prefix is ``00 00 00 FA`` reads back
+    # as 253, and the constant decodes to an EMPTY string (the whole 22-line
+    # dictionary constant renders as a blank box). LabVIEW display TEXT
+    # (labels / node & method names / format strings) legitimately rides the
+    # mac_roman + normalize path and must stay literal, so we rewrite ONLY the
+    # binary ``OF__DefaultData`` tag: emit each byte as a printable-ASCII literal
+    # or an ``&#xNN;`` entity of the byte value — exactly the byte-entity form the
+    # constant reader and the text-encoding tests already expect. Entities are
+    # ASCII, so ``normalize_extracted_xml`` leaves them untouched and the reader
+    # recovers each byte; the value's final code page is then applied by
+    # ``decode_labview_text`` (so a CJK string constant still decodes correctly).
+    _default_data_tag = _lv_heap.OBJ_FIELD_TAGS.OF__DefaultData
+    _orig_prep = _lv_heap.HeapNodeString.prepareContentXML
+
+    def _byte_exact_default_data(self, fname_base):  # type: ignore[no-untyped-def]
+        content = self.content
+        if (
+            self.tagEn != _default_data_tag
+            or content is None
+            or isinstance(content, bool)
+        ):
+            return _orig_prep(self, fname_base)
+        out = []
+        for b in content:
+            # printable ASCII (minus the wrapping quote and XML/CDATA-special
+            # bytes) stays literal; everything else -> exact byte entity, so the
+            # value round-trips byte-for-byte through CDATA + normalize.
+            if 0x20 <= b <= 0x7E and b not in (0x22, 0x26, 0x3C, 0x3E):
+                out.append(chr(b))
+            else:
+                out.append(f"&#x{b:02x};")
+        return '"' + "".join(out) + '"'
+
+    _lv_heap.HeapNodeString.prepareContentXML = _byte_exact_default_data
+
     _installed = True