diffnc 0.0.1__py3-none-any.whl

diffnc/vendors/junos_set.py

@@ -0,0 +1,158 @@
+"""Junos set-form vendor parser.
+
+Handles the flat ``set ...`` form produced by ``display set``. Documents are modelled as a
+flat list of leaves (one per logical ``set`` statement); duplicate statements collapse to
+one. ``activate <path>`` and ``deactivate <path>`` are treated as a tri-state per path
+(activated / deactivated / unspecified), applied in input order — the last toggle wins and
+only one state node per path remains in the tree. ``delete <path>`` is applied in-order:
+it removes any earlier ``set``/``activate``/``deactivate`` whose path equals or starts
+with ``<path>`` at a token boundary, mirroring the Junos CLI semantics. Subsequent ``set``
+statements may re-add state.
+
+Line comments (``#``, ``//`` to end of line) are stripped during parsing.
+
+The hierarchical (``show configuration``) form is handled by a separate vendor, see
+:mod:`diffnc.vendors.junos`.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from diffnc.errors import ParseError
+from diffnc.ir import ConfigNode, ConfigTree
+from diffnc.vendors.base import VendorParser
+
+if TYPE_CHECKING:
+    from diffnc.reconcile import ReconcileEvent
+
+_SET_PREFIXES = ("set ", "deactivate ", "activate ")
+_DELETE_PREFIX = "delete "
+_TOGGLE_PREFIXES = ("activate ", "deactivate ")
+_VALID_SET_PREFIXES = (*_SET_PREFIXES, _DELETE_PREFIX)
+
+
+@dataclass
+class _JunosSetParser:
+    name: str = "junos_set"
+
+    def parse(self, text: str) -> ConfigTree:
+        tree = ConfigTree.empty(vendor=self.name)
+        for lineno, raw in enumerate(text.splitlines(), start=1):
+            stripped = _strip_line_comment(raw).strip()
+            if not stripped:
+                continue
+            if not stripped.startswith(_VALID_SET_PREFIXES):
+                raise ParseError(
+                    f"line {lineno}: expected 'set'/'activate'/'deactivate'/'delete' line, "
+                    f"got {stripped!r}"
+                )
+            if stripped.startswith(_DELETE_PREFIX):
+                path = stripped[len(_DELETE_PREFIX) :].strip()
+                if not path:
+                    raise ParseError(f"line {lineno}: 'delete' requires a path")
+                _apply_delete(tree.root, path)
+                continue
+            if stripped.startswith(_TOGGLE_PREFIXES):
+                op, _, path = stripped.partition(" ")
+                path = path.strip()
+                if not path:
+                    raise ParseError(f"line {lineno}: {op!r} requires a path")
+                _apply_state_toggle(tree.root, path, stripped)
+                continue
+            tree.root.add_child(ConfigNode(line=stripped))
+        return tree
+
+    def format(self, tree: ConfigTree) -> list[str]:
+        return [child.line for child in tree.root.children]
+
+    def render_open(self, node: ConfigNode, depth: int) -> str:
+        # Set form has no sections, so this should never be invoked by the diff engine.
+        raise ParseError("render_open is not applicable to Junos set form")
+
+    def render_close(self, node: ConfigNode, depth: int) -> str | None:
+        return None
+
+    def render_leaf(self, node: ConfigNode, depth: int) -> str:
+        return node.line
+
+    def is_order_sensitive(self, path: tuple[str, ...]) -> bool:
+        """Set form has no semantically ordered children.
+
+        :meth:`parse` already replays the activate/deactivate/delete operations to a
+        canonical final state, so the IR's residual order is just whatever the input
+        happened to leave behind — never load-bearing.
+        """
+
+        return False
+
+    def render_reconcile(self, events: Iterable[ReconcileEvent]) -> Iterator[str]:
+        from diffnc.reconcile import ReconcileAdd, ReconcileDelete
+
+        for ev in events:
+            if isinstance(ev, ReconcileAdd):
+                yield ev.node.line
+            elif isinstance(ev, ReconcileDelete):
+                yield f"delete {_strip_set_prefix(ev.node.line)}"
+
+
+def _apply_state_toggle(root: ConfigNode, path: str, new_line: str) -> None:
+    """Toggle the activate/deactivate state for ``path``.
+
+    Replaces any existing ``activate <path>`` / ``deactivate <path>`` child line in place
+    (preserving first-occurrence position), or appends a new state node when none exists.
+    """
+
+    activate_line = f"activate {path}"
+    deactivate_line = f"deactivate {path}"
+    for child in root.children:
+        if child.line == activate_line or child.line == deactivate_line:
+            child.line = new_line
+            return
+    root.children.append(ConfigNode(line=new_line))
+
+
+def _strip_set_prefix(line: str) -> str:
+    for prefix in _SET_PREFIXES:
+        if line.startswith(prefix):
+            return line[len(prefix) :]
+    return line
+
+
+def _apply_delete(root: ConfigNode, delete_path: str) -> None:
+    """Drop children whose set-form path equals or token-prefix-matches ``delete_path``."""
+
+    boundary = delete_path + " "
+    surviving: list[ConfigNode] = []
+    for child in root.children:
+        path = _strip_set_prefix(child.line)
+        if path == delete_path or path.startswith(boundary):
+            continue
+        surviving.append(child)
+    root.children = surviving
+
+
+def _strip_line_comment(line: str) -> str:
+    """Truncate at the first ``#`` or ``//`` that lies outside a double-quoted string."""
+
+    in_quote = False
+    i = 0
+    n = len(line)
+    while i < n:
+        ch = line[i]
+        if ch == '"':
+            in_quote = not in_quote
+            i += 1
+            continue
+        if not in_quote:
+            if ch == "#":
+                return line[:i]
+            if ch == "/" and i + 1 < n and line[i + 1] == "/":
+                return line[:i]
+        i += 1
+    return line
+
+
+PARSER: VendorParser = _JunosSetParser()

