lvkit 0.8.2__tar.gz → 0.8.4__tar.gz

{lvkit-0.8.2 → lvkit-0.8.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: lvkit
-Version: 0.8.2
+Version: 0.8.4
 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.8.2 → lvkit-0.8.4}/pyproject.toml

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

{lvkit-0.8.2 → lvkit-0.8.4}/src/lvkit/__init__.py

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

{lvkit-0.8.2 → lvkit-0.8.4}/src/lvkit/cache_paths.py

@@ -111,6 +111,35 @@ def _slug(path: Path) -> str:
     return f"{tail}-{h}"
 
 
+# The fixed short stem every MANAGED-cache artifact (extract/render/diff) uses
+# instead of the real VI's filename stem — the second Windows MAX_PATH axis
+# alongside the bounded ``vi-<hash>`` slot below. Owned by this module (the
+# single source of the cache-layout policy); ``extractor.py`` and
+# ``output_cache.py`` import it rather than repeating the literal.
+MANAGED_ARTIFACT_STEM = "vi"
+
+
+def _vi_slot(rel: Path) -> str:
+    """A per-VI cache dir name that is ALWAYS bounded, whatever the source tree's
+    depth: ``vi-`` + 16 hex of a sha256 of the owner-relative path.
+
+    Owned namespaces used to hang a VI's cache under ``<rel.parent>`` — the full
+    source-directory hierarchy reproduced beneath the cache root. A deep repo (or
+    a long VI filename) then pushed the final cache path past Windows' MAX_PATH
+    even with a short ``LVKIT_CACHE_DIR``, because BOTH the depth and the source
+    stem were unbounded inputs (the failure this replaces). Collapsing the whole
+    owner-relative path to one fixed-width hash segment removes the depth axis;
+    fixed short artifact names inside the slot remove the stem axis. The path is
+    keyed on the FULL ``rel`` (parent + filename), so every source VI maps to its
+    own slot and sibling VIs never collide. The real source path is NOT lost — it
+    is recorded as the ``source`` field of each slot's ``.meta.json`` sidecar
+    (see ``extractor._write_cache_meta`` / ``output_cache._write``). The
+    separators are normalized to ``/`` so the same VI hashes identically
+    regardless of how its path was spelled on this platform."""
+    key = rel.as_posix()
+    return "vi-" + hashlib.sha256(key.encode("utf-8")).hexdigest()[:16]
+
+
 def kind_fingerprint(kind: str) -> str:
     """The 8-hex build-compatibility tag stamped into a cache path for ``kind``.
 
@@ -215,14 +244,20 @@ def classify(vi_path: Path, kind: str) -> tuple[Path, str, str]:
     """Map ``vi_path`` to ``(cache_dir, source_label, namespace)`` for one
     artifact ``kind`` (``"extract"`` | ``"render"`` | ``"diff"``).
 
-    ``cache_dir`` is ``<cache>/<ns>/<slug>/<kind>/<fp>/<rel-parent>`` — project-
+    ``cache_dir`` is ``<cache>/<ns>/<slug>/<kind>/<fp>/vi-<hash>`` — project-
     first: the VI's identity (namespace + slug) is named ONCE and the ``kind``
-    hangs off it, so one project's whole cache is a single subtree and sibling VIs
-    of the same kind + build share a dir. ``<fp>`` is the per-kind build tag
-    (:func:`kind_fingerprint`) so two incompatible lvkit builds get separate slots
-    instead of clobbering each other. ``namespace`` is ``"projects"``,
+    hangs off it, so one project's whole cache is a single subtree. ``<fp>`` is
+    the per-kind build tag (:func:`kind_fingerprint`) so two incompatible lvkit
+    builds get separate slots instead of clobbering each other. ``vi-<hash>``
+    (:func:`_vi_slot`) is a bounded per-VI slot standing in for the owner-relative
+    directory hierarchy, so an arbitrarily deep source tree can never push the
+    cache path past Windows' MAX_PATH; the artifact names inside it are fixed and
+    short (``vi_BDHb.xml`` / ``vi.<ext>``) for the same reason. ``source_label``
+    stays the REAL owner-relative path (``str(rel)``) so the true source is
+    recorded in each slot's ``.meta.json``. ``namespace`` is ``"projects"``,
     ``"shared"``, or ``"adhoc"`` — callers path-address the first two and
