annet 3.8.0__tar.gz → 3.9.1__tar.gz

{annet-3.8.0/annet.egg-info → annet-3.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annet
-Version: 3.8.0
+Version: 3.9.1
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-3.8.0 → annet-3.9.1}/annet/annlib/jsontools.py

@@ -4,8 +4,9 @@ import copy
 import fnmatch
 import json
 from collections.abc import Mapping, Sequence
+from itertools import starmap
 from operator import itemgetter
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Iterable, List, Optional
 
 import jsonpatch
 import jsonpointer
@@ -16,23 +17,28 @@ def format_json(data: Any, stable: bool = False) -> str:
     return json.dumps(data, indent=4, ensure_ascii=False, sort_keys=not stable) + "\n"
 
 
-def _sanitize_json_pointer(pattern: str) -> str:
-    """Replace special characters on the JsonPointer valid ones"""
-    return pattern.replace("~", "~0").replace("/", "~1")
-
-
 def apply_json_fragment(
         old: Dict[str, Any],
-        new_fragment: Dict[str, Any],
-        acl: List[str],
+        new_fragment: Dict[str, Any], *,
+        acl: Sequence[str],
+        filters: Sequence[str] | None = None,
 ) -> Dict[str, Any]:
     """
     Replace parts of the old document with 'new_fragment' using ACL restrictions.
+    If `filter` is not `None`, only those parts which also matches at least one filter
+    from the list will be modified (updated or deleted).
     """
     full_new_config = copy.deepcopy(old)
     for acl_item in acl:
         new_pointers = _resolve_json_pointers(acl_item, new_fragment)
         old_pointers = _resolve_json_pointers(acl_item, full_new_config)
+        if filters is not None:
+            new_pointers = _apply_filters_to_json_pointers(
+                new_pointers, filters, content=new_fragment
+            )
+            old_pointers = _apply_filters_to_json_pointers(
+                old_pointers, filters, content=full_new_config
+            )
 
         for pointer in new_pointers:
             new_value = pointer.get(new_fragment)
@@ -102,30 +108,7 @@ def apply_patch(content: Optional[bytes], patch_bytes: bytes) -> bytes:
     return new_contents
 
 
-def apply_acl_filters(content: Dict[str, Any], filters: List[str]) -> Dict[str, Any]:
-    result = {}
-    for f in filters:
-        filter_text = f.strip()
-        if not filter_text:
-            continue
-
-        pointers = _resolve_json_pointers(filter_text, content)
-        for pointer in pointers:
-            part = pointer.get(copy.deepcopy(content))
-
-            sub_tree = result
-            for i in pointer.get_parts():
-                if i not in sub_tree:
-                    sub_tree[i] = {}
-                sub_tree = sub_tree[i]
-
-            patch = jsonpatch.JsonPatch([{"op": "add", "path": pointer.path, "value": part}])
-            result = patch.apply(result)
-
-    return result
-
-
-def _resolve_json_pointers(pattern: str, content: Dict[str, Any]) -> List[jsonpointer.JsonPointer]:
+def _resolve_json_pointers(pattern: str, content: dict[str, Any]) -> list[jsonpointer.JsonPointer]:
     """
     Resolve globbed json pointer pattern to a list of actual pointers, existing in the document.
 
@@ -163,7 +146,7 @@ def _resolve_json_pointers(pattern: str, content: Dict[str, Any]) -> List[jsonpo
     ]
     """
     parts = jsonpointer.JsonPointer(pattern).parts
-    matched = [([], content)]
+    matched = [((), content)]
     for part in parts:
         new_matched = []
         for matched_parts, doc in matched:
@@ -179,10 +162,67 @@ def _resolve_json_pointers(pattern: str, content: Dict[str, Any]) -> List[jsonpo
                     if fnmatch.fnmatchcase(str(i), part)
                 ]
             for key, sub_doc in keys_and_docs:
-                new_matched.append((matched_parts + [key], sub_doc))
+                new_matched.append((matched_parts + (key,), sub_doc))
         matched = new_matched
 
-    ret: List[jsonpointer.JsonPointer] = []
+    ret: list[jsonpointer.JsonPointer] = []
     for matched_parts, _ in matched:
-        ret.append(jsonpointer.JsonPointer("/" + "/".join([_sanitize_json_pointer(v) for v in matched_parts])))
+        ret.append(jsonpointer.JsonPointer.from_parts(matched_parts))
     return ret
