annet 0.13.6__py3-none-any.whl → 0.14.1__py3-none-any.whl

annet/adapters/netbox/v37/storage.py

@@ -204,7 +204,7 @@ class NetboxStorageV37(Storage):
         res = extend_device(
             device=device,
             storage=self,
-            interfaces=interfaces[device.id],
+            interfaces=interfaces,
             neighbours=neighbours,
         )
         return res

annet/annlib/jsontools.py

@@ -28,7 +28,11 @@ def apply_json_fragment(
         try:
             new_value = pointer.get(new_fragment)
         except jsonpointer.JsonPointerException:
-            # no value found in new_fragment by the pointer, skip the ACL item
+            # no value found in new_fragment by the pointer,
+            # try to delete it from the new config
+            doc, part = pointer.to_last(full_new_config)
+            if isinstance(doc, dict) and isinstance(part, str):
+                doc.pop(part, None)
             continue
 
         _ensure_pointer_exists(full_new_config, pointer)

annet/annlib/patching.py

@@ -15,8 +15,8 @@ from typing import (  # pylint: disable=unused-import
 from .lib import jun_activate, merge_dicts, strip_annotation, uniq
 from .rbparser import platform
 from .rbparser.ordering import compile_ordering_text
-from .rulebook.common import default as common_default
 from .rulebook.common import call_diff_logic
+from .rulebook.common import default as common_default
 from .tabparser import CommonFormatter
 from .types import Diff, Op
 
@@ -115,7 +115,7 @@ class PatchTree:
         return (
             f"PatchTree(\n"
             f"    itms=[\n"
-            f"        {n.join(itms).strip()}\n"
+            f"{textwrap.indent(n.join(itms), '    ')}\n"
             f"    ]\n"
             f")"
         )

annet/annlib/tabparser.py

@@ -1,9 +1,14 @@
+import dataclasses
 import itertools
 import re
 from collections import OrderedDict as odict
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Tuple, Union
 
 from .types import Op
 
+if TYPE_CHECKING:
+    from .patching import PatchTree
+
 
 # =====
 class ParserError(Exception):
@@ -23,6 +28,40 @@ class BlockEnd:
     pass
 
 
+RowWithContext = Tuple[str, Optional[Dict[str, Any]]]
+
+
+def block_wrapper(value: Any) -> Iterable[Any]:
+    yield from iter((BlockBegin, value, BlockEnd))
+
+
+@dataclasses.dataclass
+class FormatterContext:
+    parent: Optional["FormatterContext"] = None
+
+    prev: Optional[RowWithContext] = None
+    current: Optional[RowWithContext] = None
+    next: Optional[RowWithContext] = None
+
+    @property
+    def level(self) -> int:
+        if self.parent is None:
+            return 0
+        return self.parent.level + 1
+
+    @property
+    def row_prev(self) -> Optional[str]:
+        return self.prev and self.prev[0]
+
+    @property
+    def row(self) -> Optional[str]:
+        return self.current and self.current[0]
+
+    @property
+    def row_next(self) -> Optional[str]:
+        return self.next and self.next[0]
+
+
 # =====
 class CommonFormatter:
     def __init__(self, indent="  "):
@@ -41,12 +80,12 @@ class CommonFormatter:
             )
         )
 
-    def diff(self, diff):
-        return list(self._diff_lines(diff))
-
     def diff_generator(self, diff):
         yield from self._diff_lines(diff)
 
