nmhit 0.3.1__tar.gz → 0.3.2__tar.gz

{nmhit-0.3.1 → nmhit-0.3.2}/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.20)
 # Keep this version in sync with [project] version in pyproject.toml.
-project(neml2-hit VERSION 0.3.1 LANGUAGES CXX)
+project(neml2-hit VERSION 0.3.2 LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

{nmhit-0.3.1 → nmhit-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nmhit
-Version: 0.3.1
+Version: 0.3.2
 Summary: Python bindings for the nmhit NEML2-flavored HIT parser
 License: MIT
 Classifier: Programming Language :: Python :: 3

{nmhit-0.3.1 → nmhit-0.3.2}/generated/Lexer.cpp

@@ -736,7 +736,7 @@ static const YY_CHAR yy_ec[256] =
 
        23,   10,   10,   10,   24,   10,   10,   25,   10,   26,
        27,   10,   10,   28,   10,   10,   29,   30,   10,   10,
-       10,   10,   31,    1,   32,    1,    1,    1,    1,    1,
+       10,   10,   31,    1,   32,   10,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,

{nmhit-0.3.1 → nmhit-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "nmhit"
-version = "0.3.1"  # Keep in sync with VERSION in CMakeLists.txt.
+version = "0.3.2"  # Keep in sync with VERSION in CMakeLists.txt.
 description = "Python bindings for the nmhit NEML2-flavored HIT parser"
 readme = "README.md"
 requires-python = ">=3.9"

nmhit-0.3.2/python/tests/test_nmhit.py

@@ -0,0 +1,277 @@
+"""Pytest test suite for the nmhit Python bindings.
+
+Scope is intentionally narrow: each test verifies that a Python-exposed
+binding is reachable AND returns / accepts the right Python type. Parser
+semantics (int / float / bool parsing, brace expansion, round-trip,
+override-wins, error messages, ...) are tested in tests/test_hit.cpp;
+duplicating those here just means two test suites have to be kept in
+sync for the same feature.
+
+What lives here:
+
+* Class + free-function existence (``isinstance(root, nmhit.Root)``,
+  ``nmhit.parse_text`` callable, ``nmhit.NodeType`` enum reachable).
+* Type-erasing wrappers and helpers that exist *only* in Python
+  (``nmhit.param`` auto-dispatch, ``nmhit-format`` CLI).
+* Python-side machinery the C++ tests can't reach: ``Path``/str
+  acceptance, kwarg names, ``__repr__``, ``Error`` subclassing
+  ``RuntimeError``, child references surviving parent GC.
+
+What does NOT live here: anything where the body would amount to "call
+the binding, then re-test the C++ behaviour the call delegates to."
+"""
+
+import gc
+
+import pytest
+
+import nmhit
+
+
+# ── module surface ────────────────────────────────────────────────────────────
+
+
+def test_module_classes_exposed():
+    """The C++ types we expose by name in __init__.pyi are real Python
+    attributes (not stubs the user can't actually construct against)."""
+    for name in (
+        "Root",
+        "Section",
+        "Field",
+        "Comment",
+        "Blank",
+        "NodeType",
+        "Error",
+    ):
+        assert hasattr(nmhit, name), f"nmhit.{name} missing"
+
+
+def test_error_subclasses_runtime_error():
+    """nmhit.Error is bound as a RuntimeError subclass so generic
+    ``except RuntimeError`` paths in user code catch it."""
+    assert issubclass(nmhit.Error, RuntimeError)
+
+
+def test_node_type_enum_round_trip():
+    """NodeType is bound as a proper enum -- each value is comparable to
+    itself across separate parses (rules out the stub-int-constant trap)."""
+    root_a = nmhit.parse_text("[s]\n  k = 1\n[]")
+    root_b = nmhit.parse_text("[t]\n[]")
+    assert root_a.type() == nmhit.NodeType.Root == root_b.type()
+    assert root_a.find("s").type() == nmhit.NodeType.Section
+    assert root_a.find("s/k").type() == nmhit.NodeType.Field
+
+
+# ── parse entry points ────────────────────────────────────────────────────────
+
+
+def test_parse_text_returns_root():
+    assert isinstance(nmhit.parse_text("k = 42"), nmhit.Root)
+
+
+def test_parse_file_accepts_pathlike(tmp_path):
+    """parse_file's path argument accepts both pathlib.Path and str."""
+    f = tmp_path / "test.i"
+    f.write_text("x = 7\n")
+    assert isinstance(nmhit.parse_file(f), nmhit.Root)
+    assert isinstance(nmhit.parse_file(str(f)), nmhit.Root)
+
+
+def test_parse_text_pre_post_kwargs():
+    """pre / post are keyword-argument bindings (positional ordering and
+    name spelled correctly on the Python side)."""
+    root = nmhit.parse_text("b = 2", pre=["a = 1"], post=["b := 99"])
+    assert root.param_int("a") == 1
+    assert root.param_int("b") == 99
+
+
+def test_parse_file_pre_kwarg(tmp_path):
+    f = tmp_path / "test.i"
+    f.write_text("b = 2\n")
+    root = nmhit.parse_file(f, pre=["a = 1"])
+    assert root.param_int("a") == 1
+
+
+# ── find / children ───────────────────────────────────────────────────────────
+
+
+def test_find_missing_returns_none():
+    """A missing path returns Python None (not raises, not a NULL pointer
+    surfaced as a crash)."""
+    root = nmhit.parse_text("k = 1")
+    assert root.find("nonexistent") is None
+
+
+def test_children_filter_returns_correct_subclass():
+    """``children(NodeType.X)`` returns instances of the right
+    concrete Python subclass (Field / Section / Comment / Blank)."""
+    src = "# comment\n\na = 1\n[s]\n[]\n"
+    root = nmhit.parse_text(src)
+    assert all(isinstance(n, nmhit.Comment) for n in root.children(nmhit.NodeType.Comment))
+    assert all(isinstance(n, nmhit.Blank) for n in root.children(nmhit.NodeType.Blank))
+    assert all(isinstance(n, nmhit.Field) for n in root.children(nmhit.NodeType.Field))
+    assert all(isinstance(n, nmhit.Section) for n in root.children(nmhit.NodeType.Section))
+
+
+# ── keepalive / lifetime ──────────────────────────────────────────────────────
+
+
+def test_child_ref_survives_root_drop():
+    """A node grabbed off a Root must keep the Root alive (nanobind
+    keep_alive policy). Without this, GC would free the C++ tree out
+    from under the Python handle."""
+    node = nmhit.parse_text("[s]\n  k = 99\n[]").find("s/k")
+    gc.collect()
+    assert node.param_int() == 99
+
+
+def test_children_element_survives_list_drop():
+    """Same keepalive contract for elements returned from children()."""
+    root = nmhit.parse_text("a = 1\nb = 2")
+    kids = root.children()
+    kid = kids[0]
+    del kids
+    gc.collect()
+    assert kid.path() in ("a", "b")
+
+
+# ── parent / root_node ────────────────────────────────────────────────────────
+
+
+def test_parent_returns_section():
+    """parent() returns a Python-typed node (not the raw void* you'd get
+    if the binding skipped the type-dispatch shim)."""
+    root = nmhit.parse_text("[s]\n  k = 1\n[]")
+    parent = root.find("s/k").parent()
+    assert isinstance(parent, nmhit.Section)
+    assert parent.path() == "s"
+
+
+def test_root_node_returns_root():
+    root = nmhit.parse_text("[s]\n  k = 1\n[]")
+    r = root.find("s/k").root_node()
+    assert isinstance(r, nmhit.Root)
+
+
+# ── error forwarding ──────────────────────────────────────────────────────────
+
+
+def test_parse_error_is_nmhit_error():
+    """Parse failures raise nmhit.Error (forwarded from C++ exception)."""
+    with pytest.raises(nmhit.Error):
+        nmhit.parse_text("[mesh]\n  dim = 3")
+
+
+def test_error_messages_attribute():
+    """The Error instance carries a ``messages`` list of ErrorMessage
+    objects with line / column / message / filename attributes (struct
+    binding)."""
+    with pytest.raises(nmhit.Error) as exc_info:
+        nmhit.parse_text("[mesh]\n  dim = 3")
+    msgs = exc_info.value.messages
+    assert isinstance(msgs, list)
+    if msgs:
+        m = msgs[0]
+        for attr in ("line", "column", "message", "filename"):
+            assert hasattr(m, attr), f"ErrorMessage.{attr} missing"
+
+
+def test_parse_file_missing_raises():
+    """Filesystem-not-found is forwarded as nmhit.Error, not as a bare
+    Python FileNotFoundError or a segfault."""
+    with pytest.raises(nmhit.Error):
+        nmhit.parse_file("/nonexistent/path/file.i")
+
+
+# ── tree mutation bindings ────────────────────────────────────────────────────
+
+
+def test_field_constructor_callable_from_python():
+    """nmhit.Field(name, value) constructor exposed for tree building."""
+    f = nmhit.Field("k", "42")
+    assert isinstance(f, nmhit.Field)
+
+
+def test_add_child_round_trip():
+    """add_child / param_int are reachable bindings on Root."""
+    root = nmhit.parse_text("")
+    root.add_child(nmhit.Field("k", "42"))
+    assert root.param_int("k") == 42
+
+
+def test_remove_child_returns_typed_node():
+    """remove_child returns the right Python-typed node (Field here)."""
+    root = nmhit.parse_text("k = 42")
+    removed = root.remove_child("k")
+    assert isinstance(removed, nmhit.Field)
+
+
+# ── Comment binding ──────────────────────────────────────────────────────────
+
+
+def test_comment_inline_property():
+    """Comment.is_inline / set_inline are exposed as a callable
+    getter+setter pair (not a Python property — match what the C++
+    side declares)."""
+    c = nmhit.Comment("hello", is_inline=True)
+    assert c.is_inline() is True
+    c.set_inline(False)
+    assert c.is_inline() is False
+
+
+# ── repr ─────────────────────────────────────────────────────────────────────
+
+
+def test_node_repr_contains_class_name():
+    """__repr__ bindings produce something human-readable that names
+    the concrete subclass."""
+    assert "Root" in repr(nmhit.parse_text(""))
+
+
+# ── nmhit.param: Python-only auto-dispatch helper ────────────────────────────
+# Has no C++ counterpart -- the C++ API is one method per type.
+
+
+def test_param_auto_int():
+    root = nmhit.parse_text("k = 42")
+    val = nmhit.param(root, "k")
+    assert isinstance(val, int) and val == 42
+
+
+def test_param_auto_float():
+    root = nmhit.parse_text("x = 3.14")
+    val = nmhit.param(root, "x")
+    assert isinstance(val, float)
+
+
+def test_param_auto_bool():
+    root = nmhit.parse_text("flag = true")
+    assert nmhit.param(root, "flag") is True
+
+
+def test_param_auto_str():
+    root = nmhit.parse_text("name = hello")
+    val = nmhit.param(root, "name")
+    assert isinstance(val, str) and val == "hello"
+
+
+def test_param_with_explicit_type_hint():
+    """Passing an explicit type forces the converter -- exercises the
+    Python-side dispatch table."""
+    root = nmhit.parse_text("n = 5")
+    val = nmhit.param(root, "n", float)
+    assert isinstance(val, float) and val == 5.0
+
+
+# ── verbatim → non-string read forwarding ─────────────────────────────────────
+
+
+def test_verbatim_field_raises_on_non_str_getter():
+    """Verbatim (triple-quoted) fields can only be read as strings; every
+    other ``param_*`` getter raises nmhit.Error. Pinned here because the
+    error path crosses the bindings boundary."""
+    root = nmhit.parse_text("k = '''42'''")
+    assert root.param_str("k") == "42"
+    for getter in ("param_int", "param_float", "param_bool", "param_list_int"):
+        with pytest.raises(nmhit.Error, match="verbatim"):
+            getattr(root, getter)("k")

{nmhit-0.3.1 → nmhit-0.3.2}/src/Lexer.l

@@ -36,7 +36,7 @@ DIGIT      [0-9]
 EXP        [eE][+\-]?[0-9]+
 FLOAT      ({SIGN}?([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)([eE][+\-]?[0-9]+)?|{SIGN}?[0-9]+[eE][+\-]?[0-9]+)
 INTEGER    {SIGN}?[0-9]+
-IDENT      [A-Za-z0-9_.\/<>+\-*!]+
+IDENT      [A-Za-z0-9_.\/<>+\-*!~]+
 COMMENT    #[^\n]*
 
 %%

{nmhit-0.3.1 → nmhit-0.3.2}/src/Node.cpp

@@ -441,7 +441,17 @@ Node::_raw_string(const Node * n)
 {
   auto * f = as_field(n);
   if (f->is_verbatim())
-    return f->raw_val(); // verbatim: no unquoting, no brace expansion
+  {
+    // Verbatim (triple-quoted) bodies are stored without their surrounding
+    // ''' / """ delimiters, so no unquoting step is needed. Brace expansion
+    // is still applied for parity with single-quoted strings -- this lets
+    // users interpolate `${var}` into multi-line Python blocks (NEML2
+    // benchmark inputs rely on this for ${nbatch} substitution).
+    const auto & v = f->raw_val();
+    if (has_brace_expr(v))
+      return expand_brace_expr(v, n);
+    return v;
+  }
   return parse_string(f->raw_val(), n);
 }
 

{nmhit-0.3.1 → nmhit-0.3.2}/tests/test_hit.cpp

@@ -861,6 +861,64 @@ main()
     EXPECT(root->param<int>("Models/k") == 1);
   });
 
+  // ── tilde in identifiers ──────────────────────────────────────────────────
+  // NEML2 uses ``var~1`` to denote "state at start of step" history variables;
+  // the parser has to accept ``~`` in field names + section path components.
+
+  run("ident_with_tilde_field_name", []() {
+    auto root = p("strain~1 = 42");
+    EXPECT(root->param<int>("strain~1") == 42);
+  });
+
+  run("ident_with_tilde_field_inside_section", []() {
+    auto root = p("[Settings]\n  elastic_strain~1 = '(2; 5)'\n[]");
+    auto * sec = root->find("Settings");
+    EXPECT(sec != nullptr);
+    EXPECT(sec->param<std::string>("elastic_strain~1") == "(2; 5)");
+  });
+
+  run("ident_with_tilde_section_path", []() {
+    auto root = p("[a~1]\n  k = 7\n[]");
+    auto * sec = root->find("a~1");
+    EXPECT(sec != nullptr);
+    EXPECT(sec->param<int>("k") == 7);
+  });
+
+  // ── brace expansion in triple-quoted strings ─────────────────────────────
+  // Verbatim triple-quoted bodies now go through the same ${var} expansion
+  // pass as single-quoted strings -- the verbatim flag controls quote
+  // stripping + delimiter preservation, not interpolation.
+
+  run("triple_single_quoted_brace_expansion", []() {
+    auto root = p("n = 5\n[blk]\n  body = '''\nuse ${n} here\n'''\n[]");
+    auto * blk = root->find("blk");
+    EXPECT(blk != nullptr);
+    EXPECT(blk->param<std::string>("body").find("use 5 here") != std::string::npos);
+  });
+
+  run("triple_double_quoted_brace_expansion", []() {
+    auto root = p("n = 7\n[blk]\n  body = \"\"\"\nuse ${n} here\n\"\"\"\n[]");
+    auto * blk = root->find("blk");
+    EXPECT(blk != nullptr);
+    EXPECT(blk->param<std::string>("body").find("use 7 here") != std::string::npos);
+  });
+
+  run("triple_quoted_without_brace_is_byte_exact", []() {
+    // A body with no ${ must pass through untouched -- no spurious
+    // interpolation pass that could mangle Python code etc.
+    auto root = p("k = '''\nline one\nline two\n'''");
+    EXPECT(root->param<std::string>("k") == "\nline one\nline two\n");
+  });
+
+  run("triple_quoted_brace_expansion_preserves_newlines", []() {
+    // Multi-line body around a ${var} interpolation -- the surrounding
+    // newlines must survive the expansion pass.
+    auto root = p("n = 3\n[blk]\n  body = '''\nbefore\n${n}\nafter\n'''\n[]");
+    auto * blk = root->find("blk");
+    EXPECT(blk != nullptr);
+    EXPECT(blk->param<std::string>("body") == "\nbefore\n3\nafter\n");
+  });
+
   // ── Summary ───────────────────────────────────────────────────────────────
 
   std::cerr << "\n=== Results: " << g_passed << " passed, " << g_failed << " failed ===\n";

nmhit-0.3.1/python/tests/test_nmhit.py

@@ -1,678 +0,0 @@
-"""Pytest test suite for the nmhit Python bindings."""
-
-import pytest
-import nmhit
-
-
-# ── parse_text / basic types ──────────────────────────────────────────────────
-
-def test_parse_text_returns_root():
-    root = nmhit.parse_text("k = 42")
-    assert isinstance(root, nmhit.Root)
-
-
-def test_int_field():
-    root = nmhit.parse_text("k = 42")
-    assert root.param_int("k") == 42
-
-
-def test_negative_int():
-    root = nmhit.parse_text("k = -7")
-    assert root.param_int("k") == -7
-
-
-def test_float_field():
-    root = nmhit.parse_text("x = 3.14")
-    assert abs(root.param_float("x") - 3.14) < 1e-9
-
-
-def test_scientific_notation():
-    root = nmhit.parse_text("v = 1.5e-3")
-    assert abs(root.param_float("v") - 1.5e-3) < 1e-12
-
-
-def test_bool_true():
-    root = nmhit.parse_text("flag = true")
-    assert root.param_bool("flag") is True
-
-
-def test_bool_false():
-    root = nmhit.parse_text("flag = false")
-    assert root.param_bool("flag") is False
-
-
-def test_bool_invalid():
-    root = nmhit.parse_text("a = yes")
-    with pytest.raises(nmhit.Error):
-        root.param_bool("a")
-
-
-def test_str_field():
-    root = nmhit.parse_text("name = hello")
-    assert root.param_str("name") == "hello"
-
-
-# ── sections ──────────────────────────────────────────────────────────────────
-
-def test_section_navigation():
-    root = nmhit.parse_text("[mesh]\n  dim = 3\n[]")
-    assert root.param_int("mesh/dim") == 3
-
-
-def test_nested_sections():
-    root = nmhit.parse_text("[a]\n  [b]\n    k = 42\n  []\n[]")
-    assert root.param_int("a/b/k") == 42
-
-
-# ── find / children ───────────────────────────────────────────────────────────
-
-def test_find_returns_correct_type():
-    root = nmhit.parse_text("k = 1")
-    node = root.find("k")
-    assert isinstance(node, nmhit.Field)
-
-
-def test_find_returns_none_for_missing():
-    root = nmhit.parse_text("k = 1")
-    assert root.find("nonexistent") is None
-
-
-def test_children_unfiltered():
-    root = nmhit.parse_text("a = 1\nb = 2")
-    kids = root.children()
-    assert len(kids) == 2
-
-
-def test_children_filtered_by_field():
-    root = nmhit.parse_text("# comment\nk = 1")
-    fields = root.children(nmhit.NodeType.Field)
-    assert len(fields) == 1
-    assert isinstance(fields[0], nmhit.Field)
-
-
-def test_children_filtered_by_section():
-    root = nmhit.parse_text("[a]\n  x = 1\n[]\n[b]\n  y = 2\n[]")
-    secs = root.children(nmhit.NodeType.Section)
-    assert len(secs) == 2
-    assert all(isinstance(s, nmhit.Section) for s in secs)
-
-
-# ── lifetime / keepalive ──────────────────────────────────────────────────────
-
-def test_child_ref_survives_root_drop():
-    # Dropping the root Python object must not invalidate child references.
-    node = nmhit.parse_text("[s]\n  k = 99\n[]").find("s/k")
-    import gc; gc.collect()
-    assert node.param_int() == 99
-
-
-def test_children_element_survives_list_drop():
-    root = nmhit.parse_text("a = 1\nb = 2")
-    kids = root.children()
-    kid = kids[0]
-    del kids
-    import gc; gc.collect()
-    assert kid.path() in ("a", "b")
-
-
-# ── parent / root_node ────────────────────────────────────────────────────────
-
-def test_parent_ref():
-    root = nmhit.parse_text("[s]\n  k = 1\n[]")
-    sec = root.find("s")
-    field = sec.find("k")
-    assert field.parent() is not None
-    assert field.parent().path() == "s"
-
-
-def test_root_node():
-    root = nmhit.parse_text("[s]\n  k = 1\n[]")
-    field = root.find("s/k")
-    r = field.root_node()
-    assert isinstance(r, nmhit.Root)
-
-
-# ── param_optional ────────────────────────────────────────────────────────────
-
-def test_param_optional_present():
-    root = nmhit.parse_text("x = 5")
-    assert root.param_optional_int("x", 0) == 5
-
-
-def test_param_optional_absent():
-    root = nmhit.parse_text("x = 5")
-    assert root.param_optional_int("y", 99) == 99
-
-
-def test_param_optional_float():
-    root = nmhit.parse_text("x = 1.5")
-    assert abs(root.param_optional_float("x", 0.0) - 1.5) < 1e-9
-    assert root.param_optional_float("z", -1.0) == -1.0
-
-
-def test_param_optional_str():
-    root = nmhit.parse_text("name = foo")
-    assert root.param_optional_str("name", "default") == "foo"
-    assert root.param_optional_str("other", "default") == "default"
-
-
-# ── arrays ────────────────────────────────────────────────────────────────────
-
-def test_list_int():
-    root = nmhit.parse_text("vals = '1 2 3'")
-    assert root.param_list_int("vals") == [1, 2, 3]
-
-
-def test_list_float():
-    root = nmhit.parse_text("vals = '1.0 2.5 3.14'")
-    v = root.param_list_float("vals")
-    assert len(v) == 3
-    assert abs(v[1] - 2.5) < 1e-9
-
-
-def test_list_str():
-    root = nmhit.parse_text("tags = 'alpha beta gamma'")
-    assert root.param_list_str("tags") == ["alpha", "beta", "gamma"]
-
-
-def test_list_bool():
-    root = nmhit.parse_text("flags = 'true false true'")
-    assert root.param_list_bool("flags") == [True, False, True]
-
-
-def test_list_list_int():
-    root = nmhit.parse_text("vals = '1 2 3; 4 5 6'")
-    v = root.param_list_list_int("vals")
-    assert len(v) == 2
-    assert v[0] == [1, 2, 3]
-    assert v[1] == [4, 5, 6]
-
-
-def test_list_list_float():
-    root = nmhit.parse_text("m = '1.0 2.0; 3.0 4.0'")
-    v = root.param_list_list_float("m")
-    assert len(v) == 2
-    assert abs(v[0][0] - 1.0) < 1e-9
-    assert abs(v[1][1] - 4.0) < 1e-9
-
-
-def test_list_list_str():
-    root = nmhit.parse_text("tags = 'a b; c d'")
-    v = root.param_list_list_str("tags")
-    assert v == [["a", "b"], ["c", "d"]]
-
-
-# ── render / clone ────────────────────────────────────────────────────────────
-
-def test_render_round_trip():
-    original = "[mesh]\n  dim = 3\n[]\n"
-    root = nmhit.parse_text(original)
-    rendered = root.render()
-    root2 = nmhit.parse_text(rendered)
-    assert root2.param_int("mesh/dim") == 3
-
-
-def test_clone():
-    root = nmhit.parse_text("k = 42")
-    root2 = root.clone()
-    assert root2.param_int("k") == 42
-
-
-def test_clone_independence():
-    root = nmhit.parse_text("k = 1")
-    root2 = root.clone()
-    root2.find("k").set_val("99")
-    assert root.param_int("k") == 1
-    assert root2.param_int("k") == 99
-
-
-# ── Field mutation ────────────────────────────────────────────────────────────
-
-def test_field_raw_val():
-    root = nmhit.parse_text("k = 42")
-    field = root.find("k")
-    assert isinstance(field, nmhit.Field)
-    assert field.raw_val() == "42"
-
-
-def test_field_set_val():
-    root = nmhit.parse_text("k = 1")
-    root.find("k").set_val("99")
-    assert root.param_int("k") == 99
-
-
-# ── add_child / insert_child / remove_child ───────────────────────────────────
-
-def test_add_child():
-    # add_child clones the supplied node into the tree.
-    root = nmhit.parse_text("")
-    root.add_child(nmhit.Field("k", "42"))
-    assert root.param_int("k") == 42
-
-
-def test_insert_child():
-    root = nmhit.parse_text("b = 2")
-    root.insert_child(0, nmhit.Field("a", "1"))
-    kids = root.children(nmhit.NodeType.Field)
-    assert kids[0].path() == "a"
-    assert kids[1].path() == "b"
-
-
-def test_remove_child():
-    root = nmhit.parse_text("k = 42")
-    removed = root.remove_child("k")   # pass path string
-    assert isinstance(removed, nmhit.Field)
-    assert root.find("k") is None
-
-
-def test_remove_child_nested():
-    root = nmhit.parse_text("[s]\n  k = 42\n[]")
-    removed = root.remove_child("s/k")
-    assert isinstance(removed, nmhit.Field)
-    assert root.find("s/k") is None
-
-
-def test_remove_child_missing():
-    root = nmhit.parse_text("k = 42")
-    with pytest.raises(nmhit.Error):
-        root.remove_child("nonexistent")
-
-
-def test_remove_child_empty_relpath():
-    root = nmhit.parse_text("k = 42")
-    with pytest.raises(nmhit.Error):
-        root.remove_child("")
-
-
-# ── error handling ────────────────────────────────────────────────────────────
-
-def test_error_on_missing_section_close():
-    with pytest.raises(nmhit.Error):
-        nmhit.parse_text("[mesh]\n  dim = 3")
-
-
-def test_error_has_messages():
-    with pytest.raises(nmhit.Error) as exc_info:
-        nmhit.parse_text("[mesh]\n  dim = 3")
-    assert hasattr(exc_info.value, "messages")
-
-
-def test_error_is_runtime_error():
-    with pytest.raises(RuntimeError):
-        nmhit.parse_text("[mesh]\n  dim = 3")
-
-
-def test_error_on_duplicate_field():
-    with pytest.raises(nmhit.Error):
-        nmhit.parse_text("k = 1\nk = 2")
-
-
-# ── ErrorMessage ──────────────────────────────────────────────────────────────
-
-def test_error_message_attributes():
-    with pytest.raises(nmhit.Error) as exc_info:
-        nmhit.parse_text("[mesh]\n  dim = 3")
-    msgs = exc_info.value.messages
-    assert isinstance(msgs, list)
-    if msgs:
-        m = msgs[0]
-        assert hasattr(m, "line")
-        assert hasattr(m, "column")
-        assert hasattr(m, "message")
-        assert hasattr(m, "filename")
-
-
-# ── source location ───────────────────────────────────────────────────────────
-
-def test_line_numbers():
-    root = nmhit.parse_text("a = hello\nb = world\nc = 3")
-    assert root.find("a").line() == 1
-    assert root.find("b").line() == 2
-    assert root.find("c").line() == 3
-
-
-def test_fullpath():
-    root = nmhit.parse_text("[a]\n  [b]\n    k = 1\n  []\n[]")
-    node = root.find("a/b/k")
-    assert node.fullpath() == "a/b/k"
-
-
-def test_path():
-    root = nmhit.parse_text("[mesh]\n  dim = 3\n[]")
-    sec = root.find("mesh")
-    assert sec.path() == "mesh"
-
-
-# ── parse_file ────────────────────────────────────────────────────────────────
-
-def test_parse_file(tmp_path):
-    f = tmp_path / "test.i"
-    f.write_text("x = 7\n")
-    root = nmhit.parse_file(f)
-    assert root.param_int("x") == 7
-
-
-def test_parse_file_str_path(tmp_path):
-    f = tmp_path / "test.i"
-    f.write_text("x = 7\n")
-    root = nmhit.parse_file(str(f))
-    assert root.param_int("x") == 7
-
-
-def test_parse_file_missing():
-    with pytest.raises(nmhit.Error):
-        nmhit.parse_file("/nonexistent/path/file.i")
-
-
-def test_parse_file_with_pre(tmp_path):
-    f = tmp_path / "test.i"
-    f.write_text("b = 2\n")
-    root = nmhit.parse_file(f, pre=["a = 1"])
-    assert root.param_int("a") == 1
-    assert root.param_int("b") == 2
-
-
-# ── pre / post overrides ──────────────────────────────────────────────────────
-
-def test_pre_snippets():
-    root = nmhit.parse_text("b = 2", pre=["a = 1"])
-    assert root.param_int("a") == 1
-    assert root.param_int("b") == 2
-
-
-def test_post_override():
-    root = nmhit.parse_text("k = 1", post=["k := 99"])
-    assert root.param_int("k") == 99
-
-
-# ── free scalar converters ────────────────────────────────────────────────────
-
-def test_parse_bool():
-    assert nmhit.parse_bool("true") is True
-    assert nmhit.parse_bool("false") is False
-    assert nmhit.parse_bool("'true'") is True
-
-
-def test_parse_bool_invalid():
-    for bad in ("yes", "no", "on", "off", "True", "1", "0"):
-        with pytest.raises(nmhit.Error):
-            nmhit.parse_bool(bad)
-
-
-def test_parse_int():
-    assert nmhit.parse_int("42") == 42
-    assert nmhit.parse_int("-7") == -7
-    assert nmhit.parse_int("'10'") == 10
-
-
-def test_parse_int_invalid():
-    with pytest.raises(nmhit.Error):
-        nmhit.parse_int("3.14")
-
-
-def test_parse_double():
-    assert abs(nmhit.parse_double("3.14") - 3.14) < 1e-9
-    assert nmhit.parse_double("1e3") == 1000.0
-
-
-def test_parse_float():
-    assert abs(nmhit.parse_float("1.5") - 1.5) < 1e-6
-
-
-# ── nmhit.param() convenience wrapper ────────────────────────────────────────
-
-def test_param_auto_int():
-    root = nmhit.parse_text("k = 42")
-    assert nmhit.param(root, "k") == 42
-    assert isinstance(nmhit.param(root, "k"), int)
-
-
-def test_param_auto_float():
-    root = nmhit.parse_text("x = 3.14")
-    val = nmhit.param(root, "x")
-    assert isinstance(val, float)
-    assert abs(val - 3.14) < 1e-9
-
-
-def test_param_auto_bool():
-    root = nmhit.parse_text("flag = true")
-    assert nmhit.param(root, "flag") is True
-
-
-def test_param_auto_str():
-    root = nmhit.parse_text("name = hello")
-    assert nmhit.param(root, "name") == "hello"
-
-
-def test_param_with_type_hint_float():
-    root = nmhit.parse_text("n = 5")
-    assert nmhit.param(root, "n", float) == 5.0
-
-
-def test_param_with_type_hint_str():
-    root = nmhit.parse_text("n = 42")
-    assert nmhit.param(root, "n", str) == "42"
-
-
-# ── Comment / Blank node types ────────────────────────────────────────────────
-
-def test_comment_preserved():
-    root = nmhit.parse_text("# top comment\nk = 1")
-    comments = root.children(nmhit.NodeType.Comment)
-    assert len(comments) == 1
-    assert isinstance(comments[0], nmhit.Comment)
-    assert "top comment" in comments[0].text()
-
-
-def test_blank_preserved():
-    root = nmhit.parse_text("a = 1\n\nb = 2")
-    blanks = root.children(nmhit.NodeType.Blank)
-    assert len(blanks) >= 1
-
-
-def test_comment_inline():
-    c = nmhit.Comment("hello", is_inline=True)
-    assert c.is_inline() is True
-    c.set_inline(False)
-    assert c.is_inline() is False
-
-
-# ── node identity and type ────────────────────────────────────────────────────
-
-def test_node_type_enum():
-    root = nmhit.parse_text("[s]\n  k = 1\n[]")
-    assert root.type() == nmhit.NodeType.Root
-    assert root.find("s").type() == nmhit.NodeType.Section
-    assert root.find("s/k").type() == nmhit.NodeType.Field
-
-
-def test_node_repr():
-    root = nmhit.parse_text("")
-    assert "Root" in repr(root)
-
-
-# ── override assignment ───────────────────────────────────────────────────────
-
-def test_override_assign():
-    root = nmhit.parse_text("k = 1\nk := 99")
-    assert root.param_int("k") == 99
-
-
-# ── triple-quoted strings ─────────────────────────────────────────────────────
-
-def test_triple_single_quote_basic():
-    """'''value''' is parsed verbatim and returned by param_str."""
-    root = nmhit.parse_text("k = '''hello world'''")
-    assert root.param_str("k") == "hello world"
-
-
-def test_triple_double_quote_basic():
-    """\"\"\"value\"\"\"  is parsed verbatim and returned by param_str."""
-    root = nmhit.parse_text('k = """hello world"""')
-    assert root.param_str("k") == "hello world"
-
-
-def test_triple_single_quote_multiline():
-    """Triple single-quoted strings preserve internal newlines verbatim."""
-    root = nmhit.parse_text("k = '''\n  line1\n  line2\n'''")
-    val = root.param_str("k")
-    assert "line1" in val
-    assert "line2" in val
-    assert "\n" in val
-
-
-def test_triple_double_quote_multiline():
-    """Triple double-quoted strings preserve internal newlines verbatim."""
-    root = nmhit.parse_text('k = """\n  line1\n  line2\n"""')
-    val = root.param_str("k")
-    assert "line1" in val
-    assert "line2" in val
-    assert "\n" in val
-
-
-def test_triple_single_quote_contains_double_quotes():
-    """Triple single-quoted strings may contain double-quote characters."""
-    root = nmhit.parse_text("""k = '''say "hello"'''""")
-    assert root.param_str("k") == 'say "hello"'
-
-
-def test_triple_double_quote_contains_single_quotes():
-    """Triple double-quoted strings may contain single-quote characters."""
-    root = nmhit.parse_text("""k = \"\"\"it's fine\"\"\"""")
-    assert root.param_str("k") == "it's fine"
-
-
-def test_triple_single_quote_contains_single_quote():
-    """A single embedded apostrophe inside triple single-quoted string is allowed."""
-    root = nmhit.parse_text("k = '''it's verbatim'''")
-    assert root.param_str("k") == "it's verbatim"
-
-
-def test_triple_double_quote_contains_double_quote():
-    """A single embedded double-quote inside triple double-quoted string is allowed."""
-    root = nmhit.parse_text('k = """say "hi" """')
-    assert '"hi"' in root.param_str("k")
-
-
-def test_triple_single_quote_both_quote_types():
-    """Triple single-quoted strings may contain both quote types."""
-    root = nmhit.parse_text("""k = '''it's "great"'''""")
-    val = root.param_str("k")
-    assert "it's" in val
-    assert '"great"' in val
-
-
-def test_triple_double_quote_both_quote_types():
-    """Triple double-quoted strings may contain both quote types."""
-    # """...""" delimiter allows single ' freely; single " is also fine mid-string.
-    root = nmhit.parse_text('k = """it\'s "great" """')
-    val = root.param_str("k")
-    assert "it's" in val
-    assert '"great"' in val
-
-
-def test_triple_single_quote_in_section():
-    """Triple-quoted strings work inside sections."""
-    root = nmhit.parse_text("[s]\n  code = '''\n    result = 1\n  '''\n[]")
-    val = root.param_str("s/code")
-    assert "result" in val
-
-
-def test_triple_single_quote_multiline_indented():
-    """Indented multi-line triple-quoted content is preserved verbatim (no stripping)."""
-    root = nmhit.parse_text("k = '''\n      x = 1\n      y = 2\n    '''")
-    val = root.param_str("k")
-    assert "x = 1" in val
-    assert "y = 2" in val
-    # Leading whitespace of interior lines is preserved
-    assert "      x" in val or "    x" in val  # some indentation present
-
-
-def test_triple_quote_empty():
-    """An empty triple-quoted string returns an empty string."""
-    root = nmhit.parse_text("k = ''''''")
-    assert root.param_str("k") == ""
-
-
-def test_triple_quote_python_expression():
-    """Typical use case: Python code expression stored verbatim."""
-    code = "import torch\nresult = torch.tensor([1.0, 2.0, 3.0])"
-    hit = f"k = '''\n{code}\n'''"
-    root = nmhit.parse_text(hit)
-    val = root.param_str("k")
-    assert "import torch" in val
-    assert "torch.tensor" in val
-    assert "\n" in val
-
-
-def test_triple_quote_only_readable_as_string():
-    """Verbatim (triple-quoted) fields raise when read as non-string types."""
-    root = nmhit.parse_text("k = '''42'''")
-    # param_str must succeed
-    assert root.param_str("k") == "42"
-    # All non-string interpretations must raise
-    with pytest.raises(nmhit.Error, match="verbatim"):
-        root.param_int("k")
-    with pytest.raises(nmhit.Error, match="verbatim"):
-        root.param_float("k")
-    with pytest.raises(nmhit.Error, match="verbatim"):
-        root.param_bool("k")
-
-
-def test_triple_quote_not_readable_as_list():
-    """Verbatim fields also raise when read as list types."""
-    root = nmhit.parse_text("k = '''1 2 3'''")
-    assert root.param_str("k") == "1 2 3"
-    with pytest.raises(nmhit.Error, match="verbatim"):
-        root.param_list_int("k")
-
-
-# ── triple-quoted round-trip rendering ────────────────────────────────────────
-# Round-trip = parse_text(s).render() == s, byte-for-byte. The formatter
-# (nmhit-format) walks this exact pipeline, so any divergence here is a
-# direct formatter-breaking bug.
-
-
-def test_triple_single_quote_roundtrip_inline():
-    src = "k = '''hello world'''\n"
-    assert nmhit.parse_text(src).render() == src
-
-
-def test_triple_double_quote_roundtrip_inline():
-    src = 'k = """hello world"""\n'
-    assert nmhit.parse_text(src).render() == src
-
-
-def test_triple_single_quote_roundtrip_multiline():
-    src = "k = '''\n  line1\n  line2\n'''\n"
-    assert nmhit.parse_text(src).render() == src
-
-
-def test_triple_double_quote_roundtrip_multiline():
-    src = 'k = """\n  line1\n  line2\n"""\n'
-    assert nmhit.parse_text(src).render() == src
-
-
-def test_triple_quote_roundtrip_python_expression():
-    src = (
-        "[Tensors]\n"
-        "  [strain]\n"
-        "    type = Python\n"
-        "    expr = '''\n"
-        "torch.stack([\n"
-        "    torch.linspace(0, 1, 5),\n"
-        "    torch.linspace(1, 2, 5),\n"
-        "])\n"
-        "'''\n"
-        "  []\n"
-        "[]\n"
-    )
-    assert nmhit.parse_text(src).render() == src
-
-
-def test_triple_quote_roundtrip_preserves_delimiter_style():
-    """The renderer must wrap the body in the same delimiter the input used."""
-    src_sq = "k = '''\nbody\n'''\n"
-    src_dq = 'k = """\nbody\n"""\n'
-    assert nmhit.parse_text(src_sq).render() == src_sq
-    assert nmhit.parse_text(src_dq).render() == src_dq