-    content-address ``adhoc`` (its paths never repeat).
+    content-address ``adhoc`` (its paths never repeat; its dir is already a single
+    bounded ``_slug`` segment).
     """
     resolved = vi_path.resolve()
     cache = global_cache_root()
@@ -237,7 +272,7 @@ def classify(vi_path: Path, kind: str) -> tuple[Path, str, str]:
         rel = _rel_under(resolved, vilib)
         if rel is not None:
             _note_owner(vilib)
-            d = cache / "shared" / "vilib" / _slug(vilib) / kind / fp / rel.parent
+            d = cache / "shared" / "vilib" / _slug(vilib) / kind / fp / _vi_slot(rel)
             return d, str(rel), "shared"
 
     userlib = _userlib_root
@@ -245,7 +280,8 @@ def classify(vi_path: Path, kind: str) -> tuple[Path, str, str]:
         rel = _rel_under(resolved, userlib)
         if rel is not None:
             _note_owner(userlib)
-            d = cache / "shared" / "userlib" / _slug(userlib) / kind / fp / rel.parent
+            slug = _slug(userlib)
+            d = cache / "shared" / "userlib" / slug / kind / fp / _vi_slot(rel)
             return d, str(rel), "shared"
 
     project = _project_root_for(resolved)
@@ -253,7 +289,7 @@ def classify(vi_path: Path, kind: str) -> tuple[Path, str, str]:
         proj_abs = project.resolve()
         rel = resolved.relative_to(proj_abs)
         _note_owner(proj_abs)
-        d = cache / "projects" / _slug(proj_abs) / kind / fp / rel.parent
+        d = cache / "projects" / _slug(proj_abs) / kind / fp / _vi_slot(rel)
         return d, str(rel), "projects"
 
     # adhoc has NO owner (not a project, not a library) -> no identity slug to
@@ -474,7 +510,10 @@ def write_meta(vi_path: Path, meta_path: Path, **extra: object) -> None:
 # source/fingerprint change — that is handled by the <fp> path level). A mismatch
 # triggers a one-time drop of the derived namespaces in cleanup_legacy_cache.
 #   "2": project-first with a per-kind <fp> level and <tail>-<hash8> slugs.
-_LAYOUT_VERSION = "2"
+#   "3": owned VIs sit in a bounded per-VI ``vi-<hash>`` slot with fixed short
+#        artifact names (was the reproduced ``<rel.parent>`` hierarchy + source
+#        stem), so a deep source tree can't overflow Windows MAX_PATH.
+_LAYOUT_VERSION = "3"
 
 
 def cleanup_legacy_cache() -> None:

{lvkit-0.8.2 → lvkit-0.8.4}/src/lvkit/extractor.py

@@ -34,6 +34,7 @@ install_pylabview_patches()
 # pylabview). Re-exported here so long-standing callers of ``extractor.X`` (e.g.
 # ``graph.core`` -> ``extractor.set_extraction_roots``) keep working unchanged.
 from lvkit.cache_paths import (  # noqa: E402
+    MANAGED_ARTIFACT_STEM,
     _slug,
     classify,
     cleanup_legacy_cache,
@@ -179,7 +180,7 @@ def _make_read_po(**overrides: object) -> argparse.Namespace:
     return argparse.Namespace(**opts)
 
 
-def _extract_in_process(vi_path: Path, output_dir: Path, vi_stem: str) -> None:
+def _extract_in_process(vi_path: Path, output_dir: Path, artifact_stem: str) -> None:
     """Extract a VI to XML in-process, matching ``readRSRC -i <vi> -x``.
 
     pylabview places each block's sidecar XML (``_BDHb.xml`` etc.) in
@@ -190,17 +191,21 @@ def _extract_in_process(vi_path: Path, output_dir: Path, vi_stem: str) -> None:
     request concurrency. This avoids the per-call interpreter boot + pylabview
     re-import that the subprocess path pays on every extraction.
 
