annet 1.1.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

annet/annet.py

@@ -2,7 +2,7 @@
 import sys
 
 import annet
-from annet import argparse, cli, generators, hardware, lib, rulebook
+from annet import argparse, cli, generators, hardware, lib, rulebook, diff
 
 
 # =====
@@ -13,6 +13,7 @@ def main():
     cli.fill_base_args(parser, annet.__name__, "configs/logging.yaml")
     rulebook.rulebook_provider_connector.set(rulebook.DefaultRulebookProvider)
     hardware.hardware_connector.set(hardware.AnnetHardwareProvider)
+    diff.file_differ_connector.set(diff.UnifiedFileDiffer)
 
     parser.add_commands(parser.find_subcommands(cli.list_subcommands()))
     try:

annet/api/__init__.py

@@ -1,5 +1,4 @@
 import abc
-import difflib
 import os
 import re
 import sys
@@ -37,6 +36,7 @@ from annet import diff as ann_diff
 from annet import filtering
 from annet import gen as ann_gen
 from annet import patching, rulebook, tabparser, tracing
+from annet.diff import file_differ_connector
 from annet.rulebook import deploying
 from annet.filtering import Filterer
 from annet.hardware import hardware_connector
@@ -52,8 +52,6 @@ from annet.storage import Device, get_storage
 from annet.types import Diff, ExitCode, OldNewResult, Op, PCDiff, PCDiffFile
 
 
-live_configs = ann_gen.live_configs
-
 DEFAULT_INDENT = "  "
 
 
@@ -242,29 +240,22 @@ def gen(args: cli_args.ShowGenOptions, loader: ann_gen.Loader):
 
 
 # =====
-def _diff_file(old_text: Optional[str], new_text: Optional[str], context=3):
-    old_lines = old_text.splitlines() if old_text else []
-    new_lines = new_text.splitlines() if new_text else []
-    context = max(len(old_lines), len(new_lines)) if context is None else context
-    return list(difflib.unified_diff(old_lines, new_lines, n=context, lineterm=""))
-
-
-def _diff_files(old_files, new_files, context=3):
+def _diff_files(hw, old_files, new_files):
     ret = {}
+    differ = file_differ_connector.get()
     for (path, (new_text, reload_data)) in new_files.items():
         old_text = old_files.get(path)
         is_new = old_text is None
-        diff_lines = _diff_file(old_text, new_text, context=context)
+        diff_lines = differ.diff_file(hw, path, old_text, new_text)
         ret[path] = (diff_lines, reload_data, is_new)
     return ret
 
 
 def patch(args: cli_args.ShowPatchOptions, loader: ann_gen.Loader):
     """ Сгенерировать патч для устройств """
-    global live_configs  # pylint: disable=global-statement
     if args.config == "running":
         fetcher = annet.deploy.get_fetcher()
-        live_configs = annet.lib.do_async(fetcher.fetch(loader.devices, processes=args.parallel))
+        ann_gen.live_configs = annet.lib.do_async(fetcher.fetch(loader.devices, processes=args.parallel))
     stdin = args.stdin(filter_acl=args.filter_acl, config=args.config)
 
     filterer = filtering.filterer_connector.get()
@@ -355,9 +346,9 @@ def diff(
 
         pc_diff_files = []
         if res.old_files or new_files:
-            pc_diff_files.extend(_pc_diff(device.hostname, res.old_files, new_files))
+            pc_diff_files.extend(_pc_diff(res.device.hw, device.hostname, res.old_files, new_files))
         if res.old_json_fragment_files or new_json_fragment_files:
-            pc_diff_files.extend(_json_fragment_diff(device.hostname, res.old_json_fragment_files, new_json_fragment_files))
+            pc_diff_files.extend(_json_fragment_diff(res.device.hw, device.hostname, res.old_json_fragment_files, new_json_fragment_files))
 
         if pc_diff_files:
             pc_diff_files.sort(key=lambda f: f.label)
@@ -478,18 +469,19 @@ class PCDeployerJob(DeployerJob):
         upload_files: Dict[str, bytes] = {}
         reload_cmds: Dict[str, bytes] = {}
         generator_types: Dict[str, GeneratorType] = {}
+        differ = file_differ_connector.get()
         for generator_type, pc_files in [(GeneratorType.ENTIRE, new_files), (GeneratorType.JSON_FRAGMENT, new_json_fragment_files)]:
             for file, (file_content_or_json_cfg, cmds) in pc_files.items():
                 if generator_type == GeneratorType.ENTIRE:
                     file_content: str = file_content_or_json_cfg
-                    diff_content = "\n".join(_diff_file(old_files.get(file), file_content))
+                    diff_content = "\n".join(differ.diff_file(res.device.hw, file, old_files.get(file), file_content))
                 else:  # generator_type == GeneratorType.JSON_FRAGMENT
                     old_json_cfg = old_json_fragment_files[file]
                     json_patch = jsontools.make_patch(old_json_cfg, file_content_or_json_cfg)
                     file_content = jsontools.format_json(json_patch)
                     old_text = jsontools.format_json(old_json_cfg)
                     new_text = jsontools.format_json(file_content_or_json_cfg)
-                    diff_content = "\n".join(_diff_file(old_text, new_text))
+                    diff_content = "\n".join(differ.diff_file(res.device.hw, file, old_text, new_text))
 
                 if diff_content or force_reload:
                     self._has_diff |= True
@@ -624,7 +616,6 @@ class Deployer:
         return ans
 
     def check_diff(self, result: annet.deploy.DeployResult, loader: ann_gen.Loader):
-        global live_configs  # pylint: disable=global-statement
         success_device_ids = []
         for host, hres in result.results.items():
             device = self.fqdn_to_device[host]
@@ -639,7 +630,7 @@ class Deployer:
             config="running",
         )
         if diff_args.query:
-            live_configs = None
+            ann_gen.live_configs = None
             diffs = diff(diff_args, loader, success_device_ids, self._filterer)
             non_pc_diffs = {dev: diff for dev, diff in diffs.items() if not isinstance(diff, PCDiff)}
             devices_to_diff = ann_diff.collapse_diffs(non_pc_diffs)
@@ -682,13 +673,23 @@ async def adeploy(
 ) -> ExitCode:
     """ Сгенерировать конфиг для устройств и задеплоить его """
     ret: ExitCode = 0
-    global live_configs  # pylint: disable=global-statement
-    live_configs = await fetcher.fetch(devices=loader.devices, processes=args.parallel)
-    pool = ann_gen.OldNewParallel(args, loader, filterer)
+    ann_gen.live_configs = await fetcher.fetch(devices=loader.devices, processes=args.parallel)
 
-    for res in pool.generated_configs(loader.devices):
+    device_ids = [d.id for d in loader.devices]
+    for res in ann_gen.old_new(
+        args,
+        config=args.config,
+        loader=loader,
+        no_new=args.clear,
+        stdin=args.stdin(filter_acl=args.filter_acl, config=args.config),
+        do_files_download=True,
+        device_ids=device_ids,
+        filterer=filterer,
+    ):
         # Меняем exit code если хоть один device ловил exception
         if res.err is not None:
