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

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)