+    ``artifact_stem`` names the produced files — the caller's real VI stem for a
+    caller-owned ``output_dir``, or the fixed ``MANAGED_ARTIFACT_STEM`` in the
+    managed cache; it is NOT necessarily ``vi_path.stem``.
+
     Mirrors the option set that ``readRSRC.main()`` builds for the ``-x``
     (extract) subcommand via argparse.
     """
-    xml_path = output_dir / f"{vi_stem}.xml"
+    xml_path = output_dir / f"{artifact_stem}.xml"
     po = _make_read_po(
         rsrc=str(vi_path),
         xml=str(xml_path),
         textcp="mac_roman",
         raw_connectors=False,
         keep_names=False,
-        filebase=vi_stem,
+        filebase=artifact_stem,
         list=False,
         dump=False,
         extract=True,
@@ -214,8 +219,8 @@ def _extract_in_process(vi_path: Path, output_dir: Path, vi_stem: str) -> None:
     with open(xml_path, "wb") as xml_fh:
         tree.write(xml_fh, encoding="utf-8", xml_declaration=True)
     for path in output_dir.iterdir():
-        belongs_to_vi = path.name == f"{vi_stem}.xml" or path.name.startswith(
-            f"{vi_stem}_"
+        belongs_to_vi = path.name == f"{artifact_stem}.xml" or path.name.startswith(
+            f"{artifact_stem}_"
         )
         if path.suffix == ".xml" and belongs_to_vi:
             normalize_extracted_xml(path)
@@ -249,15 +254,24 @@ def extract_vi_xml(
     """
     vi_path = Path(vi_path).resolve()
 
-    if output_dir is None:
+    # A caller-supplied output_dir is caller-owned, so keep the real source stem
+    # in the artifact names there. The MANAGED cache (output_dir is None) uses a
+    # FIXED short stem instead: a long source filename would otherwise overflow
+    # the cache path once a ``_BDHb.xml`` suffix is appended — the second Windows
+    # MAX_PATH axis, paired with the bounded per-VI slot dir (cache_paths._vi_slot).
+    # The real source name/path is preserved for callers: the graph loader keys
+    # every node on the source path (never on this stem), and the ``source`` field
+    # of the ``.meta.json`` records the real owner-relative path.
+    managed = output_dir is None
+    if managed:
         output_dir = _cache_target(vi_path)
     output_dir.mkdir(parents=True, exist_ok=True)
 
-    vi_stem = vi_path.stem
-    bd_xml = output_dir / f"{vi_stem}_BDHb.xml"
-    fp_xml = output_dir / f"{vi_stem}_FPHb.xml"
-    main_xml = output_dir / f"{vi_stem}.xml"
-    meta_path = output_dir / f"{vi_stem}.meta.json"
+    artifact_stem = MANAGED_ARTIFACT_STEM if managed else vi_path.stem
+    bd_xml = output_dir / f"{artifact_stem}_BDHb.xml"
+    fp_xml = output_dir / f"{artifact_stem}_FPHb.xml"
+    main_xml = output_dir / f"{artifact_stem}.xml"
+    meta_path = output_dir / f"{artifact_stem}.meta.json"
 
     # Cache hit: XML present and the recorded content-hash (or mtime/size
     # fast-path) still matches the VI. The extraction-code compatibility check is
