diffnc 0.0.1__py3-none-any.whl

diffnc/__init__.py

@@ -0,0 +1,37 @@
+"""Structural diff for network device configurations.
+
+Public API mirrors :mod:`difflib`:
+
+* :func:`unified_diff` — compact, change-focused diff with section context.
+* :func:`ndiff` — every-line diff with ``- ``/``+ ``/``  `` markers.
+* :func:`reconcile` — config-mode commands that transform *A* into *B*.
+* :func:`detect_vendor` — auto-detect the vendor for a config blob.
+
+Errors are exposed via :class:`DiffncError` and its subclasses.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import version
+
+from diffnc.detect import detect_vendor
+from diffnc.diff import ndiff, unified_diff
+from diffnc.errors import (
+    DiffncError,
+    ParseError,
+    VendorMismatchError,
+)
+from diffnc.reconcile import reconcile
+
+__all__ = [
+    "DiffncError",
+    "ParseError",
+    "VendorMismatchError",
+    "__version__",
+    "detect_vendor",
+    "ndiff",
+    "reconcile",
+    "unified_diff",
+]
+
+__version__ = version("diffnc")

diffnc/__main__.py

@@ -0,0 +1,8 @@
+"""Allow ``python -m diffnc`` to dispatch to the CLI."""
+
+from __future__ import annotations
+
+from diffnc.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

diffnc/cli.py

@@ -0,0 +1,140 @@
+"""Command-line interface — ``diffnc FILE_A FILE_B``.
+
+Exit codes follow :manpage:`diff(1)`:
+
+* ``0`` — inputs are equivalent (no diff output).
+* ``1`` — inputs differ.
+* ``2`` — an error occurred (parse failure, vendor mismatch, missing file, ...).
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Iterable
+from pathlib import Path
+
+from diffnc import __version__
+from diffnc.diff import ndiff, unified_diff
+from diffnc.errors import DiffncError
+from diffnc.reconcile import reconcile
+
+_GREEN = "\x1b[32m"
+_RED = "\x1b[31m"
+_YELLOW = "\x1b[33m"
+_RESET = "\x1b[0m"
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = _build_argument_parser()
+    args = parser.parse_args(argv)
+
+    try:
+        text_a = _read_file(args.file_a)
+        text_b = _read_file(args.file_b)
+    except OSError as exc:
+        print(f"diffnc: {exc}", file=sys.stderr)
+        return 2
+
+    try:
+        if args.mode == "ndiff":
+            lines: Iterable[str] = ndiff(text_a, text_b, lineterm="\n", vendor=args.vendor)
+        elif args.mode == "reconcile":
+            lines = (f"{line}\n" for line in reconcile(text_a, text_b, vendor=args.vendor))
+        else:
+            lines = unified_diff(
+                text_a,
+                text_b,
+                fromfile=str(args.file_a),
+                tofile=str(args.file_b),
+                lineterm="\n",
+                vendor=args.vendor,
+            )
+        materialised = list(lines)
+    except DiffncError as exc:
+        print(f"diffnc: {exc}", file=sys.stderr)
+        return 2
+
+    if not materialised:
+        return 0
+
+    use_color = _should_colorize(args.color)
+    for line in materialised:
+        sys.stdout.write(_colorize(line, use_color))
+
+    return 1
+
+
+def _build_argument_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="diffnc",
+        description="Structural diff for network device configurations.",
+    )
+    parser.add_argument("file_a", type=Path, help="left-hand configuration file")
+    parser.add_argument("file_b", type=Path, help="right-hand configuration file")
+
+    mode_group = parser.add_mutually_exclusive_group()
+    mode_group.add_argument(
+        "-u",
+        "--unified",
+        dest="mode",
+        action="store_const",
+        const="unified",
+        help="emit a compact, structure-aware unified diff (default)",
+    )
+    mode_group.add_argument(
+        "-n",
+        "--ndiff",
+        dest="mode",
+        action="store_const",
+        const="ndiff",
+        help="emit a verbose diff showing every line",
+    )
+    mode_group.add_argument(
+        "-r",
+        "--reconcile",
+        dest="mode",
+        action="store_const",
+        const="reconcile",
+        help="emit config-mode commands that transform FILE_A into FILE_B",
+    )
+    parser.set_defaults(mode="unified")
+
+    parser.add_argument(
+        "--vendor",
+        choices=["junos", "junos_set", "nxos", "ios", "iosxe", "iosxr", "eos"],
+        default=None,
+        help="skip auto-detection and force a vendor",
+    )
+    parser.add_argument(
+        "--color",
+        choices=["auto", "always", "never"],
+        default="auto",
+        help="colorise +/- lines (default: auto, based on terminal)",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def _read_file(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def _should_colorize(mode: str) -> bool:
+    if mode == "always":
+        return True
+    if mode == "never":
+        return False
+    return sys.stdout.isatty()
+
+
+def _colorize(line: str, use_color: bool) -> str:
+    if not use_color:
+        return line
+    if line.startswith("+") and not line.startswith("+++"):
+        return f"{_GREEN}{line}{_RESET}"
+    if line.startswith("-") and not line.startswith("---"):
+        return f"{_RED}{line}{_RESET}"
+    if line.startswith("!"):
+        return f"{_YELLOW}{line}{_RESET}"
+    return line

diffnc/detect.py

@@ -0,0 +1,170 @@
+"""Vendor auto-detection.
+
+The detector inspects a configuration's signal-bearing lines and returns the vendor name.
+Heuristics are intentionally conservative: when in doubt, raise :class:`ParseError` so the
+caller can ask the user to disambiguate via ``--vendor``.
+"""
+
+from __future__ import annotations
+
+import re
+
+from diffnc.errors import ParseError
+
+_JUNOS_TOP_KEYWORDS = (
+    "interfaces",
+    "system",
+    "routing-options",
+    "routing-instances",
+    "protocols",
+    "policy-options",
+    "firewall",
+    "security",
+    "groups",
+    "chassis",
+    "snmp",
+    "services",
+    "applications",
+    "forwarding-options",
+)
+
+_NXOS_INTERFACE_RE = re.compile(r"^interface Ethernet\d+/\d+")
+
+_IOS_INTERFACE_PREFIXES = (
+    "interface FastEthernet",
+    "interface GigabitEthernet",
+    "interface TenGigabitEthernet",
+    "interface Serial",
+)
+
+# Cisco "speed-named" interface prefixes shared by IOS / IOS-XE / IOS-XR. The classic
+# bare ``Ethernet`` prefix is excluded because it belongs to NX-OS and Arista EOS.
+_CISCO_NAMED_IFACES = (
+    "FastEthernet",
+    "GigabitEthernet",
+    "TenGigabitEthernet",
+    "TenGigE",
+    "TwentyFiveGigE",
+    "FortyGigE",
+    "HundredGigE",
+)
+_CISCO_NAMED_GROUP = "|".join(_CISCO_NAMED_IFACES)
+
+# IOS-XE distinguishes itself with a 3-tuple slot/subslot/port (e.g.
+# ``GigabitEthernet0/0/0``) — distinct from classic IOS's 2-tuple form.
+_IOSXE_INTERFACE_RE = re.compile(rf"^interface (?:{_CISCO_NAMED_GROUP})\d+/\d+/\d+(?:\.\d+)?$")
+
+# IOS-XR uses a 4-tuple slot/subslot/instance/port for physical interfaces.
+_IOSXR_INTERFACE_RE = re.compile(rf"^interface (?:{_CISCO_NAMED_GROUP})\d+/\d+/\d+/\d+")
+
+
+def _has_nxos_marker(lines: list[str]) -> bool:
+    for s in lines:
+        if s.startswith(("feature ", "vrf context ", "vdc ")):
+            return True
+        if _NXOS_INTERFACE_RE.match(s):
+            return True
+    return False
+
+
+def _has_ios_marker(lines: list[str]) -> bool:
+    for s in lines:
+        if s.startswith(("service password-encryption", "service timestamps")):
+            return True
+        if s in ("boot-start-marker", "boot-end-marker"):
+            return True
+        if s.startswith(_IOS_INTERFACE_PREFIXES):
+            return True
+        if s.startswith(("line con ", "line vty ")):
+            return True
+    return False
+
+
+def _has_iosxe_marker(lines: list[str]) -> bool:
+    for s in lines:
+        if s.startswith(("platform ", "license boot level")):
+            return True
+        if s.startswith(("boot system bootflash:", "boot system flash")):
+            return True
+        if _IOSXE_INTERFACE_RE.match(s):
+            return True
+    return False
+
+
+def _has_iosxr_marker(lines: list[str]) -> bool:
+    for s in lines:
+        if s.startswith(("interface Bundle-Ether", "interface MgmtEth")):
+            return True
+        if s.startswith("RP/0/"):
+            return True
+        if _IOSXR_INTERFACE_RE.match(s):
+            return True
+    return False
+
+
+def _has_eos_marker(lines: list[str]) -> bool:
+    for s in lines:
+        if s.startswith(
+            (
+                "vrf instance ",
+                "daemon TerminAttr",
+                "management api http-commands",
+                "service routing protocols model",
+                "transceiver qsfp default-mode",
+            )
+        ):
+            return True
+    return False
+
+
+def detect_vendor(text: str) -> str:
+    """Return the vendor name for *text*.
+
+    Raises:
+        ParseError: if no supported vendor can be confidently identified.
+    """
+
+    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)
+
+    if not significant:
+        raise ParseError("configuration is empty or comment-only")
+
+    # Junos set form: most lines start with `set ` (or `deactivate `/`activate `/`delete `).
+    set_like = sum(
+        1 for s in significant if s.startswith(("set ", "deactivate ", "activate ", "delete "))
+    )
+    if set_like / len(significant) >= 0.8:
+        return "junos_set"
+
+    # Junos hierarchical: presence of braces and at least one Junos top-level keyword.
+    has_brace = any(s.endswith("{") or s == "}" for s in significant)
+    has_junos_kw = any(
+        s.split(" ", 1)[0] in _JUNOS_TOP_KEYWORDS or s.startswith(kw + " {")
+        for s in significant
+        for kw in _JUNOS_TOP_KEYWORDS
+    )
+    if has_brace and has_junos_kw:
+        return "junos"
+
+    # Brace-less indent-based vendors: NX-OS, IOS, IOS-XE, IOS-XR, EOS. Checks are
+    # ordered by marker specificity so a mixed config (e.g. EOS with copied IOS-style
+    # lines) stays on the more specific vendor.
+    if not has_brace:
+        if _has_eos_marker(significant):
+            return "eos"
+        if _has_iosxr_marker(significant):
+            return "iosxr"
+        if _has_nxos_marker(significant):
+            return "nxos"
+        if _has_iosxe_marker(significant):
+            return "iosxe"
+        if _has_ios_marker(significant):
+            return "ios"
+        return "nxos"
+
+    raise ParseError("could not detect vendor from configuration text")