+    def diff(self, diff):
+        return list(self.diff_generator(diff))
+
     def patch(self, patch):
         return "\n".join(
             _filtered_block_marks(
@@ -103,17 +142,37 @@ class CommonFormatter:
                 row = self._indent * _level + row
             yield row
 
-    def blocks_and_context(self, tree, is_patch, _level=0, _parent=None):
-        empty_context = {}
+    def blocks_and_context(
+        self,
+        tree: "PatchTree",
+        is_patch: bool,
+        context: Optional[FormatterContext] = None
+    ):
+        if context is None:
+            context = FormatterContext()
+
         if is_patch:
-            items = ((item.row, item.child, item.context) for item in tree.itms)
+            items = [(item.row, item.child, item.context) for item in tree.itms]
         else:
-            items = ((row, child, empty_context) for row, child in tree.items())
-        for row, sub_config, context in items:
-            yield row, context
+            items = [(row, child, {}) for row, child in tree.items()]
+
+        n = len(items)
+        for i in range(n):
+            prev_row, prev_sub_config, prev_row_context = items[i - 1] if i > 0 else (None, None, None)
+            row, sub_config, row_context = items[i]
+            next_row, next_sub_config, next_row_context = items[i + 1] if i + 1 < n else (None, None, None)
+
+            context.current = (row, row_context)
+            context.prev = (prev_row, prev_row_context) if prev_row else None
+            context.next = (next_row, next_row_context) if next_row else None
+
+            yield row, row_context
+
             if sub_config or (is_patch and sub_config is not None):
                 yield BlockBegin, None
-                yield from self.blocks_and_context(sub_config, is_patch, _level + 1, row)
+                yield from self.blocks_and_context(
+                    sub_config, is_patch, context=FormatterContext(parent=context)
+                )
                 yield BlockEnd, None
 
     def _blocks(self, tree, is_patch):
@@ -133,20 +192,32 @@ class BlockExitFormatter(CommonFormatter):
         res = super().split(text)
         return res
 
-    def block_exit(self, parent):
-        if not (parent and parent.startswith(self._no_block_exit)):
-            return self._block_exit
+    def block_exit(self, context: Optional[FormatterContext]) -> Iterable[Any]:
+        current = context and context.row
+        if current and not current.startswith(self._no_block_exit):
+            yield from block_wrapper(self._block_exit)
+
+    def blocks_and_context(self, tree, is_patch, context: Optional[FormatterContext] = None):
+        if context is None:
+            context = FormatterContext()
+
+        level = context.level
+        block_level = level
 
-    def blocks_and_context(self, tree, is_patch, _level=0, _parent=None):
-        last_context = {}
-        for row, context in super().blocks_and_context(tree, is_patch, _level, _parent):
-            yield row, context
-            if context is not None:
-                last_context = context
-        if is_patch and _level > 0:
-            exit_statement = self.block_exit(_parent)
-            if exit_statement:
-                yield exit_statement, last_context
+        last_row_context = {}
+        for row, row_context in super().blocks_and_context(tree, is_patch, context=context):
+            yield row, row_context
+            if row_context is not None:
+                last_row_context = row_context
+
+            if row is BlockBegin:
+                block_level += 1
+            elif row is BlockEnd:
+                block_level -= 1
+
+            if row is BlockEnd and block_level == level and is_patch:
+                for exit_statement in filter(None, self.block_exit(context)):
+                    yield exit_statement, last_row_context
 
 
 class HuaweiFormatter(BlockExitFormatter):
@@ -166,18 +237,30 @@ class HuaweiFormatter(BlockExitFormatter):
         # например на VRP V100R006C00SPC500 + V100R006SPH003
         policy_end_blocks = ("end-list", "endif", "end-filter")
         tree = self.split_remove_spaces(text)
-        tree[:] = filter(lambda x: not x.endswith(policy_end_blocks), tree)
+        tree[:] = filter(lambda x: not str(x).strip().startswith(policy_end_blocks), tree)
         return tree
 
-    def block_exit(self, parent):
-        if parent:
-            if parent.startswith("xpl route-filter"):
-                return "end-filter"
-            elif parent.startswith(("xpl")):
-                return "end-list"
-            elif parent.startswith("if") and parent.endswith("then"):
-                return "endif"
-        return super().block_exit(parent)
+    def block_exit(self, context: Optional[FormatterContext]):
+        row = context and context.row or ""
+        row_next = context and context.row_next
+        parent_row = context and context.parent and context.parent.row or ""
+
+        if row.startswith("xpl route-filter"):
+            yield from block_wrapper("end-filter")
+            return
+
+        if row.startswith("xpl"):
+            yield from block_wrapper("end-list")
+            return
+
+        if parent_row.startswith("xpl route-filter"):
+            if (row.startswith(("if", "elseif")) and row.endswith("then")) and not row_next:
+                yield "endif"
+            elif row == "else":
+                yield "endif"
+            return
+
+        yield from super().block_exit(context)
 
 
 class CiscoFormatter(BlockExitFormatter):
@@ -198,15 +281,17 @@ class AsrFormatter(BlockExitFormatter):
         tree[:] = filter(lambda x: not x.endswith(policy_end_blocks), tree)
         return tree
 
-    def block_exit(self, parent):
-        if parent:
-            if parent.startswith(("prefix-set", "as-path-set", "community-set")):
-                return "end-set"
-            elif parent.startswith("if") and parent.endswith("then"):
-                return "endif"
-            elif parent.startswith("route-policy"):
-                return "end-policy"
-        return super().block_exit(parent)
+    def block_exit(self, context: Optional[FormatterContext]) -> str:
+        current = context and context.row or ""
+
+        if current.startswith(("prefix-set", "as-path-set", "community-set")):
+            yield from block_wrapper("end-set")
+        elif current.startswith("if") and current.endswith("then"):
+            yield from block_wrapper("endif")
+        elif current.startswith("route-policy"):
+            yield from block_wrapper("end-policy")
+        else:
+            yield from super().block_exit(context)
 
 
 class JuniperFormatter(CommonFormatter):
@@ -381,18 +466,24 @@ class RosFormatter(CommonFormatter):
     def patch_plain(self, patch):
         return list(self.cmd_paths(patch).keys())
 
-    def blocks_and_context(self, tree, is_patch, _level=0, _parent=None):
+    def blocks_and_context(
+        self,
+        tree: "PatchTree",
+        is_patch: bool,
+        context: Optional[FormatterContext] = None
+    ):
         rows = []
-        empty_context = {}
+
         if is_patch:
             items = ((item.row, item.child, item.context) for item in tree.itms)
         else:
-            items = ((row, child, empty_context) for row, child in tree.items())
-        for row, sub_config, context in items:
+            items = ((row, child, {}) for row, child in tree.items())
+
+        for row, sub_config, row_context in items:
             if sub_config or (is_patch and sub_config is not None):
-                rows.append((row, sub_config, context))
+                rows.append((row, sub_config, row_context))
             else:
-                rows.append((row, None, context))
+                rows.append((row, None, row_context))
 
         prev_prow = None
         for sub_config, row_group in itertools.groupby(rows, lambda x: x[1]):
@@ -400,20 +491,25 @@ class RosFormatter(CommonFormatter):
                 if prev_prow:
                     yield prev_prow
                     yield BlockBegin, None
-                for (row, _, context) in row_group:
-                    yield row, context
+                for row, _, row_context in row_group:
+                    yield row, row_context
                 if prev_prow:
                     yield BlockEnd, None
             else:
-                for (row, _, context) in row_group:
-                    if _parent:
-                        prev_prow = _parent
-                        prow = f"{_parent} {row}"
+                for row, _, row_context in row_group:
+                    if context and context.parent and context.parent.row:
+                        prev_prow = context.parent.row
+                        prow = f"{context.parent.row} {row}"
                     else:
                         prow = row
-                    yield prow, context
+                    yield prow, row_context
+
                     yield BlockBegin, None
-                    yield from self.blocks_and_context(sub_config, is_patch, _level + 1, prow)
+                    yield from self.blocks_and_context(
+                        sub_config,
+                        is_patch,
+                        context=FormatterContext(parent=context, current=(prow, row_context))
+                    )
                     yield BlockEnd, None
 
     def _formatted_blocks(self, blocks):

annet/cli_args.py

@@ -27,7 +27,7 @@ def convert_to_none(arg):
 
 
 def valid_config_source(value):
-    if value not in ["cfglister", "running", "empty", "-"] and not os.path.exists(value):
+    if value not in ["running", "empty", "-"] and not os.path.exists(value):
         raise ValueError("No such file or directory %r" % value)
     return value
 
@@ -174,14 +174,14 @@ opt_annotate = Arg(
 
 opt_config = Arg(
     "--config", default="running", type=valid_config_source,
-    help="'cfglister', 'running', 'empty', путь к файлу конфига, "
+    help="'running', 'empty', путь к файлу конфига, "
          "каталогу с файлами конфига в формате <hostname>.cfg "
          "или '-' (stdin)"
 )
 
 opt_clear = Arg(
     "--clear", default=False,
-    help="Используя acl вычищает команды относящиеся к данному генератору"
+    help="Используя acl вычищает команды относящиеся к данному генератору, "
          "аналогично использованию return в самом начале генератора"
 )
 

{annet-0.13.6.dist-info → annet-0.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: annet
-Version: 0.13.6
+Version: 0.14.1
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-0.13.6.dist-info → annet-0.14.1.dist-info}/RECORD

@@ -2,7 +2,7 @@ annet/__init__.py,sha256=oyElxAW97sHgQccGafhaWVBveBn1gSjjdP_xHROaRLg,2139
 annet/annet.py,sha256=TMdEuM7GJQ4TjRVmuK3bCTZN-21lxjQ9sXqEdILUuBk,725
 annet/argparse.py,sha256=MoBD0LPnHdA6HU7z1uQNArYlkD92znoeGIFTMnS4dRM,12608
 annet/cli.py,sha256=Nk956O3nOEVsOLyOqKDgjqJaB2uVlwYb9tPrWMbB4E4,9632
-annet/cli_args.py,sha256=Wv2X2wk6trTsGpKpcaZacGqVbDxMzEJvN8uYIJOq4D0,16071
+annet/cli_args.py,sha256=5sCD20ls18NDASPOHT5MbAFB10gyayGcFosKaJTLDps,16047
 annet/connectors.py,sha256=FLFJlhb73g2c8e61zYnGn8dTkIiaaWYqeUCsZd48AWg,2471
 annet/deploy.py,sha256=B8E0P_VvCrS2URjFvgmUiIkHp95g7pAWfmT34igaDeo,18893
 annet/diff.py,sha256=zLcaCnb4lZRUb7frpH1CstQ3kacRcCblZs1uLG8J5lk,3391
@@ -34,17 +34,17 @@ annet/adapters/netbox/common/storage_opts.py,sha256=rl_0pr3VzmOy6PDZIUMkKSBfJh90
 annet/adapters/netbox/v24/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/adapters/netbox/v24/storage.py,sha256=ogCu5XXIpcpPtuz7dWfDFIbqtz8k5G96PL6mhAQWwBU,6026
 annet/adapters/netbox/v37/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-annet/adapters/netbox/v37/storage.py,sha256=XIP11yp_ypi2lEQdtqNXGkzUYNxFCfDsmUM5pnoMFPU,7496
+annet/adapters/netbox/v37/storage.py,sha256=3Xv4BoStxy80iev4B9WMxUxl_U0LdKG6ZoTykMpliLw,7485
 annet/annlib/__init__.py,sha256=fT1l4xV5fqqg8HPw9HqmZVN2qwS8i6X1aIm2zGDjxKY,252
 annet/annlib/command.py,sha256=uuBddMQphtn8P5MO5kzIa8_QrtMns-k05VeKv1bcAuA,1043
 annet/annlib/diff.py,sha256=UPt3kYFQdQdVVy3ePYzNHPAxMVmHxCrCnZnMCV6ou2Q,4587
 annet/annlib/errors.py,sha256=jBcSFzY6Vj-FxR__vqjFm-87AwYQ0xHuAopTirii5AU,287
 annet/annlib/filter_acl.py,sha256=0w1VF6WcONiTYTQh0yWi6_j9rCTc_kMLAUMr0hbdkNU,7203
-annet/annlib/jsontools.py,sha256=UXZrO6RZ4LIcJkQ6xUcef6WuHMgpMTipolcIBZTEhuc,3461
+annet/annlib/jsontools.py,sha256=aGf1ZmkyuQ7FOB7-sP4KGE4smLd7pDZHBUGEF_XQTso,3651
 annet/annlib/lib.py,sha256=eJ4hcVuQ6pdYBzLs4YKCHFtq45idOfZCYp92XfF7_QI,15317
 annet/annlib/output.py,sha256=_SjJ6G6bejvnTKqNHw6xeio0FT9oO3OIkLaOC3cEga4,7569
-annet/annlib/patching.py,sha256=Gh8uUjFyYND9TJBBQH-DH6-AwFiiR-dXVXOisMS7elg,19784
-annet/annlib/tabparser.py,sha256=bhYbuGJIg6VP5CLiq09UZjgrenP9DegKvw_kYy-Hus0,22910
+annet/annlib/patching.py,sha256=GwG2lT4w-I1Ls3Eswn6SPJLBUVt2M3Ysw1fmXsWamYw,19793
+annet/annlib/tabparser.py,sha256=oV2sR_paW_tXUfHuAtL9OtV2V4PZICQuxH4VXOjhcqM,25793
 annet/annlib/types.py,sha256=VHU0CBADfYmO0xzB_c5f-mcuU3dUumuJczQnqGlib9M,852
 annet/annlib/netdev/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/annlib/netdev/db.py,sha256=fI_u5aya4l61mbYSjj4JwlVfi3s7obt2jqERSuXGRUI,1634
@@ -124,10 +124,10 @@ annet/rulebook/texts/routeros.rul,sha256=ipfxjj0mjFef6IsUlupqx4BY_Je_OUb8u_U1019
 annet_generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet_generators/example/__init__.py,sha256=zVd8_DrXuOASrNzg2Ab94rPyvJff83L-_HppDFxnUjM,228
 annet_generators/example/lldp.py,sha256=68CLrK7vxTQQy9XIBxtywuEdBNlIlfXGYj8_wYWs5UI,1146
-annet-0.13.6.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
-annet-0.13.6.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
-annet-0.13.6.dist-info/METADATA,sha256=o_MGhpo38KbBhndlGER9EnhCvJdLWy1uZbsDNr78ODU,694
-annet-0.13.6.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-annet-0.13.6.dist-info/entry_points.txt,sha256=yHimujIzR2bwNIbb--MTs_GpXiAve89Egpu2LlgTEkg,119
-annet-0.13.6.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
-annet-0.13.6.dist-info/RECORD,,
+annet-0.14.1.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
+annet-0.14.1.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
+annet-0.14.1.dist-info/METADATA,sha256=Ytr-6UkYSrc_wLkYHOza5V7iSPFGHtdteNJ6IoQzdzw,694
+annet-0.14.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
+annet-0.14.1.dist-info/entry_points.txt,sha256=yHimujIzR2bwNIbb--MTs_GpXiAve89Egpu2LlgTEkg,119
+annet-0.14.1.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
+annet-0.14.1.dist-info/RECORD,,

{annet-0.13.6.dist-info → annet-0.14.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.1)
+Generator: setuptools (70.2.0)
 Root-Is-Purelib: true
 Tag: py3-none-any