+
+
+def _apply_filters_to_json_pointers(
+        pointers: Iterable[jsonpointer.JsonPointer],
+        filters: Sequence[str], *,
+        content: Any,
+) -> list[jsonpointer.JsonPointer]:
+
+    """
+    Takes a list of pointers, a list of filters and a document
+    and returns a list of pointers that match at least one of the filters
+    (if necessary, pointers may be deeper than from the input).
+
+    For example, given:
+    pointers=["/foo", "/lorem/ipsum", "/lorem/dolor"],
+    filters=["/foo/b*/q*", "/lorem"],
+    content={
+        "foo": {
+            "bar": {
+                "baz": [1, 2],
+                "qux": [3, 4]
+            },
+            "qux": {
+                "baz": [5, 6]
+            }
+        },
+        "lorem": {
+            "ipsum": [7, 8],
+            "dolor": "sit",
+            "amet": "consectetur"
+        }
+    }
+    The function will return:
+    ["/foo/bar/qux", "/lorem/ipsum", "/lorem/dolor"]
+    """
+
+    ret: set[jsonpointer.JsonPointer] = set()
+    for filter_item in filters:
+        filter_parts = jsonpointer.JsonPointer(filter_item).parts
+        for pointer in pointers:
+            pointer_parts = pointer.parts
+            if not all(starmap(fnmatch.fnmatchcase, zip(pointer_parts, filter_parts))):
+                continue  # common part not matched
+            if len(filter_parts) > len(pointer_parts):
+                # filter is deeper than data pointer
+                deeper_doc = pointer.resolve(content)
+                deeper_pattern = "".join((
+                    f"/{jsonpointer.escape(part)}"
+                    for part in filter_parts[len(pointer_parts):]
+                ))
+                ret.update(map(pointer.join, _resolve_json_pointers(deeper_pattern, deeper_doc)))
+            else:
+                ret.add(pointer)
+    # sort return value by some stable key, to decrease the chance
+    # that some bug may lead to unstable output being produced
+    # (since `type(ret) is set`)
+    return sorted(ret, key=str)

{annet-3.8.0 → annet-3.9.1}/annet/annlib/netdev/devdb/data/devdb.json

@@ -63,7 +63,12 @@
     "Huawei.Quidway.S2x.S2300": "23\\d\\d",
     "Huawei.Quidway.S2x.S2700": "27\\d\\d",
     "Huawei.Quidway.S5300": "53\\d\\d",
+    "Huawei.Quidway.S5300.S5328": "5328",
+    "Huawei.Quidway.S5300.S5352": "5352",
     "Huawei.Quidway.S5700": "57\\d\\d",
+    "Huawei.Quidway.S5700.S5731": "5731",
+    "Huawei.Quidway.S5700.S5735": "5735",
+    "Huawei.Quidway.S5700.S5735I": "5735I",
     "Huawei.Quidway.S6700": "67\\d\\d",
     "Huawei.NE": " NE\\d+",
     "Huawei.NE.NE40E": " NE40E",
@@ -152,8 +157,12 @@
     "Aruba.AP.AP300.AP367": " AP-367",
     "Aruba.AP.AP300.AP377": " AP-377",
     "Aruba.AP.AP500": " AP-5\\d\\d",
+    "Aruba.AP.AP500.AP505": " AP-505",
     "Aruba.AP.AP500.AP514": " AP-514",
     "Aruba.AP.AP500.AP515": " AP-515",
+    "Aruba.AP.AP500.AP535": " AP-535",
+    "Aruba.AP.AP500.AP565": " AP-565",
+    "Aruba.AP.AP500.AP567": " AP-567",
     "Aruba.AP.AP600": " AP-6\\d\\d",
     "Aruba.AP.AP600.AP615": " AP-615",
     "Aruba.AP.AP600.AP635": " AP-635",
@@ -178,4 +187,4 @@
     "B4com.CS4132U": "^[Bb]4com B4T-CS4132U.*",
     "B4com.CS4148Q": "^[Bb]4com B4T-CS4148Q.*",
     "B4com.CS4164U": "^[Bb]4com B4T-CS4164U.*"
-}
+}

{annet-3.8.0 → annet-3.9.1}/annet/gen.py

