vcti-tree-exporter-json 2.0.0__tar.gz

vcti_tree_exporter_json-2.0.0/LICENSE

@@ -0,0 +1,8 @@
+Copyright (c) 2018-2026 Visual Collaboration Technologies Inc.
+All Rights Reserved.
+
+This software is proprietary and confidential. Unauthorized copying,
+distribution, or use of this software, via any medium, is strictly
+prohibited. Access is granted only to authorized VCollab developers
+and individuals explicitly authorized by Visual Collaboration
+Technologies Inc.

vcti_tree_exporter_json-2.0.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: vcti-tree-exporter-json
+Version: 2.0.0
+Summary: JSON exporter plugin for vcti-tree-exporter: writes a vcti tree to a single .json document (nested nodes carrying name, attributes, and light arrays as JSON lists).
+Author: Visual Collaboration Technologies Inc.
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://github.com/vcollab/vcti-python-tree-exporter-json
+Project-URL: Repository, https://github.com/vcollab/vcti-python-tree-exporter-json
+Project-URL: Changelog, https://github.com/vcollab/vcti-python-tree-exporter-json/blob/main/CHANGELOG.md
+Keywords: tree,export,json,serialization,exporter,plugin
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: <3.15,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: vcti-tree-exporter>=2.0.0
+Requires-Dist: vcti-tree>=2.0.0
+Requires-Dist: vcti-datanode>=2.0.0
+Requires-Dist: numpy>=1.24
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Provides-Extra: typecheck
+Requires-Dist: mypy; extra == "typecheck"
+Dynamic: license-file
+
+# JSON Tree Exporter
+
+JSON exporter plugin for [`vcti-tree-exporter`](https://github.com/vcollab/vcti-python-tree-exporter): writes a vcti tree to a single `.json` document.
+
+`JsonExporter` serializes any [`vcti-tree`](https://github.com/vcollab/vcti-python-tree)
+tree whose node payloads are
+[`vcti-datanode`](https://github.com/vcollab/vcti-python-datanode) `DataNode`s
+to one JSON document that mirrors the tree, and ships a
+`get_exporter_descriptor()` factory so a consumer registers it in a catalog and
+resolves it by id (`"json"`) or by attribute lookup.
+
+JSON is a natural fit for **structure, metadata, and light arrays** — simulation
+settings, CAE metadata, input decks — that load straight into tooling. It is a
+poor fit for large numeric arrays (they become bulky nested lists); use HDF5 or
+NPZ for heavy data.
+
+## Installation
+
+```bash
+pip install vcti-tree-exporter-json
+```
+
+This pulls in `vcti-tree-exporter` (the protocol/catalog) and `numpy`.
+
+## Tree → JSON mapping
+
+Each node becomes an object; the document root is the tree's root node:
+
+```json
+{
+  "name": "model",
+  "attributes": {"solver": "abaqus"},
+  "children": [
+    {"name": "info", "attributes": {"count": 7}},
+    {"name": "displacement", "attributes": {}, "data": [1.0, 2.0, 3.0]}
+  ]
+}
+```
+
+| Tree node part | JSON |
+|---|---|
+| `node.name` | `"name"` (the structural name; `null` if unset) |
+| `node.attributes` | `"attributes"` object (always present) |
+| `node.load()` array | `"data"` as nested lists (present only for data nodes) |
+| children | `"children"` array (present only when non-empty) |
+
+A node may carry both `data` and `children`. Attribute values are JSON-encoded
+(bytes decoded, numpy scalars/arrays converted to numbers/lists); anything not
+natively serializable falls back to its `str()`. Array dtype is not preserved —
+the export is one-way.
+
+## Usage
+
+```python
+from pathlib import Path
+from vcti.tree.exporter.core import build_registry, get_exporter
+from vcti.tree.exporter.json import get_exporter_descriptor
+
+registry = build_registry([get_exporter_descriptor()])   # plus any other format plugins
+get_exporter(registry, "json").export(tree, Path("model.json"), overwrite=True)
+```
+
+Or use the exporter directly:
+
+```python
+from vcti.tree.exporter.json import JsonExporter
+JsonExporter().export(tree, Path("model.json"))
+```
+
+## Dependencies
+
+- [vcti-tree-exporter](https://github.com/vcollab/vcti-python-tree-exporter) — the `Exporter` protocol and the `ExporterDescriptor` catalog.
+- [vcti-tree](https://github.com/vcollab/vcti-python-tree) / [vcti-datanode](https://github.com/vcollab/vcti-python-datanode) — the tree and payload types.
+- numpy. (JSON encoding itself uses only the standard library.)

vcti_tree_exporter_json-2.0.0/README.md

@@ -0,0 +1,74 @@
+# JSON Tree Exporter
+
+JSON exporter plugin for [`vcti-tree-exporter`](https://github.com/vcollab/vcti-python-tree-exporter): writes a vcti tree to a single `.json` document.
+
+`JsonExporter` serializes any [`vcti-tree`](https://github.com/vcollab/vcti-python-tree)
+tree whose node payloads are
+[`vcti-datanode`](https://github.com/vcollab/vcti-python-datanode) `DataNode`s
+to one JSON document that mirrors the tree, and ships a
+`get_exporter_descriptor()` factory so a consumer registers it in a catalog and
+resolves it by id (`"json"`) or by attribute lookup.
+
+JSON is a natural fit for **structure, metadata, and light arrays** — simulation
+settings, CAE metadata, input decks — that load straight into tooling. It is a
+poor fit for large numeric arrays (they become bulky nested lists); use HDF5 or
+NPZ for heavy data.
+
+## Installation
+
+```bash
+pip install vcti-tree-exporter-json
+```
+
+This pulls in `vcti-tree-exporter` (the protocol/catalog) and `numpy`.
+
+## Tree → JSON mapping
+
+Each node becomes an object; the document root is the tree's root node:
+
+```json
+{
+  "name": "model",
+  "attributes": {"solver": "abaqus"},
+  "children": [
+    {"name": "info", "attributes": {"count": 7}},
+    {"name": "displacement", "attributes": {}, "data": [1.0, 2.0, 3.0]}
+  ]
+}
+```
+
+| Tree node part | JSON |
+|---|---|
+| `node.name` | `"name"` (the structural name; `null` if unset) |
+| `node.attributes` | `"attributes"` object (always present) |
+| `node.load()` array | `"data"` as nested lists (present only for data nodes) |
+| children | `"children"` array (present only when non-empty) |
+
+A node may carry both `data` and `children`. Attribute values are JSON-encoded
+(bytes decoded, numpy scalars/arrays converted to numbers/lists); anything not
+natively serializable falls back to its `str()`. Array dtype is not preserved —
+the export is one-way.
+
+## Usage
+
+```python
+from pathlib import Path
+from vcti.tree.exporter.core import build_registry, get_exporter
+from vcti.tree.exporter.json import get_exporter_descriptor
+
+registry = build_registry([get_exporter_descriptor()])   # plus any other format plugins
+get_exporter(registry, "json").export(tree, Path("model.json"), overwrite=True)
+```
+
+Or use the exporter directly:
+
+```python
+from vcti.tree.exporter.json import JsonExporter
+JsonExporter().export(tree, Path("model.json"))
+```
+
+## Dependencies
+
+- [vcti-tree-exporter](https://github.com/vcollab/vcti-python-tree-exporter) — the `Exporter` protocol and the `ExporterDescriptor` catalog.
+- [vcti-tree](https://github.com/vcollab/vcti-python-tree) / [vcti-datanode](https://github.com/vcollab/vcti-python-datanode) — the tree and payload types.
+- numpy. (JSON encoding itself uses only the standard library.)

vcti_tree_exporter_json-2.0.0/pyproject.toml

@@ -0,0 +1,82 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "vcti-tree-exporter-json"
+version = "2.0.0"
+description = "JSON exporter plugin for vcti-tree-exporter: writes a vcti tree to a single .json document (nested nodes carrying name, attributes, and light arrays as JSON lists)."
+readme = "README.md"
+authors = [
+    {name = "Visual Collaboration Technologies Inc."}
+]
+requires-python = ">=3.12,<3.15"
+license = "LicenseRef-Proprietary"
+license-files = ["LICENSE"]
+keywords = ["tree", "export", "json", "serialization", "exporter", "plugin"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+dependencies = [
+    "vcti-tree-exporter>=2.0.0",
+    "vcti-tree>=2.0.0",
+    "vcti-datanode>=2.0.0",
+    "numpy>=1.24",
+]
+
+[project.urls]
+Homepage = "https://github.com/vcollab/vcti-python-tree-exporter-json"
+Repository = "https://github.com/vcollab/vcti-python-tree-exporter-json"
+Changelog = "https://github.com/vcollab/vcti-python-tree-exporter-json/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["vcti.tree.exporter.json", "vcti.tree.exporter.json.*"]
+
+[tool.setuptools.package-data]
+"vcti.tree.exporter.json" = ["py.typed"]
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-cov"]
+lint = ["ruff"]
+typecheck = ["mypy"]
+
+[tool.setuptools]
+zip-safe = true
+
+[tool.pytest.ini_options]
+addopts = "--cov=vcti.tree.exporter.json --cov-report=term-missing --cov-fail-under=95"
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+files = ["src"]
+namespace_packages = true
+explicit_package_bases = true
+mypy_path = ["src"]
+
+[tool.coverage.run]
+branch = true
+
+[tool.coverage.report]
+exclude_also = [
+    "raise NotImplementedError",
+    "if TYPE_CHECKING:",
+    "if __name__ == .__main__.:",
+    "@(abc\\.)?abstractmethod",
+    "\\.\\.\\.",
+]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 99
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP"]

vcti_tree_exporter_json-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

vcti_tree_exporter_json-2.0.0/src/vcti/tree/exporter/json/__init__.py

@@ -0,0 +1,22 @@
+# Copyright Visual Collaboration Technologies Inc. All Rights Reserved.
+# See LICENSE for details.
+"""vcti.tree.exporter.json — JSON exporter plugin for vcti-tree-exporter.
+
+Provides :class:`JsonExporter`, which serializes a ``vcti.tree`` tree of
+``vcti.datanode.DataNode`` payloads to a single ``.json`` document (nested
+objects mirroring the hierarchy, with each node's name, attributes, and light
+arrays), and :func:`get_exporter_descriptor`, the catalog factory a consumer
+registers with ``vcti.tree.exporter.core.build_registry``.
+"""
+
+from importlib.metadata import version
+
+from .exporter import JsonExporter, get_exporter_descriptor
+
+__version__ = version("vcti-tree-exporter-json")
+
+__all__ = [
+    "JsonExporter",
+    "__version__",
+    "get_exporter_descriptor",
+]

vcti_tree_exporter_json-2.0.0/src/vcti/tree/exporter/json/exporter.py

@@ -0,0 +1,111 @@
+# Copyright Visual Collaboration Technologies Inc. All Rights Reserved.
+# See LICENSE for details.
+"""JSON exporter — write a vcti tree to a single JSON document.
+
+The tree maps directly onto JSON's own hierarchy: each node becomes an object
+
+    {"name": <str|null>, "attributes": {...}, "data": [...], "children": [...]}
+
+where ``data`` (the node's array, as nested lists) and ``children`` are present
+only when the node has them. The document root is the tree's root node.
+
+JSON is a natural fit for structure, metadata, and *light* arrays (simulation
+settings, CAE metadata); it is a poor fit for large numeric arrays, which
+become bulky nested lists — use HDF5 or NPZ for heavy data. Array dtype is not
+preserved (values become plain JSON numbers); this exporter is one-way.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from vcti.datanode import DataNode
+from vcti.tree.exporter.core import EXTENSION_ATTR, FORMAT_ATTR, ExporterDescriptor
+
+if TYPE_CHECKING:
+    from vcti.tree.core import ReadOnlyTree
+
+#: Fixed, well-known id for the JSON exporter descriptor.
+EXPORTER_ID = "json"
+
+
+def _json_default(value: Any) -> Any:
+    """Coerce a value JSON cannot serialize natively into a JSON-safe form."""
+    if isinstance(value, bytes):
+        return value.decode("utf-8", errors="replace").rstrip("\x00")
+    if isinstance(value, np.generic):
+        return value.item()
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    return str(value)  # last resort so one odd value never aborts the export
+
+
+class JsonExporter:
+    """Serialize a vcti tree to a single ``.json`` document.
+
+    Satisfies the ``vcti.tree.exporter.core.Exporter`` protocol structurally. Format
+    name and default extension live on its descriptor
+    (:func:`get_exporter_descriptor`), not on this class.
+    """
+
+    def export(
+        self,
+        tree: ReadOnlyTree[DataNode, Any],
+        path: Path,
+        *,
+        overwrite: bool = False,
+    ) -> None:
+        path = Path(path)
+        if path.exists() and not overwrite:
+            raise FileExistsError(f"Output file already exists: {path}")
+
+        root_obj = self._node_to_obj(tree, tree.root_handle)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("w", encoding="utf-8") as f:
+            json.dump(root_obj, f, indent=2, ensure_ascii=False, default=_json_default)
+
+    def _node_to_obj(
+        self,
+        tree: ReadOnlyTree[DataNode, Any],
+        handle: Any,
+    ) -> dict[str, Any] | None:
+        payload = tree.payload(handle)
+        if not isinstance(payload, DataNode):
+            return None
+
+        obj: dict[str, Any] = {"name": payload.name, "attributes": dict(payload.attributes)}
+
+        # load() materialises a data leaf and is a safe no-op (None) for a
+        # metadata-only node; restore the prior state for lazy sources.
+        was_loaded = payload.is_loaded
+        array = payload.load()
+        if array is not None:
+            obj["data"] = array.tolist()
+            if not was_loaded:
+                payload.unload()
+
+        children = [
+            child_obj
+            for child in tree.children(handle)
+            if (child_obj := self._node_to_obj(tree, child)) is not None
+        ]
+        if children:
+            obj["children"] = children
+        return obj
+
+
+def get_exporter_descriptor() -> ExporterDescriptor:
+    """Create the :class:`ExporterDescriptor` for the JSON exporter."""
+    return ExporterDescriptor(
+        id=EXPORTER_ID,
+        name="JSON Exporter",
+        exporter=JsonExporter(),
+        description="Writes a vcti tree to a single .json document.",
+        attributes={
+            FORMAT_ATTR: "json",
+            EXTENSION_ATTR: ".json",
+        },
+    )

vcti_tree_exporter_json-2.0.0/src/vcti_tree_exporter_json.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: vcti-tree-exporter-json
+Version: 2.0.0
+Summary: JSON exporter plugin for vcti-tree-exporter: writes a vcti tree to a single .json document (nested nodes carrying name, attributes, and light arrays as JSON lists).
+Author: Visual Collaboration Technologies Inc.
+License-Expression: LicenseRef-Proprietary
+Project-URL: Homepage, https://github.com/vcollab/vcti-python-tree-exporter-json
+Project-URL: Repository, https://github.com/vcollab/vcti-python-tree-exporter-json
+Project-URL: Changelog, https://github.com/vcollab/vcti-python-tree-exporter-json/blob/main/CHANGELOG.md
+Keywords: tree,export,json,serialization,exporter,plugin
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: <3.15,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: vcti-tree-exporter>=2.0.0
+Requires-Dist: vcti-tree>=2.0.0
+Requires-Dist: vcti-datanode>=2.0.0
+Requires-Dist: numpy>=1.24
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Provides-Extra: lint
+Requires-Dist: ruff; extra == "lint"
+Provides-Extra: typecheck
+Requires-Dist: mypy; extra == "typecheck"
+Dynamic: license-file
+
+# JSON Tree Exporter
+
+JSON exporter plugin for [`vcti-tree-exporter`](https://github.com/vcollab/vcti-python-tree-exporter): writes a vcti tree to a single `.json` document.
+
+`JsonExporter` serializes any [`vcti-tree`](https://github.com/vcollab/vcti-python-tree)
+tree whose node payloads are
+[`vcti-datanode`](https://github.com/vcollab/vcti-python-datanode) `DataNode`s
+to one JSON document that mirrors the tree, and ships a
+`get_exporter_descriptor()` factory so a consumer registers it in a catalog and
+resolves it by id (`"json"`) or by attribute lookup.
+
+JSON is a natural fit for **structure, metadata, and light arrays** — simulation
+settings, CAE metadata, input decks — that load straight into tooling. It is a
+poor fit for large numeric arrays (they become bulky nested lists); use HDF5 or
+NPZ for heavy data.
+
+## Installation
+
+```bash
+pip install vcti-tree-exporter-json
+```
+
+This pulls in `vcti-tree-exporter` (the protocol/catalog) and `numpy`.
+
+## Tree → JSON mapping
+
+Each node becomes an object; the document root is the tree's root node:
+
+```json
+{
+  "name": "model",
+  "attributes": {"solver": "abaqus"},
+  "children": [
+    {"name": "info", "attributes": {"count": 7}},
+    {"name": "displacement", "attributes": {}, "data": [1.0, 2.0, 3.0]}
+  ]
+}
+```
+
+| Tree node part | JSON |
+|---|---|
+| `node.name` | `"name"` (the structural name; `null` if unset) |
+| `node.attributes` | `"attributes"` object (always present) |
+| `node.load()` array | `"data"` as nested lists (present only for data nodes) |
+| children | `"children"` array (present only when non-empty) |
+
+A node may carry both `data` and `children`. Attribute values are JSON-encoded
+(bytes decoded, numpy scalars/arrays converted to numbers/lists); anything not
+natively serializable falls back to its `str()`. Array dtype is not preserved —
+the export is one-way.
+
+## Usage
+
+```python
+from pathlib import Path
+from vcti.tree.exporter.core import build_registry, get_exporter
+from vcti.tree.exporter.json import get_exporter_descriptor
+
+registry = build_registry([get_exporter_descriptor()])   # plus any other format plugins
+get_exporter(registry, "json").export(tree, Path("model.json"), overwrite=True)
+```
+
+Or use the exporter directly:
+
+```python
+from vcti.tree.exporter.json import JsonExporter
+JsonExporter().export(tree, Path("model.json"))
+```
+
+## Dependencies
+
+- [vcti-tree-exporter](https://github.com/vcollab/vcti-python-tree-exporter) — the `Exporter` protocol and the `ExporterDescriptor` catalog.
+- [vcti-tree](https://github.com/vcollab/vcti-python-tree) / [vcti-datanode](https://github.com/vcollab/vcti-python-datanode) — the tree and payload types.
+- numpy. (JSON encoding itself uses only the standard library.)

vcti_tree_exporter_json-2.0.0/src/vcti_tree_exporter_json.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/vcti/tree/exporter/json/__init__.py
+src/vcti/tree/exporter/json/exporter.py
+src/vcti/tree/exporter/json/py.typed
+src/vcti_tree_exporter_json.egg-info/PKG-INFO
+src/vcti_tree_exporter_json.egg-info/SOURCES.txt
+src/vcti_tree_exporter_json.egg-info/dependency_links.txt
+src/vcti_tree_exporter_json.egg-info/requires.txt
+src/vcti_tree_exporter_json.egg-info/top_level.txt
+src/vcti_tree_exporter_json.egg-info/zip-safe
+tests/test_exporter.py
+tests/test_version.py

vcti_tree_exporter_json-2.0.0/src/vcti_tree_exporter_json.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vcti_tree_exporter_json-2.0.0/src/vcti_tree_exporter_json.egg-info/requires.txt

@@ -0,0 +1,14 @@
+vcti-tree-exporter>=2.0.0
+vcti-tree>=2.0.0
+vcti-datanode>=2.0.0
+numpy>=1.24
+
+[lint]
+ruff
+
+[test]
+pytest
+pytest-cov
+
+[typecheck]
+mypy

vcti_tree_exporter_json-2.0.0/src/vcti_tree_exporter_json.egg-info/top_level.txt

@@ -0,0 +1 @@
+vcti

vcti_tree_exporter_json-2.0.0/src/vcti_tree_exporter_json.egg-info/zip-safe

@@ -0,0 +1 @@
+

vcti_tree_exporter_json-2.0.0/tests/test_exporter.py

@@ -0,0 +1,165 @@
+# Copyright Visual Collaboration Technologies Inc. All Rights Reserved.
+# See LICENSE for details.
+"""Tests for the JSON exporter."""
+
+from __future__ import annotations
+
+import json
+
+import numpy as np
+import pytest
+from vcti.datanode import DataNode, EagerDataSource, LazyDataSource
+from vcti.lookup import Rule
+from vcti.tree.core import DictTree
+from vcti.tree.exporter.core import (
+    EXTENSION_ATTR,
+    FORMAT_ATTR,
+    Exporter,
+    build_registry,
+    get_exporter,
+)
+
+from vcti.tree.exporter.json import JsonExporter, get_exporter_descriptor
+
+
+def _data(array: np.ndarray, *, name: str) -> DataNode:
+    return DataNode(name=name, data_source=EagerDataSource(array))
+
+
+def _sample_tree() -> DictTree:
+    tree: DictTree = DictTree(DataNode(name="model", source_attributes={"solver": "abaqus"}))
+    root = tree.root_handle
+
+    # metadata-only leaf with a bytes value, a numpy scalar, and None
+    tree.create_child(
+        root,
+        DataNode(
+            name="info",
+            source_attributes={
+                "count": np.int64(7),
+                "label": b"ABAQUS",
+                "missing": None,
+            },
+        ),
+    )
+
+    # group with a data leaf (light 1-D array) and a domain "name" attribute
+    materials = tree.create_child(root, DataNode(name="materials"))
+    tree.create_child(
+        materials,
+        DataNode(
+            name="material_0",
+            data_source=EagerDataSource(np.array([1.0, 2.0, 3.0])),
+            source_attributes={"id": 1, "name": "Steel"},
+        ),
+    )
+
+    # a non-DataNode payload is skipped
+    tree.create_child(root, "not-a-datanode")
+    return tree
+
+
+def _load(tmp_path, tree, name="out.json") -> dict:
+    out = tmp_path / name
+    JsonExporter().export(tree, out)
+    with out.open(encoding="utf-8") as f:
+        return json.load(f)
+
+
+def test_protocol_conformance():
+    assert isinstance(JsonExporter(), Exporter)
+
+
+def test_descriptor_factory_records_metadata():
+    desc = get_exporter_descriptor()
+    assert desc.id == "json"
+    assert isinstance(desc.exporter, JsonExporter)
+    assert desc.attributes[FORMAT_ATTR] == "json"
+    assert desc.attributes[EXTENSION_ATTR] == ".json"
+
+
+def test_document_root_is_the_tree_root(tmp_path):
+    doc = _load(tmp_path, _sample_tree())
+    assert doc["name"] == "model"
+    assert doc["attributes"]["solver"] == "abaqus"
+
+
+def test_nested_structure_names_and_attributes(tmp_path):
+    doc = _load(tmp_path, _sample_tree())
+    names = {child["name"] for child in doc["children"]}
+    assert names == {"info", "materials"}  # the non-DataNode child is skipped
+
+    info = next(c for c in doc["children"] if c["name"] == "info")
+    assert info["attributes"]["count"] == 7  # numpy scalar -> python int
+    assert info["attributes"]["label"] == "ABAQUS"  # bytes -> decoded str
+    assert info["attributes"]["missing"] is None
+    assert "children" not in info  # leaves carry no children key
+
+
+def test_data_leaf_serialised_as_list_with_attributes(tmp_path):
+    doc = _load(tmp_path, _sample_tree())
+    materials = next(c for c in doc["children"] if c["name"] == "materials")
+    (mat,) = materials["children"]
+    assert mat["data"] == [1.0, 2.0, 3.0]
+    # intrinsic name is the structural name; domain attribute "name" is separate
+    assert mat["name"] == "material_0"
+    assert mat["attributes"] == {"id": 1, "name": "Steel"}
+
+
+def test_ndarray_valued_attribute_becomes_list(tmp_path):
+    tree: DictTree = DictTree(DataNode(name="root"))
+    tree.create_child(
+        tree.root_handle,
+        DataNode(name="n", source_attributes={"D": np.array([1.0, 2.0, 3.0])}),
+    )
+    doc = _load(tmp_path, tree)
+    assert doc["children"][0]["attributes"]["D"] == [1.0, 2.0, 3.0]
+
+
+def test_unserialisable_attribute_falls_back_to_str(tmp_path):
+    tree: DictTree = DictTree(DataNode(name="root"))
+    tree.create_child(tree.root_handle, DataNode(name="thing", source_attributes={"x": {1, 2}}))
+    doc = _load(tmp_path, tree)
+    # a set is not JSON-native -> str() fallback
+    assert isinstance(doc["children"][0]["attributes"]["x"], str)
+
+
+def test_lazy_node_materialised_then_released(tmp_path):
+    tree: DictTree = DictTree(DataNode(name="root"))
+    node = DataNode(name="lazy", data_source=LazyDataSource(lambda: np.arange(3), shape=(3,)))
+    tree.create_child(tree.root_handle, node)
+    assert not node.is_loaded
+    doc = _load(tmp_path, tree)
+    assert doc["children"][0]["data"] == [0, 1, 2]
+    assert not node.is_loaded  # restored to the prior state
+
+
+def test_node_with_both_data_and_children_is_representable(tmp_path):
+    tree: DictTree = DictTree(DataNode(name="root"))
+    parent = tree.create_child(tree.root_handle, _data(np.array([9]), name="parent"))
+    tree.create_child(parent, DataNode(name="kid"))
+    doc = _load(tmp_path, tree)
+    parent_obj = doc["children"][0]
+    assert parent_obj["data"] == [9]
+    assert parent_obj["children"][0]["name"] == "kid"
+
+
+def test_overwrite_behavior(tmp_path):
+    out = tmp_path / "out.json"
+    JsonExporter().export(_sample_tree(), out)
+    with pytest.raises(FileExistsError):
+        JsonExporter().export(_sample_tree(), out)
+    JsonExporter().export(_sample_tree(), out, overwrite=True)  # no error
+
+
+def test_creates_parent_directories(tmp_path):
+    out = tmp_path / "nested" / "dir" / "out.json"
+    JsonExporter().export(_sample_tree(), out)
+    assert out.exists()
+
+
+def test_registry_integration():
+    registry = build_registry([get_exporter_descriptor()])
+    assert isinstance(get_exporter(registry, "json"), JsonExporter)
+    (desc,) = registry.lookup.filter([Rule(EXTENSION_ATTR, "==", ".json")])
+    assert desc.id == "json"

vcti_tree_exporter_json-2.0.0/tests/test_version.py

@@ -0,0 +1,15 @@
+# Copyright Visual Collaboration Technologies Inc. All Rights Reserved.
+# See LICENSE for details.
+"""Version tests for vcti-tree-exporter-json."""
+
+import re
+
+import vcti.tree.exporter.json
+
+
+class TestVersion:
+    def test_version_exists(self):
+        assert hasattr(vcti.tree.exporter.json, "__version__")
+
+    def test_version_is_valid_semver(self):
+        assert re.match(r"^\d+\.\d+\.\d+", vcti.tree.exporter.json.__version__)