annet 1.0.3__tar.gz → 1.1.0__tar.gz

{annet-1.0.3/annet.egg-info → annet-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 1.0.3
+Version: 1.1.0
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT
@@ -15,7 +15,6 @@ Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: Pygments>=2.14.0
 Requires-Dist: Mako>=1.2.4
 Requires-Dist: Jinja2>=3.1.2
-Requires-Dist: psutil>=5.8.0
 Requires-Dist: packaging>=23.2
 Requires-Dist: contextlog>=1.1
 Requires-Dist: valkit>=0.1.4

{annet-1.0.3 → annet-1.1.0}/README.md

@@ -68,3 +68,8 @@ sphinx-build -M html docs docs-build
 ```
 
 3. Open rendered html in browser docs-build/html/index.html
+
+## Links
+
+* [Online Documentation](https://annetutil.github.io/annet/)
+* [Tutorial](https://annetutil.github.io/annet/main/usage/tutorial.html)

{annet-1.0.3 → annet-1.1.0}/annet/annlib/netdev/devdb/data/devdb.json

@@ -132,6 +132,9 @@
     "PC.Whitebox.Ufispace.S": " S",
     "PC.Whitebox.Ufispace.S.S9100": " S91\\d\\d",
     "PC.Whitebox.Ufispace.S.S9100.S9110_32X": " S9110-32X",
+    "PC.Whitebox.Ufispace.S.S9300": " S93\\d\\d",
+    "PC.Whitebox.Ufispace.S.S9300.S9301_32DB": " S9301-32DB",
+    "PC.Whitebox.Ufispace.S.S9300.S9321_64EO": " S9321-64EO",
     "PC.Nebius": "^Nebius",
     "PC.Nebius.NB-E-BR-DCU-AST2600": "^Nebius NB-E-BR-DCU-AST2600",
 

{annet-1.0.3 → annet-1.1.0}/annet/annlib/patching.py

@@ -186,6 +186,9 @@ class Orderer:
         block_exit = platform.VENDOR_EXIT[self.vendor]
 
         for (order, (raw_rule, rule)) in enumerate(ordering.items()):
+            if rule["attrs"]["global"]:
+                children.append((raw_rule, rule))
+
             direct_matched = bool(rule["attrs"]["direct_regexp"].match(row))
             if not rule["attrs"]["order_reverse"] and (direct_matched or rule["attrs"]["reverse_regexp"].match(row)):
                 # если не указано order_reverse - правило считается прямым
@@ -395,7 +398,7 @@ def make_patch(pre, rb, hw, add_comments, orderer=None, _root_pre=None, do_commi
         for (key, diff) in content["items"].items():
             # чтобы logic не мог поменять атрибуты
             rule_pre = content.copy()
-            attrs = rule_pre["attrs"].copy()
+            attrs = copy.deepcopy(rule_pre["attrs"])
 
             iterable = attrs["logic"](
                 rule=attrs,
@@ -544,8 +547,7 @@ def _select_match(matches, rules):
         for (rule, is_cr_allowed) in map(operator.itemgetter(0), matches):
             if is_cr_allowed:
                 local_children = merge_dicts(local_children, rule["children"]["local"])
-            # optional break on is_cr_allowed==False?
-
+                # optional break on is_cr_allowed==False?
                 global_children = merge_dicts(global_children, rule["children"]["global"])
 
     global_children = merge_dicts(global_children, rules["global"])
@@ -555,9 +557,10 @@ def _select_match(matches, rules):
         "global": global_children,
     }
 
-    match = {"attrs": f_rule["attrs"]}
+    match = {"attrs": copy.deepcopy(f_rule["attrs"])}
     match.update(f_other)
-    return (match, children_rules)
+
+    return match, children_rules
 
 
 def _rules_local_global(rules):

{annet-1.0.3 → annet-1.1.0}/annet/annlib/rbparser/ordering.py

@@ -16,6 +16,10 @@ def compile_ordering_text(text, vendor):
                 "validator": valid_bool,
                 "default":   False,
             },
+            "global": {
+                "validator": valid_bool,
+                "default": False,
+            }
         }),
         reverse_prefix=platform.VENDOR_REVERSES[vendor],
     )
@@ -44,6 +48,7 @@ def _compile_ordering(tree, reverse_prefix):
                         syntax.compile_row_regexp(re.sub(r"^%s\s+" % (reverse_prefix), "", attrs["row"]))
                     ),
                     "order_reverse": attrs["params"]["order_reverse"],
+                    "global": attrs["params"]["global"],
                     "raw_rule": attrs["raw_rule"],
                     "context": attrs["context"],
                 },

{annet-1.0.3 → annet-1.1.0}/annet/annlib/rbparser/platform.py

@@ -25,7 +25,7 @@ VENDOR_DIFF = {
     "routeros": "common.default_diff",
     "aruba": "aruba.default_diff",
     "pc": "common.default_diff",
-    "ribbon": "ribbon.default_diff",
+    "ribbon": "common.default_diff",
     "b4com": "common.default_diff",
 }
 
@@ -40,7 +40,7 @@ VENDOR_DIFF_ORDERED = {
     "routeros": "common.ordered_diff",
     "aruba": "common.ordered_diff",
     "pc": "common.ordered_diff",
-    "ribbon": "ribbon.default_diff",
+    "ribbon": "common.ordered_diff",
     "b4com": "common.ordered_diff",
 }
 

{annet-1.0.3 → annet-1.1.0}/annet/annlib/tabparser.py

@@ -1,6 +1,8 @@
 import dataclasses
 import itertools
+import json
 import re
+import textwrap
 from collections import OrderedDict as odict
 from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Tuple, Union, List
 
@@ -70,10 +72,10 @@ class CommonFormatter:
         self._block_end = ""
         self._statement_end = ""
 
-    def split(self, text):
+    def split(self, text: str):
         return list(filter(None, text.split("\n")))
 
-    def join(self, config):
+    def join(self, config: "PatchTree"):
         return "\n".join(
             _filtered_block_marks(
                 self._indent_blocks(self._blocks(config, is_patch=False))
@@ -86,14 +88,14 @@ class CommonFormatter:
     def diff(self, diff):
         return list(self.diff_generator(diff))
 
-    def patch(self, patch):
+    def patch(self, patch: "PatchTree") -> str:
         return "\n".join(
             _filtered_block_marks(
                 self._indent_blocks(self._blocks(patch, is_patch=True))
             )
         )
 
-    def cmd_paths(self, patch):
+    def cmd_paths(self, patch: "PatchTree") -> odict:
         ret = odict()
         path = []
         for row, context in self.blocks_and_context(patch, is_patch=True):
@@ -175,7 +177,7 @@ class CommonFormatter:
                 )
                 yield BlockEnd, None
 
-    def _blocks(self, tree, is_patch):
+    def _blocks(self, tree: "PatchTree", is_patch: bool):
         for row, _context in self.blocks_and_context(tree, is_patch):
             yield row
 
@@ -386,7 +388,32 @@ class AsrFormatter(BlockExitFormatter):
 
 
 class JuniperFormatter(CommonFormatter):
-    patch_set_prefix = "set "
+    patch_set_prefix = "set"
+
+    @dataclasses.dataclass
+    class Comment:
+        begin = "/*"
+        end = "*/"
+
+        row: str
+        comment: str
+
+        def __post_init__(self):
+            self.row = self.row.strip()
+            self.comment = self.comment.strip()
+
+        @classmethod
+        def loads(cls, value: str):
+            return cls(
+                **json.loads(
+                    value.removeprefix(cls.begin)
+                    .removesuffix(cls.end)
+                    .strip()
+                )
+            )
+
+        def dumps(self):
+            return json.dumps({"row": self.row, "comment": self.comment})
 
     def __init__(self, indent="    "):
         super().__init__(indent)
@@ -395,20 +422,32 @@ class JuniperFormatter(CommonFormatter):
         self._statement_end = ";"
         self._endofline_comment = "; ##"
 
-    def split(self, text):
-        sub_regexs = (
+        self._sub_regexs = (
             (re.compile(self._block_begin + r"\s*" + self._block_end + r"$"), ""),  # collapse empty blocks
             (re.compile(self._block_begin + "(\t# .+)?$"), ""),
             (re.compile(self._statement_end + r"$"), ""),
             (re.compile(r"\s*" + self._block_end + "(\t# .+)?$"), ""),
             (re.compile(self._endofline_comment + r".*$"), ""),
         )
-        split = []
-        for line in text.split("\n"):
-            for (regex, repl_line) in sub_regexs:
-                line = regex.sub(repl_line, line)
-            split.append(line)
-        return list(filter(None, split))
+
+    def sub_regexs(self, value: str) -> str:
+        for (regex, repl_line) in self._sub_regexs:
+            value = regex.sub(repl_line, value)
+        return value
+
+    def split(self, text: str) -> list[str]:
+        comment_begin, comment_end = map(re.escape, (self.Comment.begin, self.Comment.end))
+        comment_regexp = re.compile(fr"(\s+{comment_begin})((?:(?!{comment_end}).)*)({comment_end})")
+
+        result = []
+        lines = text.split("\n")
+        for i, line in enumerate(lines):
+            line = self.sub_regexs(line)
+            if i + 1 < len(lines) and (m := comment_regexp.match(line)):
+                line = f"{m.group(1)} {self.Comment(self.sub_regexs(lines[i + 1]), m.group(2)).dumps()} {m.group(3)}"
+            result.append(line)
+
+        return list(filter(None, result))
 
     def join(self, config):
         return "\n".join(_filtered_block_marks(self._formatted_blocks(self._indented_blocks(config))))
@@ -433,30 +472,45 @@ class JuniperFormatter(CommonFormatter):
                     yield line + self._statement_end
                 yield self._indent * level + self._block_end
             elif isinstance(line, str):
-                yield line + self._statement_end
+                yield line + ("" if line.endswith(self.Comment.end) else self._statement_end)
             line = new_line
         if isinstance(line, str):
             yield line + self._statement_end
 
-    def cmd_paths(self, patch, _prev=""):
+    def cmd_paths(self, patch, _prev=tuple()):
         commands = odict()
         for item in patch.itms:
             key, childs, context = item.row, item.child, item.context
+
             if childs:
-                for k, v in self.cmd_paths(childs, _prev + " " + key).items():
+                for k, v in self.cmd_paths(childs, (*_prev, key.strip())).items():
                     commands[k] = v
             else:
-                if key.startswith("delete"):
-                    cmd = "delete" + _prev + " " + key.replace("delete", "", 1).strip()
+                if "comment" in context:
+                    value = (
+                        ""
+                        if key.startswith("delete")
+                        else context["comment"]
+                    )
+
+                    cmd = "\n".join(
+                        (
+                            "edit " + " ".join(_prev),
+                            " ".join(("annotate", context["row"].split(" ")[0], f'"{value}"')),
+                            "exit"
+                        )
+                    )
+                elif key.startswith("delete"):
+                    cmd = " ".join(("delete", *_prev, key.replace("delete", "", 1).strip()))
                 elif key.startswith("activate"):
-                    cmd = "activate" + _prev + " " + key.replace("activate", "", 1).strip()
+                    cmd = " ".join(("activate", *_prev, key.replace("activate", "", 1).strip()))
                 elif key.startswith("deactivate"):
-                    cmd = "deactivate" + _prev + " " + key.replace("deactivate", "", 1).strip()
+                    cmd = " ".join(("deactivate", *_prev, key.replace("deactivate", "", 1).strip()))
                 else:
-                    cmd = (self.patch_set_prefix + _prev.strip()).strip() + " " + key
+                    cmd = " ".join((self.patch_set_prefix, *_prev, key.strip()))
+
                 # Expanding [ a b c ] junipers list of arguments
-                matches = re.search(r"^(.*)\s+\[(.+)\]$", cmd)
-                if matches:
+                if matches := re.search(r"^(.*)\s+\[(.+)\]$", cmd):
                     for c in matches.group(2).split(" "):
                         if c.strip():
                             cmd = " ".join([matches.group(1), c])
@@ -490,7 +544,7 @@ class JuniperList:
 
 
 class NokiaFormatter(JuniperFormatter):
-    patch_set_prefix = "/configure "
+    patch_set_prefix = "/configure"
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -517,18 +571,18 @@ class NokiaFormatter(JuniperFormatter):
         finish = finish if finish is not None else len(ret)
         return ret[start:finish]
 
-    def cmd_paths(self, patch, _prev=""):
+    def cmd_paths(self, patch, _prev=tuple()):
         commands = odict()
         for item in patch.itms:
             key, childs, context = item.row, item.child, item.context
             if childs:
-                for k, v in self.cmd_paths(childs, _prev + " " + key).items():
+                for k, v in self.cmd_paths(childs, (*_prev, key.strip())).items():
                     commands[k] = v
             else:
                 if key.startswith("delete"):
-                    cmd = "/configure delete" + _prev + " " + key.replace("delete", "", 1).strip()
+                    cmd = " ".join((self.patch_set_prefix, "delete", *_prev, key.replace("delete", "", 1).strip()))
                 else:
-                    cmd = self.patch_set_prefix + _prev.strip() + " " + key
+                    cmd = " ".join((self.patch_set_prefix, *_prev, key.strip()))
                 # Expanding [ a b c ] junipers list of arguments
                 matches = re.search(r"^(.*)\s+\[(.+)\]$", cmd)
                 if matches:

{annet-1.0.3 → annet-1.1.0}/annet/bgp_models.py

@@ -3,6 +3,77 @@ from dataclasses import dataclass, field
 from typing import Literal, Union, Optional
 
 
+class VidRange:
+    def __init__(self, start: int, stop: int) -> None:
+        self.start = start
+        self.stop = stop
+
+    def is_single(self):
+        return self.start == self.stop
+
+    def __iter__(self):
+        return iter(range(self.start, self.stop + 1))
+
+    def __str__(self):
+        if self.is_single():
+            return str(self.start)
+        return f"{self.start}-{self.stop}"
+
+    def __repr__(self):
+        return f"VlanRange({self.start}, {self.stop})"
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is VidRange:
+            return self.start == other.start and self.stop == other.stop
+        return NotImplemented
+
+
+def _parse_vlan_ranges(ranges: str) -> Iterable[VidRange]:
+    for range in ranges.split(","):
+        start, sep, stop = range.strip().partition("-")
+        try:
+            if not sep:
+                int_start = int(start)
+                yield VidRange(int_start, int_start)
+            elif not stop or not start:
+                raise ValueError(f"Cannot parse range {range!r}. Expected `start-stop`")
+            else:
+                yield VidRange(int(start), int(stop))
+        except ValueError:
+            raise ValueError(f"Cannot parse range {range!r}. Expected `vid1-vid2` or `vid`")
+
+
+class VidCollection:
+    @staticmethod
+    def parse(ranges: int | str) -> "VidCollection":
+        if isinstance(ranges, int):
+            return VidCollection([VidRange(ranges, ranges)])
+        elif isinstance(ranges, str):
+            return VidCollection(list(_parse_vlan_ranges(ranges)))
+        elif isinstance(ranges, VidCollection):
+            return VidCollection(ranges.ranges)
+        else:
+            raise TypeError(f"Expected str or int, got {type(ranges)}")
+
+    def __init__(self, ranges: list[VidRange]) -> None:
+        self.ranges = ranges
+
+    def __str__(self):
+        return ",".join(map(str, self.ranges))
+
+    def __repr__(self):
+        return f"VlanCollection({str(self)!r})"
+
+    def __iter__(self):
+        for range in self.ranges:
+            yield from range
+
+    def __eq__(self, other: object) -> bool:
+        if type(other) is VidCollection:
+            return self.ranges == other.ranges
+        return False
+
+
 class ASN(int):
     """
     Stores ASN number and formats it as в AS1.AS2
@@ -235,6 +306,17 @@ class PeerGroup:
     mtu: int = 0
 
 
+@dataclass
+class L2VpnOptions:
+    name: str
+    vid: VidCollection
+    l2vni: int  # VNI, possible values are 1 to 2**24-1
+    route_distinguisher: str = ""  # like in VrfOptions
+    rt_import: list[str] = field(default_factory=list)  # like in VrfOptions
+    rt_export: list[str] = field(default_factory=list)  # like in VrfOptions
+    advertise_host_routes: bool = True  # advertise IP+MAC routes into L3VNI
+
+
 @dataclass
 class VrfOptions:
     vrf_name: str
@@ -274,8 +356,8 @@ class GlobalOptions:
     multipath: int = 0
     router_id: str = ""
     vrf: dict[str, VrfOptions] = field(default_factory=dict)
-
     groups: list[PeerGroup] = field(default_factory=list)
+    l2vpn: dict[str, L2VpnOptions] = field(default_factory=dict)
 
 
 @dataclass

annet-1.1.0/annet/executor.py

@@ -0,0 +1,194 @@
+import asyncio
+import os
+import statistics
+from abc import ABC, abstractmethod
+from functools import partial
+from operator import itemgetter
+from typing import Any, Dict, List, Optional, Union
+
+import colorama
+from annet.annlib.command import Command, CommandList, Question  # noqa: F401
+
+
+class CommandResult(ABC):
+    @abstractmethod
+    def get_out(self) -> str:
+        pass
+
+
+class Connector(ABC):
+    @abstractmethod
+    async def cmd(self, cmd: Union[Command, str]) -> CommandResult:
+        pass
+
+    @abstractmethod
+    async def download(self, files: List[str]) -> Dict[str, str]:
+        pass
+
+    @abstractmethod
+    async def upload(self, files: Dict[str, str]):
+        pass
+
+    @abstractmethod
+    def get_conn_trace(self) -> str:
+        pass
+
+    @abstractmethod
+    async def aclose(self) -> str:
+        pass
+
+
+class ExecutorException(Exception):
+    def __init__(self, *args: List[Any], auxiliary: Optional[Any] = None, **kwargs: object):
+        self.auxiliary = auxiliary
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self) -> str:
+        return "%s(args=%r,auxiliary=%s)" % (self.__class__.__name__, self.args, self.auxiliary)
+
+
+class ExecException(ExecutorException):
+    def __init__(self, msg: str, cmd: str, res: str, **kwargs):
+        super().__init__(**kwargs)
+        self.args = msg, cmd, res
+        self.kwargs = kwargs
+        self.msg = msg
+        self.cmd = cmd
+        self.res = res
+
+    def __str__(self) -> str:
+        return str(self.msg)
+
+    def __repr__(self) -> str:
+        return "%s<%s, %s>" % (self.__class__.__name__, self.msg, self.cmd)
+
+
+class BadCommand(ExecException):
+    pass
+
+
+class NonzeroRetcode(ExecException):
+    pass
+
+
+class CommitException(ExecException):
+    pass
+
+
+def _show_type_summary(caption, items, total, stat_items=None):
+    if items:
+        if not stat_items:
+            stat = ""
+        else:
+            avg = statistics.mean(stat_items)
+            stat = "   %(min).1f/%(max).1f/%(avg).1f/%(stdev)s  (min/max/avg/stdev)" % dict(
+                min=min(stat_items),
+                max=max(stat_items),
+                avg=avg,
+                stdev="-" if len(stat_items) < 2 else "%.1f" % statistics.stdev(stat_items, xbar=avg)
+            )
+
+        print("%-8s %d of %d%s" % (caption, len(items), total, stat))
+
+
+def show_bulk_report(hostnames, res, durations, log_dir):
+    total = len(hostnames)
+    if not total:
+        return
+
+    colorama.init()
+
+    print("\n====== bulk deploy report ======")
+
+    done = [host for (host, hres) in res.items() if not isinstance(hres, Exception)]
+    cancelled = [host for (host, hres) in res.items() if isinstance(hres, asyncio.CancelledError)]
+    failed = [host for (host, hres) in res.items() if isinstance(hres, Exception) and host not in cancelled]
+    lost = [host for host in hostnames if host not in res]
+    limit = 30
+
+    _show_type_summary("Done :", done, total, [durations[h] for h in done])
+    _print_limit(done, partial(_print_hostname, style=colorama.Fore.GREEN), limit, total)
+
+    _show_type_summary("Failed :", failed, total, [durations[h] for h in failed])
+
+    _print_limit(failed, partial(_print_failed, res=res), limit, total)
+
+    _show_type_summary("Cancelled :", cancelled, total, [durations[h] for h in cancelled if durations[h] is not None])
+    _print_limit(cancelled, partial(_print_hostname, style=colorama.Fore.RED), limit, total)
+
+    _show_type_summary("Lost :", lost, total)
+    _print_limit(lost, _print_hostname, limit, total)
+
+    err_limit = 5
+    if failed:
+        errs = {}
+        for hostname in failed:
+            fmt_err = _format_exc(res[hostname])
+            if fmt_err in errs:
+                errs[fmt_err] += 1
+            else:
+                errs[fmt_err] = 1
+        print("Top errors :")
+        for fmt_err, n in sorted(errs.items(), key=itemgetter(1), reverse=True)[:err_limit]:
+            print("  %-4d %s" % (n, fmt_err))
+        print("\n", end="")
+
+    if log_dir:
+        print("See deploy logs in %s/\n" % os.path.relpath(log_dir))
+
+
+def _format_exc(exc):
+    if isinstance(exc, ExecException):
+        cmd = str(exc.cmd)
+        if len(cmd) > 50:
+            cmd = cmd[:50] + "~.."
+        return "'%s', cmd '%s'" % (exc.msg, cmd)
+    elif isinstance(exc, ExecutorException):
+        return "%s%r" % (exc.__class__.__name__, exc.args)  # исключить многословный auxiliary
+    else:
+        return repr(exc)
+
+
+def _print_hostname(host, style=None):
+    if style:
+        host = style + host + colorama.Style.RESET_ALL
+    print("  %s" % host)
+
+
+def _print_limit(items, printer, limit, total, end="\n"):
+    if not items:
+        return
+    if len(items) > limit and len(items) > total * 0.7:
+        print("  ... %d hosts" % len(items))
+    for host in items[:limit]:
+        printer(host)
+    if len(items) > limit:
+        print("  ... %d more hosts" % (len(items) - limit))
+
+    print(end, end="")
+
+
+def _print_failed(host, res):
+    exc = res[host]
+    color = colorama.Fore.YELLOW if isinstance(exc, Warning) else colorama.Fore.RED
+    print("  %s - %s" % (color + host + colorama.Style.RESET_ALL, _format_exc(exc)))
+
+
+class DeferredFileWrite:
+    def __init__(self, file, mode="r"):
+        self._file = file
+        wrapper = {"w": "a", "wb": "ab"}
+        if mode in wrapper:
+            self._mode = wrapper[mode]
+        else:
+            raise Exception()
+
+    def write(self, data):
+        with open(self._file, self._mode) as fh:
+            fh.write(data)
+
+    def close(self):
+        pass
+
+    def flush(self):
+        pass

{annet-1.0.3 → annet-1.1.0}/annet/mesh/device_models.py

@@ -76,10 +76,21 @@ class VrfOptions(_FamiliesMixin, BaseMeshModel):
     groups: Annotated[dict[str, MeshPeerGroup], DictMerge(Merge())]
 
 
+class L2VpnOptions(BaseMeshModel):
+    name: str
+    vid: str | int  # VLAN ID, possible values are 1 to 4094, ranges can be set as strings
+    l2vni: int  # VNI, possible values are 1 to 2**24-1
+    route_distinguisher: str  # like in VrfOptions
+    rt_import: Annotated[tuple[str, ...], Concat()]  # like in VrfOptions
+    rt_export: Annotated[tuple[str, ...], Concat()]  # like in VrfOptions
+    advertise_host_routes: bool  # advertise IP+MAC routes into L3VNI
+
+
 class GlobalOptionsDTO(_FamiliesMixin, BaseMeshModel):
     def __init__(self, **kwargs):
         kwargs.setdefault("groups", KeyDefaultDict(lambda x: MeshPeerGroup(name=x)))
         kwargs.setdefault("vrf", KeyDefaultDict(lambda x: VrfOptions(vrf_name=x)))
+        kwargs.setdefault("l2vpn", KeyDefaultDict(lambda x: L2VpnOptions(name=x)))
         super().__init__(**kwargs)
 
     as_path_relax: bool
@@ -89,3 +100,4 @@ class GlobalOptionsDTO(_FamiliesMixin, BaseMeshModel):
     router_id: str
     vrf: Annotated[dict[str, VrfOptions], DictMerge(Merge())]
     groups: Annotated[dict[str, MeshPeerGroup], DictMerge(Merge())]
+    l2vpn: Annotated[dict[str, L2VpnOptions], DictMerge(Merge())]

{annet-1.0.3 → annet-1.1.0}/annet/mesh/models_converter.py

@@ -7,7 +7,7 @@ from adaptix import Retort, loader, Chain, name_mapping, as_is_loader
 from .peer_models import DirectPeerDTO, IndirectPeerDTO, VirtualPeerDTO, VirtualLocalDTO
 from ..bgp_models import (
     Aggregate, GlobalOptions, VrfOptions, FamilyOptions, Peer, PeerGroup, ASN, PeerOptions,
-    Redistribute, BFDTimers,
+    Redistribute, BFDTimers, L2VpnOptions, VidCollection,
 )
 
 
@@ -49,8 +49,10 @@ retort = Retort(
     recipe=[
         loader(InterfaceChanges, ObjMapping, Chain.FIRST),
         loader(ASN, ASN),
+        loader(VidCollection, VidCollection.parse),
         loader(GlobalOptions, ObjMapping, Chain.FIRST),
         loader(VrfOptions, ObjMapping, Chain.FIRST),
+        loader(L2VpnOptions, ObjMapping, Chain.FIRST),
         loader(FamilyOptions, ObjMapping, Chain.FIRST),
         loader(Aggregate, ObjMapping, Chain.FIRST),
         loader(PeerOptions, ObjMapping, Chain.FIRST),