@@ -259,38 +259,19 @@ def _old_new_per_device(ctx: OldNewDeviceContext, device: Device, filterer: Filt
 
         entire_results = res.entire_results
         json_fragment_results = res.json_fragment_results
-        old_json_fragment_files = old_files.json_fragment_files
 
         new_files = res.new_files()
-        new_json_fragment_files = res.new_json_fragment_files(old_json_fragment_files)
-
-        filters: List[str] = []
-        filters_text = build_filter_text(filterer, device, ctx.stdin, ctx.args, ctx.config)
-        if filters_text:
-            filters = filters_text.split("\n")
-
-            for file_name in new_json_fragment_files:
-                if new_json_fragment_files.get(file_name) is not None:
-                    new_json_fragment_files = _update_json_config(
-                        new_json_fragment_files,
-                        file_name,
-                        jsontools.apply_acl_filters(new_json_fragment_files[file_name][0], filters)
-                    )
-            for file_name in old_json_fragment_files:
-                if old_json_fragment_files.get(file_name) is not None:
-                    old_json_fragment_files[file_name] = jsontools.apply_acl_filters(old_json_fragment_files[file_name], filters)
+
+        filters = None
+        if filters_text := build_filter_text(filterer, device, ctx.stdin, ctx.args, ctx.config):
+            filters = filters_text.removesuffix("\n").split("\n")
+
+        old_json_fragment_files = old_files.json_fragment_files.copy()
+        new_json_fragment_files = res.new_json_fragment_files(old_json_fragment_files, filters=filters)
 
         if ctx.args.acl_safe:
             safe_new_files = res.new_files(safe=True)
-            safe_new_json_fragment_files = res.new_json_fragment_files(old_json_fragment_files, safe=True)
-            if filters:
-                for file_name in safe_new_json_fragment_files:
-                    if safe_new_json_fragment_files.get(file_name):
-                        safe_new_json_fragment_files = _update_json_config(
-                            safe_new_json_fragment_files,
-                            file_name,
-                            jsontools.apply_acl_filters(safe_new_json_fragment_files[file_name][0], filters)
-                        )
+            safe_new_json_fragment_files = res.new_json_fragment_files(old_json_fragment_files, safe=True, filters=filters)
 
     if ctx.args.profile:
         perf = res.perf_mesures()
@@ -322,13 +303,6 @@ def _old_new_per_device(ctx: OldNewDeviceContext, device: Device, filterer: Filt
     )
 
 
-def _update_json_config(json_files, file_name, new_config):
-    file = list(json_files[file_name])
-    file[0] = new_config
-    json_files[file_name] = tuple(file)
-    return json_files
-
-
 @dataclasses.dataclass
 class DeviceDownloadedFiles:
     # map file path to file content for entire generators

{annet-3.8.0 → annet-3.9.1}/annet/generators/result.py

@@ -4,9 +4,11 @@ import textwrap
 from collections import OrderedDict as odict
 from typing import (
     Any,
+    Callable,
     Dict,
     Optional,
-    Tuple, Callable,
+    Sequence,
+    Tuple,
 )
 
 from annet.annlib import jsontools
@@ -84,6 +86,7 @@ class RunGeneratorResult:
             self,
             old_files: Dict[str, Optional[str]],
             safe: bool = False,
+            filters: Sequence[str] | None = None,
     ) -> Dict[str, Tuple[Any, Optional[str]]]:
         # TODO: safe
         files: Dict[str, Tuple[Any, Optional[str]]] = {}
@@ -101,9 +104,9 @@ class RunGeneratorResult:
             previous_config: Dict[str, Any] = files[filepath][0]
             new_fragment = generator_result.config
             new_config = jsontools.apply_json_fragment(
-                previous_config,
-                new_fragment,
-                result_acl,
+                previous_config, new_fragment,
+                acl=result_acl,
+                filters=filters,
             )
             if jsontools.format_json(new_config) == jsontools.format_json(previous_config):
                 # config is not changed, deprioritize reload_cmd

{annet-3.8.0 → annet-3.9.1}/annet/implicit.py

@@ -63,6 +63,19 @@ def _implicit_tree(device):
                     undo user-password complexity-check
                  netconf
                  """
+        elif device.hw.Huawei.Quidway.S5700.S5735I:
+            text = """
+                !interface *
+                    port link-type access
+                interface NULL0
+            """
+        elif device.hw.Huawei.Quidway.S2x:
+            text = """
+                !interface *
+                    port link-type hybrid
+                    dot1x enable
+                interface NULL0
+            """
         else:
             text = """
                 stp mode mstp
@@ -158,10 +171,14 @@ def _implicit_tree(device):
             """
         if device.hw.Cisco.Catalyst:
             # this configuration is not visible in running-config when enabled
+            # no vstack and system mtu are default values
             text += r"""
                 # line console aaa config
                 !line con 0
                     authorization exec default
+                no vstack
+                system mtu routing 1500
+                system mtu jumbo 9000
             """
     return parse_text(text)
 

{annet-3.8.0 → annet-3.9.1}/annet/rulebook/texts/huawei.rul

@@ -428,6 +428,12 @@ isis *
 
 error-down auto-recovery cause link-flap
 
+configuration file auto-save backup-to-server server
+configuration file auto-save
+
+
+set save-configuration backup-to-server *
+set save-configuration *
 
 ip route-static default-bfd
 ipv6 route-static default-bfd

{annet-3.8.0 → annet-3.9.1/annet.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annet
-Version: 3.8.0
+Version: 3.9.1
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT