diffnc 0.0.1__tar.gz → 0.0.3__tar.gz

{diffnc-0.0.1 → diffnc-0.0.3}/.github/workflows/publish.yml

@@ -14,10 +14,10 @@ jobs:
       contents: read
     steps:
       - name: Checkout
-        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
 
       - name: Install uv
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
         with:
           python-version: "3.12"
 

{diffnc-0.0.1 → diffnc-0.0.3}/.github/workflows/test.yml

@@ -20,10 +20,10 @@ jobs:
         python-version: ["3.11", "3.12", "3.13", "3.14"]
 
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
 
       - name: Install uv
-        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b # v8.1.0
+        uses: astral-sh/setup-uv@fac544c07dec837d0ccb6301d7b5580bf5edae39 # v8.2.0
         with:
           python-version: ${{ matrix.python-version }}
           enable-cache: true

{diffnc-0.0.1 → diffnc-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: diffnc
-Version: 0.0.1
+Version: 0.0.3
 Summary: Structural diff library for network device configurations
 Author-email: minefuto <46558834+minefuto@users.noreply.github.com>
 License: MIT License
@@ -35,6 +35,10 @@ Description-Content-Type: text/markdown
 
 # diffnc(DIFF for Network device Configurations)
 
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/diffnc)
+![PyPI - Version](https://img.shields.io/pypi/v/diffnc)
+![GitHub License](https://img.shields.io/github/license/minefuto/diffnc)
+
 A Python library and CLI that diffs network device configurations **with structural awareness**, exposed through a `difflib`-like API.
 
 * Duplicate same-name blocks (e.g. `interface eth1` appearing more than once) are merged at parse time
@@ -257,7 +261,7 @@ The `VendorParser` protocol exposes `is_order_sensitive(path: tuple[str, ...]) -
 ## Development
 
 ```bash
-uv sync --extra dev
+uv sync
 uv run pytest          # tests
 uv run ruff check .    # lint
 uv run ruff format .   # format

{diffnc-0.0.1 → diffnc-0.0.3}/README.md

@@ -1,5 +1,9 @@
 # diffnc(DIFF for Network device Configurations)
 
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/diffnc)
+![PyPI - Version](https://img.shields.io/pypi/v/diffnc)
+![GitHub License](https://img.shields.io/github/license/minefuto/diffnc)
+
 A Python library and CLI that diffs network device configurations **with structural awareness**, exposed through a `difflib`-like API.
 
 * Duplicate same-name blocks (e.g. `interface eth1` appearing more than once) are merged at parse time
@@ -222,7 +226,7 @@ The `VendorParser` protocol exposes `is_order_sensitive(path: tuple[str, ...]) -
 ## Development
 
 ```bash
-uv sync --extra dev
+uv sync
 uv run pytest          # tests
 uv run ruff check .    # lint
 uv run ruff format .   # format

{diffnc-0.0.1 → diffnc-0.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "diffnc"
-version = "0.0.1"
+version = "0.0.3"
 description = "Structural diff library for network device configurations"
 readme = "README.md"
 authors = [

{diffnc-0.0.1 → diffnc-0.0.3}/src/diffnc/detect.py

@@ -117,20 +117,30 @@ def _has_eos_marker(lines: list[str]) -> bool:
     return False
 
 
-def detect_vendor(text: str) -> str:
-    """Return the vendor name for *text*.
-
-    Raises:
-        ParseError: if no supported vendor can be confidently identified.
-    """
-
+def _significant_lines(text: str) -> list[str]:
     significant: list[str] = []
     for raw in text.splitlines():
         s = raw.strip()
         if not s or s.startswith("!") or s.startswith("#") or s.startswith("/*"):
             continue
         significant.append(s)
+    return significant
+
+
+def is_empty_config(text: str) -> bool:
+    """True if *text* has no significant (non-comment) lines."""
+
+    return not _significant_lines(text)
+
+
+def detect_vendor(text: str) -> str:
+    """Return the vendor name for *text*.
+
+    Raises:
+        ParseError: if no supported vendor can be confidently identified.
+    """
 
+    significant = _significant_lines(text)
     if not significant:
         raise ParseError("configuration is empty or comment-only")
 

{diffnc-0.0.1 → diffnc-0.0.3}/src/diffnc/diff.py

@@ -22,11 +22,14 @@ from dataclasses import dataclass
 from difflib import SequenceMatcher
 
 from diffnc import vendors as _vendors
-from diffnc.detect import detect_vendor
+from diffnc.detect import detect_vendor, is_empty_config
 from diffnc.errors import VendorMismatchError
 from diffnc.ir import ConfigNode, ConfigTree
 from diffnc.vendors.base import VendorParser, is_order_sensitive_for, render_subtree
 
+_SIMILARITY_CUTOFF = 0.6  # difflib.get_close_matches の既定値に合わせる
+_TOKEN_SHARE_CUTOFF = 0.4  # 先頭コマンド語が一致する場合に適用する緩い二次閾値
+
 
 @dataclass(frozen=True)
 class _Event:
@@ -118,11 +121,21 @@ def _prepare(
     text_b = _coerce(b)
 
     if vendor is None:
-        vendor_a = detect_vendor(text_a)
-        vendor_b = detect_vendor(text_b)
-        if vendor_a != vendor_b:
-            raise VendorMismatchError(vendor_a, vendor_b)
-        vendor_name = vendor_a
+        empty_a = is_empty_config(text_a)
+        empty_b = is_empty_config(text_b)
+        if empty_a and empty_b:
+            # Nothing to detect from and nothing to diff: both trees parse empty, so no
+            # vendor-specific behaviour is ever reached and any registered parser will do.
+            vendor_name = "nxos"
+        elif empty_a or empty_b:
+            # An empty side carries no vendor signal; detect from the other side only.
+            vendor_name = detect_vendor(text_b if empty_a else text_a)
+        else:
+            vendor_a = detect_vendor(text_a)
+            vendor_b = detect_vendor(text_b)
+            if vendor_a != vendor_b:
+                raise VendorMismatchError(vendor_a, vendor_b)
+            vendor_name = vendor_a
     else:
         vendor_name = vendor
 
@@ -266,6 +279,10 @@ def _diff_children_unordered(
     splices in ``b``-only children at their natural position — i.e. before the next
     matched anchor — so ``-`` / ``+`` lines surface near each other instead of clumping
     at the start and end.
+
+    Additionally, A-only and B-only *leaves* that look like the same setting with a
+    changed value (high :class:`difflib.SequenceMatcher` ratio) are paired so the ``+``
+    is emitted immediately after its ``-``.
     """
 
     a_children = node_a.children
@@ -276,26 +293,88 @@ def _diff_children_unordered(
         child.line: idx for idx, child in enumerate(b_children) if child.line in common
     }
 
+    a_only_leaves = [
+        (idx, child)
+        for idx, child in enumerate(a_children)
+        if child.line not in common and child.is_leaf
+    ]
+    b_only_leaves = [
+        (idx, child)
+        for idx, child in enumerate(b_children)
+        if child.line not in common and child.is_leaf
+    ]
+    a_index_to_b_node, paired_b_positions = _pair_changed_leaves(a_only_leaves, b_only_leaves)
+
     b_pointer = 0
-    for child_a in a_children:
+    for idx, child_a in enumerate(a_children):
         if child_a.line not in common:
             yield from _emit_one_side(parser, child_a, depth, "-")
+            partner = a_index_to_b_node.get(idx)
+            if partner is not None:
+                yield from _emit_one_side(parser, partner, depth, "+")
             continue
         b_pos = b_match_index[child_a.line]
         if b_pos >= b_pointer:
             for k in range(b_pointer, b_pos):
                 child_b = b_children[k]
-                if child_b.line not in common:
+                if child_b.line not in common and k not in paired_b_positions:
                     yield from _emit_one_side(parser, child_b, depth, "+")
             b_pointer = b_pos + 1
         yield from _equal_pair(parser, child_a, b_by_line[child_a.line], depth, hide_equal, path)
 
     for k in range(b_pointer, len(b_children)):
         child_b = b_children[k]
-        if child_b.line not in common:
+        if child_b.line not in common and k not in paired_b_positions:
             yield from _emit_one_side(parser, child_b, depth, "+")
 
 
+def _leading_token(line: str) -> str:
+    """Return the first whitespace-delimited token of *line* (its command word)."""
+
+    parts = line.split(maxsplit=1)
+    return parts[0] if parts else ""
+
+
+def _pair_changed_leaves(
+    a_only: list[tuple[int, ConfigNode]],
+    b_only: list[tuple[int, ConfigNode]],
+) -> tuple[dict[int, ConfigNode], set[int]]:
+    """Greedily pair A-only / B-only leaves that differ only in value.
+
+    A pair is a candidate when either the raw-line ``difflib`` ratio clears
+    :data:`_SIMILARITY_CUTOFF`, or the two leaves share the same leading command token
+    and the ratio clears the looser :data:`_TOKEN_SHARE_CUTOFF`. The latter rescues short
+    settings with a large value change (``vlan 1`` → ``vlan 1,100,200,300``) whose char
+    ratio dips below the primary cutoff. Pairs are chosen highest-ratio first and each side
+    is used at most once, so genuine high-ratio matches win before the looser fallbacks.
+
+    Returns ``(a_child_index -> paired b node, set of paired b child indices)`` so the
+    caller can emit the ``+`` next to its ``-`` and suppress it elsewhere.
+    """
+
+    candidates: list[tuple[float, int, int]] = []
+    for ai, (_, a_node) in enumerate(a_only):
+        for bi, (_, b_node) in enumerate(b_only):
+            ratio = SequenceMatcher(None, a_node.line, b_node.line).ratio()
+            shares_token = _leading_token(a_node.line) == _leading_token(b_node.line)
+            if ratio >= _SIMILARITY_CUTOFF or (shares_token and ratio >= _TOKEN_SHARE_CUTOFF):
+                candidates.append((ratio, ai, bi))
+    candidates.sort(key=lambda t: t[0], reverse=True)
+
+    used_a: set[int] = set()
+    used_b: set[int] = set()
+    a_index_to_b_node: dict[int, ConfigNode] = {}
+    paired_b_positions: set[int] = set()
+    for _, ai, bi in candidates:
+        if ai in used_a or bi in used_b:
+            continue
+        used_a.add(ai)
+        used_b.add(bi)
+        a_index_to_b_node[a_only[ai][0]] = b_only[bi][1]
+        paired_b_positions.add(b_only[bi][0])
+    return a_index_to_b_node, paired_b_positions
+
+
 def _equal_pair(
     parser: VendorParser,
     child_a: ConfigNode,
@@ -314,10 +393,15 @@ def _equal_pair(
         return
 
     if a_is_section != b_is_section:
-        # One side became a section while the other stayed a leaf — emit as replace.
-        yield from _emit_one_side(parser, child_a, depth, "-")
-        yield from _emit_one_side(parser, child_b, depth, "+")
-        return
+        leaf_node = child_b if a_is_section else child_a
+        section_node = child_a if a_is_section else child_b
+        if not _leaf_section_render_equivalent(parser, leaf_node, section_node, depth):
+            # A leaf that genuinely became a section (e.g. Junos ``foo;`` → ``foo { ... }``).
+            yield from _emit_one_side(parser, child_a, depth, "-")
+            yield from _emit_one_side(parser, child_b, depth, "+")
+            return
+        # Indent-based vendors: the "leaf" is just an empty section with the same header,
+        # so fall through and diff their children (the empty side yields all ``-``/``+``).
 
     # Both are sections with matching headers. Diff their children; only surface the section
     # header if any descendant differs (compact mode) or always (ndiff).
@@ -343,6 +427,25 @@ def _equal_pair(
         yield _Event(" ", close)
 
 
+def _leaf_section_render_equivalent(
+    parser: VendorParser,
+    leaf_node: ConfigNode,
+    section_node: ConfigNode,
+    depth: int,
+) -> bool:
+    """Whether promoting *leaf_node* to an empty section is render-transparent.
+
+    True for indent-based vendors (Cisco/NX-OS), where ``render_leaf == render_open`` and
+    there is no closing line, so an empty ``interface eth1`` and a populated one share the
+    same header. False for brace/terminator vendors (Junos hierarchical), where a leaf
+    (``foo;``) is structurally distinct from a section (``foo { ... }``).
+    """
+
+    return parser.render_close(section_node, depth) is None and parser.render_leaf(
+        leaf_node, depth
+    ) == parser.render_open(section_node, depth)
+
+
 def _emit_one_side(
     parser: VendorParser,
     node: ConfigNode,

{diffnc-0.0.1 → diffnc-0.0.3}/tests/test_diff.py

@@ -225,3 +225,92 @@ def test_nxos_default_changes_effective_diff() -> None:
     )
     b = "interface Ethernet1/1\n  description new-uplink\n"
     assert list(unified_diff(a, b)) == []
+
+
+def test_nxos_emptied_section_header_shown_as_context() -> None:
+    """An interface that loses all its children stays a context header, not a -/+ replace."""
+
+    a = "interface Ethernet1/1\n  no shutdown\n"
+    b = "interface Ethernet1/1\n"
+    out = "".join(unified_diff(a, b, lineterm="\n"))
+    assert out == " interface Ethernet1/1\n-  no shutdown\n"
+    assert "+interface Ethernet1/1" not in out
+
+
+def test_nxos_changed_leaves_paired_adjacently() -> None:
+    """Value changes of the same setting surface as adjacent -/+ pairs, not clumped."""
+
+    a = "interface Ethernet1/2\n  ip address 192.168.1.1/24\n  ip ospf cost 50\n"
+    b = "interface Ethernet1/2\n  ip address 192.168.1.2/24\n  ip ospf cost 100\n"
+    out = "".join(unified_diff(a, b, lineterm="\n"))
+    assert out == (
+        " interface Ethernet1/2\n"
+        "-  ip address 192.168.1.1/24\n"
+        "+  ip address 192.168.1.2/24\n"
+        "-  ip ospf cost 50\n"
+        "+  ip ospf cost 100\n"
+    )
+
+
+def test_short_leaf_value_change_paired_by_leading_token() -> None:
+    """A short setting with a big value change pairs via its shared command word.
+
+    ``vlan 1`` vs ``vlan 1,100,200,300`` scores below ``_SIMILARITY_CUTOFF`` on raw chars,
+    but the shared ``vlan`` token rescues the pairing so the ``+`` sits next to its ``-``.
+    """
+
+    a = "vlan 1\nlicense smart transport smart\nlicense smart source-interface mgmt0\n"
+    b = "vlan 1,100,200,300\nlicense smart source-interface mgmt0\n"
+    out = "".join(unified_diff(a, b, lineterm="\n"))
+    assert out == ("-vlan 1\n+vlan 1,100,200,300\n-license smart transport smart\n")
+
+
+def test_junos_leaf_to_section_still_renders_as_replace() -> None:
+    """A Junos leaf becoming a populated section must not collapse into a context header."""
+
+    a = "interfaces {\n    ge-0/0/0;\n}\n"
+    b = "interfaces {\n    ge-0/0/0 {\n        unit 0;\n    }\n}\n"
+    out = "".join(unified_diff(a, b, lineterm="\n"))
+    assert "-    ge-0/0/0;\n" in out
+    assert "+    ge-0/0/0 {\n" in out
+    assert "+        unit 0;\n" in out
+    assert "+    }\n" in out
+
+
+# ---------------------------------------------------------------------------
+# Empty-side inputs
+# ---------------------------------------------------------------------------
+
+
+def test_ndiff_against_empty_b_marks_all_as_deleted() -> None:
+    a = "set interface ge-0/0/0 unit 0 family inet dhcp"
+    assert list(ndiff(a, "")) == ["- set interface ge-0/0/0 unit 0 family inet dhcp"]
+
+
+def test_unified_against_empty_a_marks_all_as_added() -> None:
+    b = "set interface ge-0/0/0 unit 0 family inet dhcp\nset system host-name r1\n"
+    assert list(unified_diff("", b)) == [
+        "+set interface ge-0/0/0 unit 0 family inet dhcp",
+        "+set system host-name r1",
+    ]
+
+
+def test_comment_only_side_treated_as_empty() -> None:
+    a = "interface Ethernet1/1\n  no shutdown\n"
+    b = "! header comment only\n"
+    out = list(unified_diff(a, b))
+    assert out == ["-interface Ethernet1/1", "-  no shutdown"]
+
+
+def test_empty_side_emits_whole_subtree() -> None:
+    a = "interface Ethernet1/1\n  description uplink\n  no shutdown\n"
+    assert list(ndiff(a, "")) == [
+        "- interface Ethernet1/1",
+        "-   description uplink",
+        "-   no shutdown",
+    ]
+
+
+def test_both_sides_empty_produce_no_output() -> None:
+    assert list(unified_diff("", "")) == []
+    assert list(ndiff("", "! comment\n")) == []

{diffnc-0.0.1 → diffnc-0.0.3}/tests/test_reconcile.py

@@ -279,3 +279,25 @@ def test_iterable_input_is_accepted() -> None:
     b_lines = ["interface eth1", "  description new"]
     out = list(reconcile(a_lines, b_lines, vendor="nxos"))
     assert out == ["interface eth1", "no description old", "description new"]
+
+
+# ---------------------------------------------------------------------------
+# Empty-side inputs
+# ---------------------------------------------------------------------------
+
+
+def test_reconcile_to_empty_deletes_everything() -> None:
+    a = "set interface ge-0/0/0 unit 0 family inet dhcp\n"
+    assert list(reconcile(a, "")) == ["delete interface ge-0/0/0 unit 0 family inet dhcp"]
+
+
+def test_reconcile_from_empty_adds_everything() -> None:
+    b = "set interface ge-0/0/0 unit 0 family inet dhcp\nset system host-name r1\n"
+    assert list(reconcile("", b)) == [
+        "set interface ge-0/0/0 unit 0 family inet dhcp",
+        "set system host-name r1",
+    ]
+
+
+def test_reconcile_both_empty_produces_no_output() -> None:
+    assert list(reconcile("", "! comment only\n")) == []

{diffnc-0.0.1 → diffnc-0.0.3}/uv.lock

@@ -117,7 +117,7 @@ toml = [
 
 [[package]]
 name = "diffnc"
-version = "0.0.1"
+version = "0.0.3"
 source = { editable = "." }
 
 [package.dev-dependencies]