diffnc/vendors/nxos.py

@@ -0,0 +1,22 @@
+"""NX-OS vendor parser.
+
+NX-OS uses significant indentation (2-space unit) under section heads such as
+``interface Ethernet1/1`` or ``vrf context FOO``. Shutdown toggling, ``default``
+semantics, and ``!``/``#`` comment handling are shared with the other Cisco-style
+vendors via :mod:`diffnc.vendors._cisco_like`.
+
+Unlike IOS, saved NX-OS configurations do not typically include ``end`` / ``exit``
+terminator lines, so we leave the ``terminators`` set empty here to keep the existing
+behaviour where such lines would be parsed as ordinary config statements if present.
+"""
+
+from __future__ import annotations
+
+from diffnc.vendors._cisco_like import CiscoLikeParser
+from diffnc.vendors.base import VendorParser
+
+PARSER: VendorParser = CiscoLikeParser(
+    name="nxos",
+    indent_unit=2,
+    terminators=frozenset(),
+)

diffnc-0.0.1.dist-info/METADATA

@@ -0,0 +1,283 @@
+Metadata-Version: 2.4
+Name: diffnc
+Version: 0.0.1
+Summary: Structural diff library for network device configurations
+Author-email: minefuto <46558834+minefuto@users.noreply.github.com>
+License: MIT License
+        
+        Copyright (c) 2026 minefuto
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# diffnc(DIFF for Network device Configurations)
+
+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
+* **Only sections where order carries meaning emit order diffs** (Junos `firewall filter` / `policy-statement` terms, Cisco `access-list` / `policy-map`, etc.). Everywhere else, reordering alone produces no diff
+* Vendor is auto-detected. Diffing across vendors raises an error
+* Supported vendors: **Cisco NX-OS**, **Cisco IOS**, **Cisco IOS-XE**, **Cisco IOS-XR**, **Arista EOS**, **Junos** (hierarchical), **Junos set** (`display set` format)
+
+## Installation
+
+```bash
+pip install diffnc
+```
+
+For development:
+
+```bash
+uv sync
+```
+
+## Library usage
+
+```python
+from diffnc import unified_diff, ndiff
+
+with open("router-before.conf") as f:
+    a = f.read()
+with open("router-after.conf") as f:
+    b = f.read()
+
+# Structural unified diff (shows changed lines and their parent sections only)
+for line in unified_diff(a, b, fromfile="before", tofile="after"):
+    print(line, end="")
+
+# Full ndiff
+for line in ndiff(a, b):
+    print(line, end="")
+```
+
+To force a specific vendor:
+
+```python
+unified_diff(a, b, vendor="junos_set")
+```
+
+To only run detection:
+
+```python
+from diffnc import detect_vendor
+detect_vendor(open("config.conf").read())  # -> "nxos"
+```
+
+### `reconcile` (experimental)
+
+> **Experimental.** The output shape and exact command sequences may change in future releases. Always review the generated commands before applying them to a live device.
+
+`reconcile(a, b)` returns the bare config-mode command lines that, when entered on a device currently running config *A*, bring it to the state described by config *B*.
+
+```python
+from diffnc import reconcile
+
+for line in reconcile(a, b):
+    print(line)
+```
+
+Output is config-mode commands only — no `configure terminal` / `end` / `commit` wrappers, no indentation. Pipe through your own session manager.
+
+* **Cisco-like (NX-OS / IOS / IOS-XE / IOS-XR / EOS):** emits section navigation plus `<line>` for adds and `no <line>` for deletes (with `no no foo` collapsed to `foo`, so `no shutdown` ↔ `shutdown` toggles correctly).
+* **Junos hierarchical:** emits flat `set <path>` and `delete <path>` lines.
+* **Junos set:** emits `<line>` verbatim for adds and `delete <path>` (with the `set ` / `activate ` / `deactivate ` prefix stripped) for deletes.
+* **Order-sensitive sections** (ACL, `policy-map`, Junos `firewall filter` / `policy-statement` terms): on any change, the entire section is deleted and recreated from *B* — partial in-place edits are not attempted.
+
+Exceptions:
+
+| Exception | When it is raised |
+| --- | --- |
+| `VendorMismatchError` | The two configs are detected as different vendors (e.g. Junos set vs. Junos hierarchical is also rejected here) |
+| `ParseError`          | Vendor detection failed, syntax error, etc. |
+
+## CLI
+
+```
+diffnc [OPTIONS] FILE_A FILE_B
+
+  -u, --unified           Structural unified diff (default)
+  -n, --ndiff             Full ndiff output
+  -r, --reconcile         Emit config-mode commands that transform FILE_A into FILE_B (experimental)
+  --vendor {junos,junos_set,nxos,ios,iosxe,iosxr,eos}
+                          Skip auto-detection and use the given vendor
+  --color {auto,always,never}
+                          Colorize +/- lines (auto = tty detection)
+  --version
+```
+
+Exit codes follow `diff(1)`: `0` = no differences, `1` = differences found, `2` = error.
+
+Example:
+
+```bash
+$ diffnc before.conf after.conf
+--- before.conf
++++ after.conf
++feature ospf
+ interface Ethernet1/1
+-  description uplink
++  description uplink-to-spine
+```
+
+Or, in reconcile mode (**experimental**):
+
+```bash
+$ diffnc before.conf after.conf -r
+interface Ethernet1/1
+no description uplink
+description uplink-to-spine
+feature ospf
+```
+
+## Example: normalizing duplicate blocks
+
+Input A:
+
+```
+interface eth1
+  no shut
+  ip address 1.1.1.1/24
+  stp
+```
+
+Input B (the same `interface eth1` appears twice):
+
+```
+interface eth1
+  shut
+  ip address 1.1.1.1/24
+
+interface eth1
+  stp
+```
+
+`ndiff` output:
+
+```
+  interface eth1
+-   no shut
++   shut
+    ip address 1.1.1.1/24
+    stp
+```
+
+## How order is handled
+
+Network device configurations mix "sections whose semantics don't depend on order" with "sections where order determines behavior." diffnc diffs **order-insensitively by default** and only does **position-based comparison for parent paths where order carries meaning**.
+
+### Order-insensitive (reorder ≠ diff)
+
+Most containers fall into this bucket. Examples: `system`, `interfaces`, `routing-options`, `vrf context`, top-level `interface ...`, `route-map FOO permit <seq>`, and so on. Reshuffling the children alone produces an empty diff.
+
+```
+# A
+system {
+    host-name foo;
+    domain-name example.com;
+}
+
+# B
+system {
+    domain-name example.com;
+    host-name foo;
+}
+
+$ diffnc a.conf b.conf   # → no diff, exit 0
+```
+
+### Order-sensitive (reorder = diff)
+
+The paths below are evaluated in declaration order by the device, so swapping term/ACE/class order produces diff output.
+
+| Vendor | Parent path | Children |
+| --- | --- | --- |
+| Junos | `firewall.filter <name>` | `term <name>` |
+| Junos | `firewall.family <fam>.filter <name>` | `term <name>` |
+| Junos | `policy-options.policy-statement <name>` | `term <name>` |
+| Cisco-like (IOS / IOS-XE / IOS-XR / NX-OS / EOS) | `ip access-list <name>`, `ipv6 access-list <name>`, `mac access-list <name>` | ACE lines |
+| Cisco-like (same as above) | `policy-map <name>` | `class <name>` blocks |
+
+Pure reorders (children whose rendered subtree is byte-identical on both sides, just in a different position) are surfaced with a `!` marker, once per moved subtree. Children whose contents also changed continue to use `-` / `+` pairs.
+
+Example: swapping two byte-identical terms inside a Junos firewall filter
+
+```diff
+ firewall {
+     filter F {
+!        term B {
+!            then discard;
+!        }
+     }
+ }
+```
+
+Example: a reorder of one term plus a content change in another term
+
+```diff
+ firewall {
+     filter F {
+!        term A {
+!            then accept;
+!        }
+         term B {
+-            then discard;
++            then reject;
+         }
+     }
+ }
+```
+
+### Customizing the behavior for a new vendor
+
+The `VendorParser` protocol exposes `is_order_sensitive(path: tuple[str, ...]) -> bool`. `path` is the tuple of `line` values from the root down to "the parent node whose children are being compared." Returning `True` makes the children compared positionally via `SequenceMatcher`; returning `False` (the default) falls back to set-style key comparison. If you're subclassing the Cisco family, the shortest path is to pass `order_sensitive_predicate` to `CiscoLikeParser(...)`.
+
+## Development
+
+```bash
+uv sync --extra dev
+uv run pytest          # tests
+uv run ruff check .    # lint
+uv run ruff format .   # format
+uv run ty check        # type check
+```
+
+## Adding a new vendor
+
+Create a new module under `src/diffnc/vendors/`, expose an implementation of the `VendorParser` protocol (`src/diffnc/vendors/base.py`) as `PARSER`, call `register(_yourvendor.PARSER)` from `src/diffnc/vendors/__init__.py`, and add the corresponding case to the detection logic in `src/diffnc/detect.py`.
+
+`VendorParser` requires the following methods:
+
+* `parse(text) -> ConfigTree`
+* `format(tree) -> list[str]`
+* `render_open(node, depth) -> str`
+* `render_close(node, depth) -> str | None`
+* `render_leaf(node, depth) -> str`
+* `is_order_sensitive(path) -> bool` (optional; treated as always `False` if not implemented. See the "How order is handled" section.)
+* `render_reconcile(events) -> Iterator[str]` (optional; required only to support `reconcile`. Receives a sequence of `ReconcileAdd` / `ReconcileDelete` / `ReconcileRecreate` events from `diffnc.reconcile` and yields the corresponding CLI lines.)
+
+## License
+
+MIT

