annet 0.13.6__tar.gz → 0.14.0__tar.gz

{annet-0.13.6/annet.egg-info → annet-0.14.0}/PKG-INFO

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

{annet-0.13.6 → annet-0.14.0}/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-0.13.6 → annet-0.14.0}/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-0.13.6 → annet-0.14.0}/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 → annet-0.14.0/annet.egg-info}/PKG-INFO

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