+            if not args.tolerate_fails:
+                raise res.err
             get_logger(res.device.hostname).error("error generating configs", exc_info=res.err)
             ret |= 2 ** 3
         job = DeployerJob.from_device(res.device, args)
@@ -746,12 +747,16 @@ def file_diff(args: cli_args.FileDiffOptions):
 def file_diff_worker(old_new: Tuple[str, str], args: cli_args.FileDiffOptions) -> Generator[
     Tuple[str, str, bool], None, None]:
     old_path, new_path = old_new
+    hw = args.hw
+    if isinstance(args.hw, str):
+        hw = HardwareView(args.hw, "")
+
     if os.path.isdir(old_path) and os.path.isdir(new_path):
         hostname = os.path.basename(new_path)
         new_files = {relative_cfg_path: (cfg_text, "") for relative_cfg_path, cfg_text in
                      ann_gen.load_pc_config(new_path).items()}
         old_files = ann_gen.load_pc_config(old_path)
-        for diff_file in _pc_diff(hostname, old_files, new_files):
+        for diff_file in _pc_diff(hw, hostname, old_files, new_files):
             diff_text = (
                 "\n".join(diff_file.diff_lines)
                 if args.no_color
@@ -791,8 +796,8 @@ def file_patch_worker(old_new: Tuple[str, str], args: cli_args.FileDiffOptions)
             yield dest_name, patch_text, False
 
 
-def _pc_diff(hostname: str, old_files: Dict[str, str], new_files: Dict[str, str]) -> Generator[PCDiffFile, None, None]:
-    sorted_lines = sorted(_diff_files(old_files, new_files).items())
+def _pc_diff(hw, hostname: str, old_files: Dict[str, str], new_files: Dict[str, str]) -> Generator[PCDiffFile, None, None]:
+    sorted_lines = sorted(_diff_files(hw, old_files, new_files).items())
     for (path, (diff_lines, _reload_data, is_new)) in sorted_lines:
         if not diff_lines:
             continue
@@ -803,6 +808,7 @@ def _pc_diff(hostname: str, old_files: Dict[str, str], new_files: Dict[str, str]
 
 
 def _json_fragment_diff(
+        hw,
         hostname: str,
         old_files: Dict[str, Any],
         new_files: Dict[str, Tuple[Any, Optional[str]]],
@@ -820,7 +826,7 @@ def _json_fragment_diff(
             ret[path] = (jsontools.format_json(cfg), reload_cmd)
         return ret
     jold, jnew = jsonify_multi(old_files), jsonify_multi_with_cmd(new_files)
-    return _pc_diff(hostname, jold, jnew)
+    return _pc_diff(hw, hostname, jold, jnew)
 
 
 def guess_hw(config_text: str):

annet/diff.py

@@ -1,6 +1,9 @@
+import abc
+import difflib
 import re
 from itertools import groupby
-from typing import Generator, List, Mapping, Tuple, Union
+from pathlib import Path
+from typing import Generator, List, Mapping, Tuple, Union, Protocol
 
 from annet.annlib.diff import (  # pylint: disable=unused-import
     colorize_line,
@@ -9,10 +12,12 @@ from annet.annlib.diff import (  # pylint: disable=unused-import
     gen_pre_as_diff,
     resort_diff,
 )
+from annet.annlib.netdev.views.hardware import HardwareView
 from annet.annlib.output import format_file_diff
 
-from annet import patching
+from annet import patching, rulebook, tabparser, hardware
 from annet.cli_args import ShowDiffOptions
+from annet.connectors import CachedConnector
 from annet.output import output_driver_connector
 from annet.storage import Device
 from annet.tabparser import make_formatter
@@ -82,3 +87,67 @@ def collapse_diffs(diffs: Mapping[Device, Diff]) -> Mapping[Tuple[Device, ...],
         res[tuple(x[0] for x in collapsed_diff)] = collapsed_diff[0][1][0]
 
     return res
+
+
+class FileDiffer(Protocol):
+    @abc.abstractmethod
+    def diff_file(self, hw: HardwareView, path: str | Path, old: str, new: str) -> list[str]:
+        raise NotImplementedError
+
+
+class UnifiedFileDiffer(FileDiffer):
+    def __init__(self):
+        self.context: int = 3
+
+    def diff_file(self, hw: HardwareView, path: str | Path, old: str, new: str) -> list[str]:
+        """Calculate the differences for config files.
+
+        Args:
+            hw: device hardware info
+            path: path to file on a device
+            old (Optional[str]): The old file content.
+            new (Optional[str]): The new file content.
+
+        Returns:
+            List[str]: List of difference lines.
+        """
+        return self._diff_text_file(old, new)
+
+    def _diff_text_file(self, old, new):
+        """Calculate the differences for plaintext files."""
+        context = self.context
+        old_lines = old.splitlines() if old else []
+        new_lines = new.splitlines() if new else []
+        context = max(len(old_lines), len(new_lines)) if context is None else context
+        return list(difflib.unified_diff(old_lines, new_lines, n=context, lineterm=""))
+
+
+class FrrFileDiffer(UnifiedFileDiffer):
+    def diff_file(self, hw: HardwareView, path: str | Path, old: str, new: str) -> list[str]:
+        if (hw.PC.Mellanox or hw.PC.NVIDIA) and (path == "/etc/frr/frr.conf"):
+            return self._diff_frr_conf(hw, old, new)
+        return super().diff_file(hw, path, old, new)
+
+    def _diff_frr_conf(self,  hw: HardwareView, old_text: str | None, new_text: str | None) -> list[str]:
+        """Calculate the differences for frr.conf files."""
+        indent = "  "
+        rb = rulebook.rulebook_provider_connector.get()
+        rulebook_data = rb.get_rulebook(hw)
+        formatter = tabparser.make_formatter(hw, indent=indent)
+
+        old_tree = tabparser.parse_to_tree(old_text or "", splitter=formatter.split)
+        new_tree = tabparser.parse_to_tree(new_text or "", splitter=formatter.split)
+
+        diff_tree = patching.make_diff(old_tree, new_tree, rulebook_data, [])
+        pre_diff = patching.make_pre(diff_tree)
+        diff_iterator = gen_pre_as_diff(pre_diff, show_rules=False, indent=indent, no_color=True)
+
+        return [line.rstrip() for line in diff_iterator if "frr version" not in line]
+
+
+class _FileDifferConnector(CachedConnector[FileDiffer]):
+    name = "Device file diff processor"
+    ep_name = "file_differ"
+
+
+file_differ_connector = _FileDifferConnector()

annet/gen.py

@@ -526,52 +526,6 @@ def worker(device_id, args: ShowGenOptions, stdin, loader: "Loader", filterer: F
                    False)
 
 
-def old_new_worker(device_id, args: DeployOptions, config, stdin, loader: "Loader", filterer: Filterer):
-    for res in old_new(
-        args,
-        config=config,
-        loader=loader,
-        filterer=filterer,
-        stdin=stdin,
-        device_ids=[device_id],
-        no_new=args.clear,
-        do_files_download=True,
-    ):
-        if res.err is not None and not args.tolerate_fails:
-            raise res.err
-        yield res
-
-
-class OldNewParallel(Parallel):
-    def __init__(self, args: DeployOptions, loader: "Loader", filterer: Filterer):
-        stdin = args.stdin(filter_acl=args.filter_acl, config=args.config)
-        super().__init__(
-            old_new_worker,
-            args,
-            config=args.config,
-            stdin=stdin,
-            loader=loader,
-            filterer=filterer,
-        )
-        self.tune_args(args)
-        self.tolerate_fails = args.tolerate_fails
-
-    def generated_configs(self, devices: List[Device]) -> Generator[OldNewResult, None, None]:
-        devices_by_id = {device.id: device for device in devices}
-        device_ids = list(devices_by_id)
-
-        for task_result in self.irun(device_ids, self.tolerate_fails):
-            if task_result.exc is not None:
-                device = devices_by_id.pop(task_result.device_id)
-                yield OldNewResult(device=device, err=task_result.exc)
-            elif task_result.result is not None:
-                yield from task_result.result
-                devices_by_id.pop(task_result.device_id)
-
-        for device in devices_by_id.values():
-            yield OldNewResult(device=device, err=Exception(f"No config returned for {device.hostname}"))
-
-
 @dataclasses.dataclass
 class DeviceFilesToDownload:
     entire: List[str] = dataclasses.field(default_factory=list)

annet/output.py

@@ -155,8 +155,15 @@ class OutputDriverBasic(OutputDriver):
             ret.append((label, getattr(exc, "formatted_output", f"{repr(exc)} (formatted_output is absent)"), True))
         return ret
 
-    def cfg_file_names(self, device: Device) -> List[str]:
-        return [f"{device.hostname}.cfg"]
+    def cfg_file_names(self, device: Device) -> list[str]:
+        res = []
+        if device.hostname:
+            res.append(f"{device.hostname}.cfg")
+        if device.id is not None and device.id != "":
+            res.append(f"_id_{device.id}.cfg")
+        if not res:
+            raise RuntimeError("Neither hostname nor id is known for device")
+        return res
 
     def entire_config_dest_path(self, device, config_path: str) -> str:
         """Формирует путь к конфигу в директории destname.

annet/rpl/__init__.py

@@ -16,11 +16,12 @@ __all__ = [
     "RoutingPolicy",
     "CommunityActionValue",
     "PrefixMatchValue",
+    "OrLonger",
 ]
 
 from .action import Action, ActionType, SingleAction
 from .condition import AndCondition, Condition, ConditionOperator, SingleCondition
-from .match_builder import R, MatchField, PrefixMatchValue
+from .match_builder import R, MatchField, PrefixMatchValue, OrLonger
 from .policy import RoutingPolicyStatement, RoutingPolicy
 from .result import ResultType
 from .routemap import RouteMap, Route

annet/rpl/match_builder.py

@@ -63,11 +63,15 @@ class SetConditionFactory(Generic[ValueT]):
         return SingleCondition(self.field, ConditionOperator.HAS_ANY, values)
 
 
+# OrLonger represents a pair of (le, ge)
+# for prefix mask length match in prefix-lists
+OrLonger = tuple[Optional[int], Optional[int]]
+
+
 @dataclass(frozen=True)
 class PrefixMatchValue:
     names: tuple[str, ...]
-    greater_equal: Optional[int]
-    less_equal: Optional[int]
+    or_longer: OrLonger = (None, None)
 
 
 class Checkable:
@@ -91,23 +95,23 @@ class Checkable:
     def match_v6(
             self,
             *names: str,
-            or_longer: tuple[Optional[int], Optional[int]] = (None, None),
+            or_longer: OrLonger = (None, None),
     ) -> SingleCondition[PrefixMatchValue]:
         return SingleCondition(
             MatchField.ipv6_prefix,
             ConditionOperator.CUSTOM,
-            PrefixMatchValue(names, greater_equal=or_longer[0], less_equal=or_longer[1]),
+            PrefixMatchValue(names, or_longer),
         )
 
     def match_v4(
             self,
             *names: str,
-            or_longer: tuple[Optional[int], Optional[int]] = (None, None),
+            or_longer: OrLonger = (None, None),
     ) -> SingleCondition[PrefixMatchValue]:
         return SingleCondition(
             MatchField.ip_prefix,
             ConditionOperator.CUSTOM,
-            PrefixMatchValue(names, greater_equal=or_longer[0], less_equal=or_longer[1]),
+            PrefixMatchValue(names, or_longer),
         )
 
 

annet/rpl_generators/__init__.py

@@ -10,14 +10,16 @@ __all__ = [
     "RDFilterFilterGenerator",
     "RDFilter",
     "IpPrefixList",
+    "IpPrefixListMember",
     "PrefixListFilterGenerator",
     "get_policies",
+    "ip_prefix_list",
 ]
 
 from .aspath import AsPathFilterGenerator
 from .community import CommunityListGenerator
 from .cumulus_frr import CumulusPolicyGenerator
-from .entities import CommunityList, AsPathFilter, CommunityType, CommunityLogic, RDFilter, IpPrefixList
+from .entities import CommunityList, AsPathFilter, CommunityType, CommunityLogic, RDFilter, IpPrefixList, IpPrefixListMember, ip_prefix_list
 from .execute import get_policies
 from .policy import RoutingPolicyGenerator
 from .prefix_lists import PrefixListFilterGenerator

annet/rpl_generators/cumulus_frr.py

@@ -14,7 +14,7 @@ from .entities import (
     AsPathFilter, IpPrefixList, CommunityList, CommunityLogic, CommunityType,
     mangle_united_community_list_name, PrefixListNameGenerator,
 )
-from .prefix_lists import get_used_prefix_lists, new_prefix_list_name_generator
+
 
 FRR_RESULT_MAP = {
     ResultType.ALLOW: "permit",
@@ -51,12 +51,6 @@ class CumulusPolicyGenerator(ABC):
     def get_prefix_lists(self, device: Any) -> Sequence[IpPrefixList]:
         raise NotImplementedError()
 
-    def get_used_prefix_lists(self, device: Any, name_generator: PrefixListNameGenerator) -> Sequence[IpPrefixList]:
-        return get_used_prefix_lists(
-            prefix_lists=self.get_prefix_lists(device),
-            name_generator=name_generator,
-        )
-
     @abstractmethod
     def get_community_lists(self, device: Any) -> list[CommunityList]:
         raise NotImplementedError()
@@ -66,8 +60,9 @@ class CumulusPolicyGenerator(ABC):
         raise NotImplementedError
 
     def generate_cumulus_rpl(self, device: Any) -> Iterator[Sequence[str]]:
+        prefix_lists = self.get_prefix_lists(device)
         policies = self.get_policies(device)
-        prefix_list_name_generator = new_prefix_list_name_generator(policies)
+        prefix_list_name_generator = PrefixListNameGenerator(prefix_lists, policies)
 
         communities = {c.name: c for c in self.get_community_lists(device)}
         yield from self._cumulus_as_path_filters(device, policies)
@@ -89,60 +84,46 @@ class CumulusPolicyGenerator(ABC):
 
     def _cumulus_prefix_list(
             self,
-            name: str,
             ip_type: Literal["ipv6", "ip"],
-            match: PrefixMatchValue,
             plist: IpPrefixList,
     ) -> Iterable[Sequence[str]]:
-        for i, prefix in enumerate(plist.members):
-            addr_mask = ip_interface(prefix)
+        for i, m in enumerate(plist.members):
+            ge, le = m.or_longer
             yield (
                 ip_type,
                 "prefix-list",
-                name,
+                plist.name,
                 f"seq {i * 5 + 5}",
-                "permit", f"{addr_mask.ip}/{addr_mask.network.prefixlen}",
+                "permit", str(m.prefix),
             ) + (
-                ("ge", str(match.greater_equal)) if match.greater_equal is not None else ()
+                ("ge", str(ge)) if ge is not None else ()
             ) + (
-                ("le", str(match.less_equal)) if match.less_equal is not None else ()
+                ("le", str(le)) if le is not None else ()
             )
 
     def _cumulus_prefix_lists(
             self, device: Any,
             policies: list[RoutingPolicy],
-            prefix_list_name_generator: PrefixListNameGenerator,
+            name_generator: PrefixListNameGenerator,
     ) -> Iterable[Sequence[str]]:
-        plists = {p.name: p for p in self.get_used_prefix_lists(device, prefix_list_name_generator)}
-        if not plists.values():
-            return
-
-        precessed_names = set()
+        processed_names = set()
         for policy in policies:
             for statement in policy.statements:
                 cond: SingleCondition[PrefixMatchValue]
                 for cond in statement.match.find_all(MatchField.ip_prefix):
                     for name in cond.value.names:
-                        mangled_name = prefix_list_name_generator.get_prefix_name(
-                            name=name,
-                            greater_equal=cond.value.greater_equal,
-                            less_equal=cond.value.less_equal,
-                        )
-                        if mangled_name in precessed_names:
+                        plist = name_generator.get_prefix(name, cond.value)
+                        if plist.name in processed_names:
                             continue
-                        yield from self._cumulus_prefix_list(mangled_name, "ip", cond.value, plists[name])
-                        precessed_names.add(mangled_name)
+                        yield from self._cumulus_prefix_list("ip", plist)
+                        processed_names.add(plist.name)
                 for cond in statement.match.find_all(MatchField.ipv6_prefix):
                     for name in cond.value.names:
-                        mangled_name = prefix_list_name_generator.get_prefix_name(
-                            name=name,
-                            greater_equal=cond.value.greater_equal,
-                            less_equal=cond.value.less_equal,
-                        )
-                        if mangled_name in precessed_names:
+                        plist = name_generator.get_prefix(name, cond.value)
+                        if plist.name in processed_names:
                             continue
-                        yield from self._cumulus_prefix_list(mangled_name, "ipv6", cond.value, plists[name])
-                        precessed_names.add(mangled_name)
+                        yield from self._cumulus_prefix_list("ipv6", plist)
+                        processed_names.add(plist.name)
         yield "!"
 
     def get_used_united_community_lists(
@@ -231,7 +212,7 @@ class CumulusPolicyGenerator(ABC):
             self,
             device: Any,
             condition: SingleCondition[Any],
-            prefix_list_name_generator: PrefixListNameGenerator,
+            name_generator: PrefixListNameGenerator,
     ) -> Iterator[Sequence[str]]:
         if condition.field == MatchField.community:
             for comm_name in self._get_match_community_names(condition):
@@ -251,21 +232,13 @@ class CumulusPolicyGenerator(ABC):
             return
         if condition.field == MatchField.ip_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_list_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "match", "ip address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "match", "ip address prefix-list", plist.name
             return
         if condition.field == MatchField.ipv6_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_list_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "match", "ipv6 address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "match", "ipv6 address prefix-list", plist.name
             return
         if condition.operator is not ConditionOperator.EQ:
             raise NotImplementedError(

annet/rpl_generators/entities.py

@@ -1,8 +1,10 @@
-from collections import defaultdict
+from ipaddress import IPv4Network, IPv6Network, ip_network
 from collections.abc import Sequence
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import Optional, List
+
+from annet.rpl import RoutingPolicy, PrefixMatchValue, OrLonger
 
 
 class CommunityLogic(Enum):
@@ -40,10 +42,48 @@ class AsPathFilter:
     filters: Sequence[str]
 
 
-@dataclass(frozen=True)
+@dataclass
+class IpPrefixListMember:
+    prefix: IPv4Network | IPv6Network
+    or_longer: OrLonger = (None, None)
+
+    def __post_init__(self):
+        self.prefix = ip_network(self.prefix)
+
+
+@dataclass
 class IpPrefixList:
     name: str
-    members: Sequence[str]
+    members: list[IpPrefixListMember]
+
+    def __post_init__(self):
+        for (i, m) in enumerate(self.members):
+            if isinstance(m, str):
+                self.members[i] = IpPrefixListMember(m)
+
+
+def ip_prefix_list(
+        name: str,
+        members_or_str: Sequence[IpPrefixListMember | str],
+        or_longer: OrLonger = (None, None),
+) -> IpPrefixList:
+    members: List[IpPrefixListMember] = []
+    for m in members_or_str:
+        if isinstance(m, str):
+            m = IpPrefixListMember(
+                prefix=ip_network(m),
+                or_longer=or_longer,
+            )
+        elif m.or_longer == (None, None):
+            m = IpPrefixListMember(
+                prefix=m.prefix,
+                or_longer=or_longer,
+            )
+        members.append(m)
+    return IpPrefixList(
+        name=name,
+        members=members,
+    )
 
 
 def arista_well_known_community(community: str) -> str:
@@ -58,26 +98,29 @@ def mangle_united_community_list_name(values: Sequence[str]) -> str:
 
 
 class PrefixListNameGenerator:
-    def __init__(self):
-        self._prefix_lists = defaultdict(set)
-
-    def add_prefix(self, name: str, greater_equal: Optional[int], less_equal: Optional[int]) -> None:
-        self._prefix_lists[name].add((greater_equal, less_equal))
-
-    def is_used(self, name: str):
-        return name in self._prefix_lists
-
-    def get_prefix_name(self, name: str, greater_equal: Optional[int], less_equal: Optional[int]) -> str:
-        if len(self._prefix_lists[name]) == 1:
-            return name
-        if greater_equal is less_equal is None:
-            return name
-        if greater_equal is None:
-            ge_str = "unset"
-        else:
-            ge_str = str(greater_equal)
-        if less_equal is None:
-            le_str = "unset"
-        else:
-            le_str = str(less_equal)
-        return f"{name}_{ge_str}_{le_str}"
+    def __init__(self, prefix_lists: Sequence[IpPrefixList], policies: Sequence[RoutingPolicy]):
+        self._prefix_lists = {x.name: x for x in prefix_lists}
+        self._policies = {x.name: x for x in policies}  # this is here for a later use ~azryve@
+
+    def get_prefix(self, name: str, match: PrefixMatchValue) -> IpPrefixList:
+        orig_prefix = self._prefix_lists[name]
+        override_name: Optional[str] = None
+        override_orlonger: Optional[OrLonger] = None
+
+        if any(match.or_longer):
+            ge, le = match.or_longer
+            ge_str = "unset" if ge is None else str(ge)
+            le_str = "unset" if le is None else str(le)
+            override_name = f"{orig_prefix.name}_{ge_str}_{le_str}"
+            override_orlonger = match.or_longer
+
+        return IpPrefixList(
+            name=override_name or name,
+            members=[
+                IpPrefixListMember(
+                    x.prefix,
+                    or_longer=override_orlonger or x.or_longer,
+                )
+                for x in orig_prefix.members
+            ],
+        )

annet/rpl_generators/policy.py

@@ -12,8 +12,9 @@ from annet.rpl.statement_builder import AsPathActionValue, NextHopActionValue, T
 from annet.rpl_generators.entities import (
     arista_well_known_community,
     CommunityList, RDFilter, PrefixListNameGenerator, CommunityLogic, mangle_united_community_list_name,
+    IpPrefixList,
 )
-from annet.rpl_generators.prefix_lists import new_prefix_list_name_generator
+
 
 HUAWEI_MATCH_COMMAND_MAP: dict[str, str] = {
     MatchField.as_path_filter: "as-path-filter {option_value}",
@@ -62,6 +63,10 @@ ARISTA_THEN_COMMAND_MAP: dict[str, str] = {
 class RoutingPolicyGenerator(PartialGenerator, ABC):
     TAGS = ["policy", "rpl", "routing"]
 
+    @abstractmethod
+    def get_prefix_lists(self, device: Any) -> list[IpPrefixList]:
+        raise NotImplementedError()
+
     @abstractmethod
     def get_policies(self, device: Any) -> list[RoutingPolicy]:
         raise NotImplementedError()
@@ -87,7 +92,7 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             condition: SingleCondition[Any],
             communities: dict[str, CommunityList],
             rd_filters: dict[str, RDFilter],
-            prefix_name_generator: PrefixListNameGenerator,
+            name_generator: PrefixListNameGenerator,
     ) -> Iterator[Sequence[str]]:
         if condition.field == MatchField.community:
             if condition.operator is ConditionOperator.HAS:
@@ -136,21 +141,13 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             return
         if condition.field == MatchField.ip_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "if-match", "ip-prefix", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "if-match", "ip-prefix", plist.name
             return
         if condition.field == MatchField.ipv6_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "if-match", "ipv6 address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "if-match", "ipv6 address prefix-list", plist.name
             return
         if condition.field == MatchField.as_path_length:
             if condition.operator is ConditionOperator.EQ:
@@ -353,10 +350,11 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                 yield "goto next-node"
 
     def run_huawei(self, device):
+        prefix_lists = self.get_prefix_lists(device)
         policies = self.get_policies(device)
         communities = {c.name: c for c in self.get_community_lists(device)}
         rd_filters = {f.name: f for f in self.get_rd_filters(device)}
-        prefix_name_generator = new_prefix_list_name_generator(policies)
+        prefix_name_generator = PrefixListNameGenerator(prefix_lists, policies)
 
         for policy in self.get_policies(device):
             for statement in policy.statements:
@@ -383,7 +381,7 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             condition: SingleCondition[Any],
             communities: dict[str, CommunityList],
             rd_filters: dict[str, RDFilter],
-            prefix_name_generator: PrefixListNameGenerator,
+            name_generator: PrefixListNameGenerator,
     ) -> Iterator[Sequence[str]]:
         if condition.field == MatchField.community:
             if condition.operator is ConditionOperator.HAS_ANY:
@@ -436,21 +434,13 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
             return
         if condition.field == MatchField.ip_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "match", "ip address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "match", "ip address prefix-list", plist.name
             return
         if condition.field == MatchField.ipv6_prefix:
             for name in condition.value.names:
-                mangled_name = prefix_name_generator.get_prefix_name(
-                    name=name,
-                    greater_equal=condition.value.greater_equal,
-                    less_equal=condition.value.less_equal,
-                )
-                yield "match", "ipv6 address prefix-list", mangled_name
+                plist = name_generator.get_prefix(name, condition.value)
+                yield "match", "ipv6 address prefix-list", plist.name
             return
         if condition.field == MatchField.as_path_length:
             if condition.operator is ConditionOperator.EQ:
@@ -492,12 +482,15 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                 yield "set", "community community-list", *action.value.replaced
             else:
                 yield "set", "community", "none"
-        for community_name in action.value.added:
-            yield "set", "community community-list", community_name, "additive"
-        for community_name in action.value.removed:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set community", arista_well_known_community(comm_value), "delete"
+        if action.value.added:
+            yield "set", "community community-list", *action.value.added, "additive"
+        if action.value.removed:
+            members = [
+                arista_well_known_community(member)
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set community", *members, "delete"
 
     def _arista_then_large_community(
             self,
@@ -520,10 +513,10 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                     first = False
                 else:
                     yield "set", "large-community large-community-list", community_name, "additive"
-        for community_name in action.value.added:
-            yield "set", "large-community large-community-list", community_name, "additive"
-        for community_name in action.value.removed:
-            yield "set large-community large-community-list", community_name, "delete"
+        if action.value.added:
+            yield "set", "large-community large-community-list",  *action.value.added, "additive"
+        if action.value.removed:
+            yield "set large-community large-community-list", *action.value.removed, "delete"
 
     def _arista_then_extcommunity_rt(
             self,
@@ -533,14 +526,20 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
     ) -> Iterator[Sequence[str]]:
         if action.value.replaced is not None:
             raise NotImplementedError("Extcommunity_rt replace is not supported for arista")
-        for community_name in action.value.added:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set", "extcommunity rt", comm_value, "additive"
-        for community_name in action.value.removed:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set extcommunity rt", comm_value, "delete"
+        if action.value.added:
+            members = [
+                f"rt {member}"
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set", "extcommunity", *members, "additive"
+        if action.value.removed:
+            members = [
+                f"rt {member}"
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set extcommunity", *members, "delete"
 
     def _arista_then_extcommunity_soo(
             self,
@@ -550,14 +549,20 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
     ) -> Iterator[Sequence[str]]:
         if action.value.replaced is not None:
             raise NotImplementedError("Extcommunity_soo replace is not supported for arista")
-        for community_name in action.value.added:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set", "extcommunity soo", comm_value, "additive"
-        for community_name in action.value.removed:
-            community = communities[community_name]
-            for comm_value in community.members:
-                yield "set", "extcommunity soo", comm_value, "delete"
+        if action.value.added:
+            members = [
+                f"soo {member}"
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set", "extcommunity", *members, "additive"
+        if action.value.removed:
+            members = [
+                f"soo {member}"
+                for community_name in action.value.removed
+                for member in communities[community_name].members
+            ]
+            yield "set", "extcommunity", *members, "delete"
 
     def _arista_then_as_path(
             self,
@@ -675,8 +680,9 @@ class RoutingPolicyGenerator(PartialGenerator, ABC):
                 yield "continue"
 
     def run_arista(self, device):
+        prefix_lists = self.get_prefix_lists(device)
         policies = self.get_policies(device)
-        prefix_name_generator = new_prefix_list_name_generator(policies)
+        prefix_name_generator = PrefixListNameGenerator(prefix_lists, policies)
         communities = {c.name: c for c in self.get_community_lists(device)}
         rd_filters = {f.name: f for f in self.get_rd_filters(device)}
 

annet/rpl_generators/prefix_lists.py

@@ -8,26 +8,6 @@ from annet.rpl import PrefixMatchValue, MatchField, SingleCondition, RoutingPoli
 from .entities import IpPrefixList, PrefixListNameGenerator
 
 
-def get_used_prefix_lists(
-        prefix_lists: Sequence[IpPrefixList], name_generator: PrefixListNameGenerator,
-) -> list[IpPrefixList]:
-    return [c for c in prefix_lists if name_generator.is_used(c.name)]
-
-
-def new_prefix_list_name_generator(policies: list[RoutingPolicy]) -> PrefixListNameGenerator:
-    name_gen = PrefixListNameGenerator()
-    for policy in policies:
-        for statement in policy.statements:
-            condition: SingleCondition[PrefixMatchValue]
-            for condition in statement.match.find_all(MatchField.ipv6_prefix):
-                for name in condition.value.names:
-                    name_gen.add_prefix(name, condition.value.greater_equal, condition.value.less_equal)
-            for condition in statement.match.find_all(MatchField.ip_prefix):
-                for name in condition.value.names:
-                    name_gen.add_prefix(name, condition.value.greater_equal, condition.value.less_equal)
-    return name_gen
-
-
 class PrefixListFilterGenerator(PartialGenerator, ABC):
     TAGS = ["policy", "rpl", "routing"]
 
@@ -39,12 +19,6 @@ class PrefixListFilterGenerator(PartialGenerator, ABC):
     def get_prefix_lists(self, device: Any) -> Sequence[IpPrefixList]:
         raise NotImplementedError()
 
-    def get_used_prefix_lists(self, device: Any, name_generator: PrefixListNameGenerator) -> Sequence[IpPrefixList]:
-        return get_used_prefix_lists(
-            prefix_lists=self.get_prefix_lists(device),
-            name_generator=name_generator,
-        )
-
     # huawei
     def acl_huawei(self, _):
         return r"""
@@ -54,57 +28,48 @@ class PrefixListFilterGenerator(PartialGenerator, ABC):
 
     def _huawei_prefix_list(
             self,
-            name: str,
             prefix_type: Literal["ipv6-prefix", "ip-prefix"],
-            match: PrefixMatchValue,
             plist: IpPrefixList,
     ) -> Iterable[Sequence[str]]:
-        for i, prefix in enumerate(plist.members):
-            addr_mask = ip_interface(prefix)
+        for i, m in enumerate(plist.members):
+            ge, le = m.or_longer
             yield (
                 "ip",
                 prefix_type,
-                name,
+                plist.name,
                 f"index {i * 5 + 5}",
                 "permit",
-                str(addr_mask.ip).upper(),
-                str(addr_mask.network.prefixlen),
+                str(m.prefix.network_address).upper(),
+                str(m.prefix.prefixlen),
             ) + (
-                ("greater-equal", str(match.greater_equal)) if match.greater_equal is not None else ()
+                ("greater-equal", str(ge)) if ge is not None else ()
             ) + (
-                ("less-equal", str(match.less_equal)) if match.less_equal is not None else ()
+                ("less-equal", str(le)) if le is not None else ()
             )
 
     def run_huawei(self, device: Any):
+        prefix_lists = self.get_prefix_lists(device)
         policies = self.get_policies(device)
-        name_generator = new_prefix_list_name_generator(policies)
-        plists = {p.name: p for p in self.get_used_prefix_lists(device, name_generator)}
-        precessed_names = set()
+
+        name_generator = PrefixListNameGenerator(prefix_lists, policies)
+        processed_names = set()
         for policy in policies:
             for statement in policy.statements:
                 cond: SingleCondition[PrefixMatchValue]
                 for cond in statement.match.find_all(MatchField.ip_prefix):
                     for name in cond.value.names:
-                        mangled_name = name_generator.get_prefix_name(
-                            name=name,
-                            greater_equal=cond.value.greater_equal,
-                            less_equal=cond.value.less_equal,
-                        )
-                        if mangled_name in precessed_names:
+                        plist = name_generator.get_prefix(name, cond.value)
+                        if plist.name in processed_names:
                             continue
-                        yield from self._huawei_prefix_list(mangled_name, "ip-prefix", cond.value, plists[name])
-                        precessed_names.add(mangled_name)
+                        yield from self._huawei_prefix_list("ip-prefix", plist)
+                        processed_names.add(plist.name)
                 for cond in statement.match.find_all(MatchField.ipv6_prefix):
                     for name in cond.value.names:
-                        mangled_name = name_generator.get_prefix_name(
-                            name=name,
-                            greater_equal=cond.value.greater_equal,
-                            less_equal=cond.value.less_equal,
-                        )
-                        if mangled_name in precessed_names:
+                        plist = name_generator.get_prefix(name, cond.value)
+                        if plist.name in processed_names:
                             continue
-                        yield from self._huawei_prefix_list(mangled_name, "ipv6-prefix", cond.value, plists[name])
-                        precessed_names.add(mangled_name)
+                        yield from self._huawei_prefix_list("ipv6-prefix", plist)
+                        processed_names.add(plist.name)
 
     # arista
     def acl_arista(self, _):
@@ -117,51 +82,41 @@ class PrefixListFilterGenerator(PartialGenerator, ABC):
 
     def _arista_prefix_list(
             self,
-            name: str,
             prefix_type: Literal["ipv6", "ip"],
-            match: PrefixMatchValue,
             plist: IpPrefixList,
     ) -> Iterable[Sequence[str]]:
-        with self.block(prefix_type, "prefix-list", name):
-            for i, prefix in enumerate(plist.members):
-                addr_mask = ip_interface(prefix)
+        with self.block(prefix_type, "prefix-list", plist.name):
+            for i, m in enumerate(plist.members):
+                ge, le = m.or_longer
                 yield (
                     f"seq {i * 10 + 10}",
                     "permit",
-                    addr_mask.with_prefixlen,
+                    str(m.prefix),
                 ) + (
-                    ("ge", str(match.greater_equal)) if match.greater_equal is not None else ()
+                    ("ge", str(ge)) if ge is not None else ()
                 ) + (
-                    ("le", str(match.less_equal)) if match.less_equal is not None else ()
+                    ("le", str(le)) if le is not None else ()
                 )
 
     def run_arista(self, device: Any):
+        prefix_lists = self.get_prefix_lists(device)
         policies = self.get_policies(device)
-        name_generator = new_prefix_list_name_generator(policies)
-        plists = {p.name: p for p in self.get_used_prefix_lists(device, name_generator)}
-        precessed_names = set()
+        name_generator = PrefixListNameGenerator(prefix_lists, policies)
+        processed_names = set()
         for policy in policies:
             for statement in policy.statements:
                 cond: SingleCondition[PrefixMatchValue]
                 for cond in statement.match.find_all(MatchField.ip_prefix):
                     for name in cond.value.names:
-                        mangled_name = name_generator.get_prefix_name(
-                            name=name,
-                            greater_equal=cond.value.greater_equal,
-                            less_equal=cond.value.less_equal,
-                        )
-                        if mangled_name in precessed_names:
+                        plist = name_generator.get_prefix(name, cond.value)
+                        if plist.name in processed_names:
                             continue
-                        yield from self._arista_prefix_list(mangled_name, "ip", cond.value, plists[name])
-                        precessed_names.add(mangled_name)
+                        yield from self._arista_prefix_list("ip", plist)
+                        processed_names.add(plist.name)
                 for cond in statement.match.find_all(MatchField.ipv6_prefix):
                     for name in cond.value.names:
-                        mangled_name = name_generator.get_prefix_name(
-                            name=name,
-                            greater_equal=cond.value.greater_equal,
-                            less_equal=cond.value.less_equal,
-                        )
-                        if mangled_name in precessed_names:
+                        plist = name_generator.get_prefix(name, cond.value)
+                        if plist.name in processed_names:
                             continue
-                        yield from self._arista_prefix_list(mangled_name, "ipv6", cond.value, plists[name])
-                        precessed_names.add(mangled_name)
+                        yield from self._arista_prefix_list("ipv6", plist)
+                        processed_names.add(plist.name)

{annet-1.1.2.dist-info → annet-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 1.1.2
+Version: 2.0.0
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-1.1.2.dist-info → annet-2.0.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 annet/__init__.py,sha256=0OKkFkqog8As7B6ApdpKQkrEAcEELUREWp82D8WvGA8,1846
-annet/annet.py,sha256=TMdEuM7GJQ4TjRVmuK3bCTZN-21lxjQ9sXqEdILUuBk,725
+annet/annet.py,sha256=8Hc-n0S6d-YhcMpMiMET_SsYKfHFJeCA_E2gKgzK-2Y,790
 annet/argparse.py,sha256=v1MfhjR0B8qahza0WinmXClpR8UiDFhmwDDWtNroJPA,12855
 annet/bgp_models.py,sha256=oibTSdipNkGL4t8Xn94bhyKHMOtwbPBqmYaAy4FmTxQ,12361
 annet/cli.py,sha256=hDpjIr3w47lgQ_CvCQS1SXFDK-SJrf5slbT__5u6GIA,12342
@@ -7,14 +7,14 @@ annet/cli_args.py,sha256=KQlihxSl-Phhq1-9oJDdNSbIllEX55LlPfH6viEKOuw,13483
 annet/connectors.py,sha256=aoiDVLPizx8CW2p8SAwGCzyO_WW8H9xc2aujbGC4bDg,4882
 annet/deploy.py,sha256=3O96k17FbVt8KCvxF4gujXAB81U2-XRJyHLpbc9ekSQ,7529
 annet/deploy_ui.py,sha256=SDTJ-CF6puW0KHQ0g_NDp61Tqh6xkTBMxv8PrBhGyNI,27977
-annet/diff.py,sha256=zLcaCnb4lZRUb7frpH1CstQ3kacRcCblZs1uLG8J5lk,3391
+annet/diff.py,sha256=SOhl706lpXdbrAwElgZqIzsTZEJRyDxOQ51fi910H0M,6088
 annet/executor.py,sha256=lcKI-EbYqeCiBNpL729kSltduzxbAzOkQ1L_QK7tNv8,5112
 annet/filtering.py,sha256=ZtqxPsKdV9reZoRxtQyBg22BqyMqd-2SotYcxZ-68AQ,903
-annet/gen.py,sha256=A718tYqIcxAa8tQEdjR6PjQ2ovWBnwPH7STKh38lmFY,33567
+annet/gen.py,sha256=m76bL6rVbusNV_uVHrHnA3D7TUvvLtckXx7hlr5HGA0,31897
 annet/hardware.py,sha256=_iR28dWiPtt6ZYdk-qg1sxazkSRJE3ukqKB-fFFfQak,1141
 annet/implicit.py,sha256=G6EwZbrtUp089qRAwh96hminp236-1pJbeKAedoEafg,6056
 annet/lib.py,sha256=4N4X6jCCrig5rk7Ua4AofrV9zK9jhzkBq57fLsfBJjw,4812
-annet/output.py,sha256=FYMcWCc43-b51KsCiKnXPZHawhgWNoVtY9gRqw__Ce0,7473
+annet/output.py,sha256=se8EpyNS9f9kPOlOaAV0ht4DjzDoBr8F2UafiezLPYw,7743
 annet/parallel.py,sha256=hLkzEht0KhzmzUWDdO4QFYQHzhxs3wPlTA8DxbB2ziw,17160
 annet/patching.py,sha256=nILbY5oJajN0b1j3f0HEJm05H3HVThnWvB7vDVh7UQw,559
 annet/reference.py,sha256=B8mH8VUMcecPnzULiTVb_kTQ7jQrCL7zp4pfIZQa5fk,4035
@@ -68,7 +68,7 @@ annet/annlib/rbparser/platform.py,sha256=65-r9mboRA3gaz9DRkSwPCdCRQneItqxppdMB6z
 annet/annlib/rbparser/syntax.py,sha256=iZ7Y-4QQBw4L3UtjEh54qisiRDhobl7HZxFNdP8mi54,3577
 annet/annlib/rulebook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/annlib/rulebook/common.py,sha256=hqwmmNofm5q2f-hV2usMY-IPMeiANLth28tZcRBYJTw,16640
-annet/api/__init__.py,sha256=oj6n0hwdxEbv7EoqAQUA56413BddSlIXNR_pUDTb8fY,35054
+annet/api/__init__.py,sha256=YHhYDXAJVUijhjFaha_WxwpOMuc39zuy2e3PWt0yMCE,35106
 annet/configs/context.yml,sha256=RVLrKLIHpCty7AGwOnmqf7Uu0iZQCn-AjYhophDJer8,259
 annet/configs/logging.yaml,sha256=EUagfir99QqA73Scc3k7sfQccbU3E1SvEQdyhLFtCl4,997
 annet/generators/__init__.py,sha256=rVHHDTPKHPZsml1eNEAj3o-8RweFTN8J7LX3tKMXdIY,16402
@@ -91,22 +91,22 @@ annet/mesh/models_converter.py,sha256=itfrxDd5zdTQpFNmo-YXIFQDpYyBuQ6g7xpcjxvK6u
 annet/mesh/peer_models.py,sha256=Div4o1t6Z0TWvy-8WKg4-n9WOd2PKCmIpfbkILDlDtk,2791
 annet/mesh/port_processor.py,sha256=RHiMS5W8qoDkTKiarQ748bcr8bNx4g_R4Y4vZg2k4TU,478
 annet/mesh/registry.py,sha256=xmWF7yxWXmwqX2_jyMAKrbGd2G9sjb4rYDx4Xk61QKc,9607
-annet/rpl/__init__.py,sha256=0kcIktE3AmS0rlm9xzVDf53xk08OeZXgD-6ZLCt_KCs,731
+annet/rpl/__init__.py,sha256=8nSiFpXH4OhzRGKr-013nHwwKk5Y50uh2gL7d_IoV8U,757
 annet/rpl/action.py,sha256=PY6W66j908RuqQ1_ioxayqVN-70rxDk5Z59EGHtxI98,1246
 annet/rpl/condition.py,sha256=MJri4MbWtPkLHIsLMAtsIEF7e8IAS9dIImjmJs5vS5U,3418
-annet/rpl/match_builder.py,sha256=vK0faYyg3vJGOp6LSKscLCno3Fc2PfznOmVCEUEhZfk,4774
+annet/rpl/match_builder.py,sha256=8hvkNWF29yIAt8cpS7P797ePm3ikZBZwrVQj7QcCsP8,4749
 annet/rpl/policy.py,sha256=P1Kt-8fHFxEczeP-RwkK_wrGN0p7IR-hOApEd2vC55E,448
 annet/rpl/result.py,sha256=PHFn1zhDeqLBn07nkYw5vsoXew4nTwkklOwqvFWzBLg,141
 annet/rpl/routemap.py,sha256=SIyk73OzPp2oH_XwrDv2xczuY2Zt1VsJmB0TT5r7F5g,2593
 annet/rpl/statement_builder.py,sha256=sVGOYsCV0s_SFQUy2WtUyQqKy5H4MOfmRCJWGj-UOJ4,9403
-annet/rpl_generators/__init__.py,sha256=ZLWs-flcpyIbdhxSDfNt-ORDrLe8ins25sWdXTWeUoA,748
+annet/rpl_generators/__init__.py,sha256=V4rAZlBaOUSjeQ5eCNmWeD7BSJLIwy0lKU_01grebpc,832
 annet/rpl_generators/aspath.py,sha256=kZakwPLfGGiXu9fC6I1z-pvy7Fe-4dy93_-lYcx39_4,2038
 annet/rpl_generators/community.py,sha256=SWpaOvoQUNISuRm41-IvGPFmntvgFv9ee4zegsMyeo0,11496
-annet/rpl_generators/cumulus_frr.py,sha256=F-LRT-UPnztUqinp3KYKqh796L9dqkzPKBUxMkiFjF8,21111
-annet/rpl_generators/entities.py,sha256=DIpgAQ8Tslo2hq6iFBaYkJX12BFBiccN8GOaRVxR1Uk,1985
+annet/rpl_generators/cumulus_frr.py,sha256=OabE9Me0O0iYCl20JOq9khTNhV2tXTrB3hrx9ohI3xE,19651
+annet/rpl_generators/entities.py,sha256=gL_Ap7dz2ioTCbA-4DIZceeE-7-_Var5hItVz--bVcs,3343
 annet/rpl_generators/execute.py,sha256=wS6e6fwcPWywsHB0gBMqZ17eF0s4YOBgDgwPB_cr5Rw,431
-annet/rpl_generators/policy.py,sha256=NeqB0reRN_KuY8LYkeGT3dRPe2HFDT9RfmVy5fcA3zw,32570
-annet/rpl_generators/prefix_lists.py,sha256=D4WXeISevf62EmDu1GYdldjz2gmONFFlmgMyGAOa_m8,7248
+annet/rpl_generators/policy.py,sha256=t0n4kRYT_cQIfPUXvQBfGiKwMF6GrpiHqs93KMq075s,32335
+annet/rpl_generators/prefix_lists.py,sha256=5jM5Xj0dtx5xF9ap-TgExs0ofRAzm0LN2j3aL5Ub_yc,4778
 annet/rpl_generators/rd.py,sha256=YGXgx1D2D0-pixgspXJzA6NvW8lx3AmHMxIY2l5rraI,1457
 annet/rulebook/__init__.py,sha256=oafL5HC8QHdkO9CH2q_fxohPMxOgjn-dNQa5kPjuqsA,3942
 annet/rulebook/common.py,sha256=zK1s2c5lc5HQbIlMUQ4HARQudXSgOYiZ_Sxc2I_tHqg,721
@@ -175,13 +175,13 @@ annet_generators/mesh_example/bgp.py,sha256=jzyDndSSGYyYBquDnLlR-7P5lzmUKcSyYCml
 annet_generators/mesh_example/mesh_logic.py,sha256=DJS5JMCTs0rs0LN__0LulNgo2ekUcWiOMe02BlOeFas,1454
 annet_generators/rpl_example/__init__.py,sha256=A7DTn-SVSlUpeO7mKT_obqimp29p9zWfVRPBSxmENQY,209
 annet_generators/rpl_example/generator.py,sha256=zndIGfV4ZlTxPgAGYs7bMQvTc_tYScODqJz3fuyermY,3871
-annet_generators/rpl_example/items.py,sha256=Ez1RF5YhcXNCusBmeApIjRL3rBlMazNZd29Gpw1_IsA,766
+annet_generators/rpl_example/items.py,sha256=d99HSXDHFjZq511EvGhIqRTWK3F4ZsCWfdUqFYQcyhE,772
 annet_generators/rpl_example/mesh.py,sha256=z_WgfDZZ4xnyh3cSf75igyH09hGvtexEVwy1gCD_DzA,288
 annet_generators/rpl_example/route_policy.py,sha256=z6nPb0VDeQtKD1NIg9sFvmUxBD5tVs2frfNIuKdM-5c,2318
-annet-1.1.2.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
-annet-1.1.2.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
-annet-1.1.2.dist-info/METADATA,sha256=Ngyf7Hi193Mgaifi37xaep8v7fjSM9-KWlIveKaXiEg,793
-annet-1.1.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-annet-1.1.2.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
-annet-1.1.2.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
-annet-1.1.2.dist-info/RECORD,,
+annet-2.0.0.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
+annet-2.0.0.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
+annet-2.0.0.dist-info/METADATA,sha256=9UifSXsrbaDmr4yZByRC-grykjjq-HGfyT32G1aDE6w,793
+annet-2.0.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+annet-2.0.0.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
+annet-2.0.0.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
+annet-2.0.0.dist-info/RECORD,,

annet_generators/rpl_example/items.py

@@ -1,4 +1,4 @@
-from annet.rpl_generators import AsPathFilter, CommunityList, CommunityType, RDFilter, IpPrefixList
+from annet.rpl_generators import AsPathFilter, CommunityList, CommunityType, RDFilter, ip_prefix_list
 
 AS_PATH_FILTERS = [
     AsPathFilter("ASP_EXAMPLE", [".*123456.*"]),
@@ -16,6 +16,6 @@ RD_FILTERS = [
 ]
 
 PREFIX_LISTS = [
-    IpPrefixList("IPV6_LIST_EXAMPLE", ["2a13:5941::/32"]),
-    IpPrefixList("IPV4_LIST_EXAMPLE", ["0.0.0.0/8", "10.0.0.0/8"]),
+    ip_prefix_list("IPV6_LIST_EXAMPLE", ["2a13:5941::/32"]),
+    ip_prefix_list("IPV4_LIST_EXAMPLE", ["0.0.0.0/8", "10.0.0.0/8"]),
 ]