diffnc-0.0.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+diffnc/__init__.py,sha256=yavFeCIll2bGmhWcWVto-7okLVvIbjwHh7b8nCgxWFA,943
+diffnc/__main__.py,sha256=hMk6DO5C-rRNRXCLgWgounKjoKZFY-z3e8RGksfkCqo,179
+diffnc/cli.py,sha256=3deyuQqb0-vQf6QuhuI7OyTbps-sk8NF9LGxUYwMvys,4006
+diffnc/detect.py,sha256=Bg1bRDsNvzEEC8kABL8aNCDk16N2uH5DyV84I49iW1s,5191
+diffnc/diff.py,sha256=pnR62dCgN1dLUtu1laUx0noHh4ewsHF3rr6IaWFqd4E,12082
+diffnc/errors.py,sha256=PfEvBZAEA7jeYzoyCNdZpvo1jhCF8OoH_dZZdPT-b9k,648
+diffnc/ir.py,sha256=gN06VRvIGArvMPOOpeNZbQ6zEbvrfRfcowUtU0k-eWE,1979
+diffnc/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffnc/reconcile.py,sha256=kGlRBiFpAfd6bgflrM2oZCFwv89Uo7jRMaiLf5OhEo4,4714
+diffnc/vendors/__init__.py,sha256=s5db9NNpV337_ov11PWlmGoyGp8iqtnm1i8JE3q7kuo,1726
+diffnc/vendors/_cisco_like.py,sha256=jCS3g1b_jYLHgMWC0bJG8-qsb8UA2p9E-vL8VtTzk_I,7250
+diffnc/vendors/base.py,sha256=DxHcmYd4Tj2VbI2xnPwAtLzH56Z2wOMrG7_FiwpN-Nw,3305
+diffnc/vendors/eos.py,sha256=DizzGfb5Qcytj3CEYMPPw3uG78n428RuTQBLZs2ZOpU,704
+diffnc/vendors/ios.py,sha256=jEvlUlV3XOJ04Q5K_oJtcmflBvnBi3gjOS4-Q4PFzXk,694
+diffnc/vendors/iosxe.py,sha256=xsdyjALeJi66Zp17U2grdbBxQfiP6yzB60APakHbRNo,757
+diffnc/vendors/iosxr.py,sha256=ZoKXFYmnM0wIDPxqMZAQ5XXIdrluOTAfIvx63_WqrX4,734
+diffnc/vendors/junos.py,sha256=rufK-hmz8kvRa30OeU4LxYRtan95xIpRvrQ5x9jxINo,5896
+diffnc/vendors/junos_set.py,sha256=y-_NaK4_fjRJbcjQlEXVRWMa_dg4j2EMi6-IGxvghSM,5807
+diffnc/vendors/nxos.py,sha256=Kt9sSSf_5vfVWgq9GipcZSgghdut6yK0J23wLCx4h2s,817
+diffnc-0.0.1.dist-info/METADATA,sha256=2--nghNCTvJJFsusR8XBKUn6xVpRzr1MdRdD6cxEXEk,9748
+diffnc-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+diffnc-0.0.1.dist-info/entry_points.txt,sha256=F79q2jhkvDItSS2e4LhCFhPRy7w6PZ-F2aR9sg9LXvs,43
+diffnc-0.0.1.dist-info/licenses/LICENSE,sha256=nQ7lrLsasMOfMg78sASYIcvRRhqCvGUYV7_1dXBbsBc,1065
+diffnc-0.0.1.dist-info/RECORD,,

diffnc-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

diffnc-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+diffnc = diffnc.cli:main

diffnc-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 minefuto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.