@@ -316,15 +330,15 @@ def extract_vi_xml(
     tmp_dir = Path(tempfile.mkdtemp(prefix=".x-", dir=_staging_root()))
     try:
         try:
-            _extract_in_process(vi_path, tmp_dir, vi_stem)
+            _extract_in_process(vi_path, tmp_dir, artifact_stem)
         except Exception as exc:
             raise RuntimeError(
                 f"pylabview extraction failed for {vi_path.name}: {exc}"
-                f"{_windows_long_path_hint(tmp_dir / f'{vi_stem}_BDHb.xml')}"
+                f"{_windows_long_path_hint(tmp_dir / f'{artifact_stem}_BDHb.xml')}"
             ) from exc
 
-        if not (tmp_dir / f"{vi_stem}_BDHb.xml").exists():
-            raise RuntimeError(f"Block diagram XML not found: {vi_stem}_BDHb.xml")
+        if not (tmp_dir / f"{artifact_stem}_BDHb.xml").exists():
+            raise RuntimeError(f"Block diagram XML not found: {artifact_stem}_BDHb.xml")
 
         # Publish every produced artifact atomically (same filesystem as the
         # temp dir), then meta.json last so its appearance marks the cache valid.

{lvkit-0.8.2 → lvkit-0.8.4}/src/lvkit/graph/builders/operations.py

@@ -99,6 +99,12 @@ class PrimitiveBuildHandler(NodeBuildHandler):
         if isinstance(node, (PropertyNode, InvokeNode, EventRegNode)):
             prim_kwargs["object_name"] = node.object_name
             prim_kwargs["object_method_id"] = node.object_method_id
+            # Property/Invoke nodes share the SAME implicit-binding fields
+            # (task #51/#55) -- EventRegNode has neither, so it's excluded
+            # here rather than duplicating this pair per elif branch below.
+            if isinstance(node, (PropertyNode, InvokeNode)):
+                prim_kwargs["bound_control_uid"] = node.bound_control_uid
+                prim_kwargs["bound_control_type"] = node.bound_control_type
             if isinstance(node, PropertyNode):
                 prim_kwargs["properties"] = [
                     PropertyDef(name=p.get("name", "")) if isinstance(p, dict) else p
@@ -107,8 +113,6 @@ class PrimitiveBuildHandler(NodeBuildHandler):
                 prim_kwargs["property_value_terminal_ids"] = [
                     ctx.qid(uid) for uid in node.dco_terminal_uids
                 ]
-                prim_kwargs["bound_control_uid"] = node.bound_control_uid
-                prim_kwargs["bound_control_type"] = node.bound_control_type
             elif isinstance(node, InvokeNode):
                 prim_kwargs["method_name"] = node.method_name
                 prim_kwargs["method_code"] = node.method_code

{lvkit-0.8.2 → lvkit-0.8.4}/src/lvkit/graph/loading.py

@@ -496,8 +496,10 @@ class LoadingMixin:
 
         for member in lib.members:
             if member.member_type == "VI":
-                member_name = Path(member.url).name
-                if member_name.lower().endswith(".ctl"):
+                member_url = Path(member.url)
+                member_name = member_url.name
+                member_suffix = member_url.suffix.lower()
+                if member_suffix == ".ctl":
                     # .ctl members are type definitions, not loadable VIs
                     typedef_qname = lib_qname + ":" + member_name
                     ctl_path = lvlib_path.parent / member.url
@@ -528,7 +530,7 @@ class LoadingMixin:
                             caller=lib_key,
                             rel="owns",
                         )
-                else:
+                elif member_suffix == ".vi":
                     member_qname = lib_qname + ":" + member_name
                     vi_path = lvlib_path.parent / member.url
                     if not vi_path.exists():
@@ -558,6 +560,21 @@ class LoadingMixin:
                             caller=lib_key,
                             rel="owns",
                         )
+                else:
+                    # A member the library XML declares Type="VI" but whose URL
+                    # is neither .vi nor .ctl -- a source-metadata anomaly, not
+                    # a code entity. No node, no stub (a stub means "a VI we
+                    # expect to resolve later", which is wrong here): warn and
+                    # move on rather than sending a non-VI file to load_vi
+                    # (which raises ValueError and would abort the whole load).
+                    logger.warning(
+                        'library %s declares member %r as Type="VI" but its '
+                        "URL %r is not a loadable .vi or .ctl file — skipping "
+                        "it.",
+                        lvlib_path.name,
+                        member.name,
+                        member.url,
+                    )
             elif member.member_type == "LVClass":
                 class_name = Path(member.url).name
                 class_path = lvlib_path.parent / member.url
@@ -647,13 +664,14 @@ class LoadingMixin:
         search_paths: list[Path] | None = None,
         owner_chain: list[str] | None = None,
     ) -> str:
-        """Load a .lvclass file. Returns the dep_graph qname it was
-        registered under (``cls_qname``, built from the ON-DISK file's own
-        stem casing) — the CALLER may have referenced this class under a
-        different casing (a type reference's recorded casing can differ
-        from the file's actual casing), so callers that add dep_graph edges
-        or aliases must use this return value, never re-derive/assume the
-        qname themselves (see ``_load_dependency``'s ``.lvclass`` branch).
+        """Load a .lvclass file. Returns the dep-graph KEY (the resolved
+        ``.lvclass`` path) it was registered under — mirrors ``load_lvlib``/
+        ``load_typedef``: callers add ownership/reference edges to THIS key,
+        never to the qname (``cls_qname``, built from the ON-DISK file's own
+        stem casing — the CALLER may have referenced this class under a
+        different casing, e.g. a type reference's recorded casing can differ
+        from the file's actual casing, so the qname alone isn't a safe edge
+        target; see ``_load_dependency``'s ``.lvclass`` branch).
 
         ``MINIMAL`` is an INTERFACE load: add the class's private-data fields
         (and its parent chain's, via walk-up — nMux field indices run into the
@@ -686,7 +704,9 @@ class LoadingMixin:
         # walks follow it by IDENTITY (a name can hit duplicates; a path
         # can't). None when the parent isn't on disk.
         parent = cls.parent_class
-        parent_file, parent_intended = self._resolve_parent(cls, lvclass_path)
+        parent_file, parent_intended = self._resolve_parent(
+            cls, lvclass_path, search_paths
+        )
         # The parent's KEY is its recorded path whether or not the file is staged
         # yet — so progressive (web) staging can NAME + fetch a not-yet-present
         # parent (an ``.exists()`` gate would drop the whole inherited surface).
@@ -832,6 +852,18 @@ class LoadingMixin:
             try:
                 pd_fields = private_data_from_lvclass_xml(lvclass_path)
             except Exception:
+                # Intentional hard best-effort boundary, not a narrowable
+                # set: private_data_from_lvclass_xml decodes a possibly
+                # malformed/legacy embedded RSRC container through
+                # pylabview's OWN VI-resource parser (parse_flattened_
+                # private_data -> lv_rsrc.VI(...).parseData()), whose
+                # exception surface on untrusted/old-format binary data
+                # isn't a documented closed set (struct/index/value/key
+                # errors and more have all been observed from that parser
+                # elsewhere) -- this docstring's own contract is "a
+                # malformed/older embedded control must never break class
+                # loading", so any failure here degrades to "no fields
+                # recovered", never propagates.
                 logger.debug(
                     "flattened private-data recovery failed for %s",
                     lvclass_path,
@@ -841,23 +873,119 @@ class LoadingMixin:
             fields = [private_data_field_to_cluster_field(f) for f in pd_fields]
         return fields
 
+    def _resolve_vilib_class_ref(
+        self,
+        parent_name: str,
+        path_tokens: list[str],
+        lvclass_path: Path,
+        search_paths: list[Path],
+    ) -> tuple[Path | None, Path | None]:
+        """Resolve a ``<vilib>``-rooted class reference's TOKENS (already
+        split — ``path_tokens[0] == "<vilib>"``) -> ``(parent_file,
+        parent_intended)``, via ``ParsedDependencyRef.resolve_against`` — the
+        EXACT SAME machinery a SubVI/type ``<vilib>`` dependency already
+        resolves through (``_resolve_dependency_path``), never a new
+        resolver. Shared by BOTH ``<vilib>``-rooted sources ``_resolve_parent``
+        can see (a plain-XML ``Parent`` Item's URL, and the binary
+        ``ParentClassLinkInfo``'s own recorded path — issue #84's #F1
+        correction: the URL case was previously naively joined, leaving a
+        literal ``<vilib>`` path component that never exists).
+
+        A configured ``vilib_root`` gives an exact, scan-free hit; otherwise
+        ``<vilib>`` maps onto ``search_paths`` (this loader's already-
+        configured SubVI roots) the same way, with ``_find_file``'s existing
+        bounded per-search-path lookup (used for every other unresolved
+        dependency) actually LOCATING the file when it's nested deeper than
+        a direct join reaches (e.g. actor-framework vendors ``Actor.lvclass``
+        under an extra ``Core/`` level the recorded path itself doesn't
+        record — LabVIEW's own vi.lib layout has no such prefix).
+        ``parent_intended`` is still produced via pure path math even when
+        no local file is found (one of ``vilib_root``/``search_paths[0]``),
+        so progressive/web staging can NAME + fetch it — never
+        ``.exists()``-gated away, same contract as the method-path code in
+        ``load_lvclass`` above."""
+        parent_file: Path | None = None
+        parent_intended: Path | None = None
+        dep_ref = ParsedDependencyRef(
+            name=parent_name + ".lvclass", path_tokens=path_tokens
+        )
+        candidate = dep_ref.resolve_against(
+            lvclass_path,
+            vilib_root=self._vilib_root,
+            userlib_root=self._userlib_root,
+            instrlib_root=self._instrlib_root,
+        )
+        if candidate is not None:
+            parent_intended = candidate
+            if candidate.exists():
+                parent_file = candidate
+        # Both the search_paths glob AND the search_paths[0]-as-vilib_root
+        # intended-path fallback are skipped once EITHER parent_file OR
+        # parent_intended is already known -- no point globbing when the
+        # exact vilib_root candidate already resolved, and no point
+        # recomputing parent_intended once parent_file has resolved (it's
+        # only ever consulted as parent_file's own fallback, never both).
+        if parent_file is None and parent_intended is None and search_paths:
+            parent_file = self._find_file(
+                parent_name + ".lvclass", search_paths, lvclass_path.parent
+            )
+        if parent_file is None and parent_intended is None and search_paths:
+            # No configured vilib_root — map <vilib> onto the first search
+            # root instead, so an absent parent still gets a deterministic
+            # (pure path math, no scan) intended path for web staging to
+            # name.
+            parent_intended = dep_ref.resolve_against(
+                lvclass_path, vilib_root=search_paths[0]
+            )
+        return parent_file, parent_intended
+
     def _resolve_parent(
-        self, cls: LVClass, lvclass_path: Path
+        self, cls: LVClass, lvclass_path: Path, search_paths: list[Path]
     ) -> tuple[Path | None, Path | None]:
         """The parent class's file (when present) and its INTENDED path
         (present or not) -> ``(parent_file, parent_intended)``.
 
         PREFERS the parent's own recorded URL (a DIRECT relative path — the
         parent commonly lives in a sibling subtree an up-tree walk can't
-        reach, e.g. ``../../Layer/Layer.lvclass``); falls back to a walk-up
-        by name only when no URL was recorded. Both None when the class has
-        no parent (or its parent is the root ``LabVIEW Object``).
+        reach, e.g. ``../../Layer/Layer.lvclass``) — UNLESS that URL is
+        itself ``<vilib>``-rooted (``cls.is_vilib_parent``, e.g.
+        ``"/<vilib>/ActorFramework/Actor/Actor.lvclass"``, verified against
+        Event Receiver Actor.lvclass's real ``Parent`` Item — a LEADING
+        SLASH, the marker, then forward-slash path components, NOT a normal
+        relative path), in which case it's tokenized and resolved via
+        ``_resolve_vilib_class_ref`` like any other vi.lib reference (issue
+        #84's #F1 correction — the naive join used to leave a literal
+        ``<vilib>`` path component that never exists).
+
+        When there's no URL but the parent's binary link record is
+        ``<vilib>``-rooted (``cls.parent_link_path``, issue #84 — e.g.
+        ``["<vilib>", "ActorFramework", "Actor", "Actor.lvclass"]``),
+        resolves it the SAME way via ``_resolve_vilib_class_ref``.
+
+        A NON-vilib link record (the "in-repo" PTH0 shape — no recorded
+        URL, parent lives elsewhere in the same tree) is deliberately left
+        to the existing bare-name walk-up below — ``resolve_against``'s
+        generic (non-``<vilib>``) branch reads leading EMPTY tokens as
+        ``..`` hops, a shape not verified against a real in-repo PTH0
+        record, so this stays scoped to what issue #84 actually asked for
+        rather than risking the already-working walk-up.
+
+        Falls back to a bare-name walk-up (``_walk_up_find`` —
+        filesystem-only, no search_paths, so it can't reach a cross-subtree
+        or vi.lib parent) when NEITHER a URL nor a resolved vilib link path
+        was found. Both None when the class has no parent (or its parent is
+        the root ``LabVIEW Object``).
         """
         parent = cls.parent_class
         parent_file: Path | None = None
         parent_intended: Path | None = None
         if parent and parent != "LabVIEW Object":
-            if cls.parent_url:
+            if cls.parent_url and cls.is_vilib_parent:
+                tokens = [t for t in cls.parent_url.split("/") if t]
+                parent_file, parent_intended = self._resolve_vilib_class_ref(
+                    parent, tokens, lvclass_path, search_paths
+                )
+            elif cls.parent_url:
                 # LabVIEW ``.lvclass`` URLs are relative to the class FILE
                 # treated as a directory (members read ``../X.vi``), so
                 # resolve against ``lvclass_path`` itself — that absorbs the
@@ -865,6 +993,10 @@ class LoadingMixin:
                 parent_intended = (lvclass_path / cls.parent_url).resolve()
                 if parent_intended.exists():
                     parent_file = parent_intended
+            elif cls.is_vilib_parent and cls.parent_link_path:
+                parent_file, parent_intended = self._resolve_vilib_class_ref(
+                    parent, cls.parent_link_path, lvclass_path, search_paths
+                )
             if parent_file is None and parent_intended is None:
                 parent_file = self._walk_up_find(
                     lvclass_path.parent, parent + ".lvclass"
@@ -1105,6 +1237,7 @@ class LoadingMixin:
         main_xml: Path | None,
         search_paths: list[Path],
         visited: set[str],
+        *,
         source_dir: Path | None = None,
         source_override: Path | None = None,
         mode: LoadMode = LoadMode.FULL,
@@ -1136,6 +1269,9 @@ class LoadingMixin:
                 bd_xml=bd_xml,
                 fp_xml=fp_xml if fp_xml and fp_xml.exists() else None,
                 main_xml=main_xml if main_xml and main_xml.exists() else None,
+                # Pin the parser's identity (name, source_path, warnings) to the
+                # real source path, not the fixed ``vi_BDHb.xml`` cache name.
+                source_override=source_override,
                 layout=self._want_layout,
             )
         )
@@ -1145,7 +1281,19 @@ class LoadingMixin:
         fp = vi.front_panel
         conpane = vi.connector_pane
 
-        unqualified_name = bd_xml.name.replace("_BDHb.xml", ".vi")
+        # The VI's real unqualified name comes from its SOURCE path when we have
+        # one (``source_override``), NOT from the extracted BD XML filename: the
+        # managed extraction cache names every artifact ``vi_BDHb.xml`` (a bounded
+        # fixed name — see ``extractor.extract_vi_xml``), so deriving the name from
+        # the XML would make every VI ``vi.vi``. The source path is authoritative
+        # and is threaded here for the top-level VI (``load_vi``) and every SubVI
+        # dependency (``_leaf_load_vi``). Only a raw ``*_BDHb.xml`` handed in
+        # directly (no source path) falls back to the XML-derived name.
+        unqualified_name = (
+            source_override.name
+            if source_override is not None
+            else bd_xml.name.replace("_BDHb.xml", ".vi")
+        )
         # own_qname is this VI's (possibly NON-unique) qualified name — kept only
         # for the self-dependency compare below and the qname reverse index. It
         # is NOT the identity: two on-disk copies (a source VI + its stripped
@@ -1639,19 +1787,19 @@ class LoadingMixin:
             owner_chain = parts[:-1] if len(parts) > 1 else None
             # MINIMAL: field-load the class (no method bodies) — enough for
             # by-name field names. FULL: load its whole method tree for codegen.
-            loaded_qname = self.load_lvclass(
+            loaded_key = self.load_lvclass(
                 resolved,
                 mode,
                 search_paths=search_paths,
                 owner_chain=owner_chain,
             )
             if caller_qname:
-                self._dep_graph.add_edge(caller_qname, loaded_qname)
+                self._dep_graph.add_edge(caller_qname, loaded_key)
             # See the walk-up branch above: alias rather than let a
             # differently-cased reference create a second, empty dep_graph
             # node that shadows the real (populated) one.
-            if qualified_name != loaded_qname:
-                self._qualified_aliases[qualified_name] = loaded_qname
+            if qualified_name != loaded_key:
+                self._qualified_aliases[qualified_name] = loaded_key
         elif leaf.endswith(".lvlib"):
             lib_key = self.load_lvlib(resolved, mode, search_paths=search_paths)
             if caller_qname:
@@ -1711,6 +1859,10 @@ class LoadingMixin:
                 search_paths=search_paths,
                 visited=set(),
                 source_dir=resolved.parent,
+                # ``resolved`` is this SubVI's real source ``.vi`` path — pin the
+                # VI's identity (key + unqualified name) to it, never to the
+                # fixed-name ``vi_BDHb.xml`` in the extraction cache.
+                source_override=resolved,
                 mode=child_mode,
             )
             if loaded_name:

{lvkit-0.8.2 → lvkit-0.8.4}/src/lvkit/graph/models.py

@@ -158,17 +158,18 @@ class PrimitiveNode(GraphNode):
     # reference terminal, but this structural id list always can. See
     # ``op_walk.correlate_property_terminals``.
     property_value_terminal_ids: list[str] = []
-    # Property node only: the BOUND front-panel control's own ddo uid (RAW,
-    # unqualified -- not this node's own qualified id) when this property
-    # node is IMPLICIT (permanently tied to a specific control, e.g. GTR's
-    # "Abort" boolean property node) -- "" for an EXPLICIT one (identity from
-    # a wired reference). See ``parser.node_types.PropertyNode``'s class
-    # docstring for the full heap discriminator (a direct ``<ddo>`` child +
-    # a ``<label>`` naming the control, both absent when explicit).
+    # Property/Invoke node only: the BOUND front-panel control's own ddo uid
+    # (RAW, unqualified -- not this node's own qualified id) when this node
+    # is IMPLICIT (permanently tied to a specific control, e.g. GTR's
+    # "Abort" boolean property node or its "Test Hierarchy Tree" invoke
+    # node) -- "" for an EXPLICIT one (identity from a wired reference). See
+    # ``parser.node_types.PropertyNode``/``InvokeNode``'s class docstrings
+    # for the full heap discriminator (a direct ``<ddo>`` child + a
+    # ``<label>`` naming the control, both absent when explicit).
     bound_control_uid: str = ""
     # The bound control's reconstructed LVType (``parser.fp_heap_type.
     # reconstruct_control_lvtype``, resolved at PARSE time against the
-    # front-panel heap -- see ``parser.vi._resolve_property_node_bound_types``).
+    # front-panel heap -- see ``parser.vi._resolve_bound_control_types``).
     # None for an explicit node, or an implicit one whose control class isn't
     # modeled by that reconstructor.
     bound_control_type: LVType | None = None

{lvkit-0.8.2 → lvkit-0.8.4}/src/lvkit/graph/parallel_parse.py

@@ -47,18 +47,27 @@ PARALLEL_THRESHOLD = 50
 # process-pool scheduling/pickling overhead across many small XML files.
 _BATCH_SIZE = 20
 
-_ParseItem = tuple[Path, Path | None, Path | None]
+# (vi_path, bd_xml, fp_xml, main_xml): vi_path is the REAL source .vi, carried so
+# the worker can pin the parser's identity to it — the managed cache names BD XML
+# ``vi_BDHb.xml`` (a bounded fixed name), so parsing without the real path would
+# label every VI ``vi.vi`` (see parse_vi's source_override).
+_ParseItem = tuple[Path, Path, Path | None, Path | None]
 
 
 def _parse_batch(items: list[_ParseItem]) -> dict[str, ParsedVI]:
-    """Worker entry point: parse a batch of (bd_xml, fp_xml, main_xml)
-    triples. Runs in a worker process. A single unparseable VI is skipped,
+    """Worker entry point: parse a batch of (vi_path, bd_xml, fp_xml, main_xml)
+    tuples. Runs in a worker process. A single unparseable VI is skipped,
     not fatal to the rest of the batch -- the caller's serial path parses it
     (and reports its error, same as today) when it finds no cache entry."""
     out: dict[str, ParsedVI] = {}
-    for bd_xml, fp_xml, main_xml in items:
+    for vi_path, bd_xml, fp_xml, main_xml in items:
         try:
-            out[str(bd_xml)] = parse_vi(bd_xml=bd_xml, fp_xml=fp_xml, main_xml=main_xml)
+            out[str(bd_xml)] = parse_vi(
+                bd_xml=bd_xml,
+                fp_xml=fp_xml,
+                main_xml=main_xml,
+                source_override=vi_path,
+            )
         except Exception:
             logger.debug("parallel parse: skipping %s", bd_xml, exc_info=True)
     return out
@@ -93,7 +102,7 @@ def parallel_parse_directory(
         except Exception:
             # Extraction failure -- let the serial path hit (and report) it.
             continue
-        resolved.append((bd_xml, fp_xml, main_xml))
+        resolved.append((vi_path, bd_xml, fp_xml, main_xml))
 
     if not resolved:
         return {}