annet 0.16.26__py3-none-any.whl → 0.16.28__py3-none-any.whl

annet/adapters/file/provider.py

@@ -1,7 +1,7 @@
 from annet.annlib.netdev.views.dump import DumpableView
 from annet.storage import Query
 from dataclasses import dataclass, fields
-from typing import List, Iterable, Optional, Any
+from typing import List, Iterable, Optional, Any, Sequence
 from annet.storage import StorageProvider, Storage
 from annet.connectors import AdapterWithName
 from annet.storage import Device as DeviceCls
@@ -56,6 +56,15 @@ class DeviceStorage:
 class Device(DeviceCls, DumpableView):
     dev: DeviceStorage
 
+    def __hash__(self):
+        return hash((self.id, type(self)))
+
+    def __eq__(self, other):
+        return type(self) is type(other) and self.fqdn == other.fqdn and self.vendor == other.vendor
+
+    def is_pc(self) -> bool:
+        return False
+
     @property
     def hostname(self) -> str:
         return self.dev.hostname
@@ -68,15 +77,6 @@ class Device(DeviceCls, DumpableView):
     def id(self):
         return self.dev.id
 
-    def __hash__(self):
-        return hash((self.id, type(self)))
-
-    def __eq__(self, other):
-        return type(self) is type(other) and self.fqdn == other.fqdn and self.vendor == other.vendor
-
-    def is_pc(self) -> bool:
-        return False
-
     @property
     def storage(self) -> Storage:
         return self
@@ -93,6 +93,18 @@ class Device(DeviceCls, DumpableView):
     def neighbours_ids(self):
         pass
 
+    def make_lag(self, lag: int, ports: Sequence[str], lag_min_links: Optional[int]) -> Interface:
+        raise NotImplementedError
+
+    def add_svi(self, svi: int) -> Interface:
+        raise NotImplementedError
+
+    def add_subif(self, interface: str, subif: int) -> Interface:
+        raise NotImplementedError
+
+    def neighbours_fqdns(self) -> list[str]:
+        return []
+
 
 @dataclass
 class Devices:
@@ -199,6 +211,12 @@ class FS(Storage):
     def flush_perf(self):
         pass
 
+    def resolve_all_fdnds(self) -> list[str]:
+        return [d.fqdn for d in self.inventory.devices]
+
+    def search_connections(self, device: "Device", neighbor: "Device") -> list[tuple["Interface", "Interface"]]:
+        return []
+
 
 def filter_query(devices: list[Device], query: Query) -> list[Device]:
     result: list[Device] = []

annet/adapters/netbox/v37/storage.py

@@ -122,7 +122,7 @@ class NetboxStorageV37(Storage):
         if self._all_fqdns is None:
             self._all_fqdns = [
                 d.name
-                for d in self.netbox.dcim_all_devices().results
+                for d in self.netbox.dcim_all_devices_brief().results
             ]
         return self._all_fqdns
 

annet/annlib/netdev/devdb/data/devdb.json

@@ -104,9 +104,9 @@
     "Nokia.NS7750": " 7750",
     "Nokia.SR_1s": "SR-1s",
 
-    "PC": "^(PC|pc|[Mm]ellanox SN|[Ee]dge-?[Cc]ore|[Mm]oxa|[Aa]sterfusion CX|[Uu]fi[Ss]pace)",
+    "PC": "^(PC|pc|[Mm]ellanox SN|[Ee]dge-?[Cc]ore|[Mm]oxa|NVIDIA|[Aa]sterfusion CX|[Uu]fi[Ss]pace)",
 
-    "PC.Whitebox": "([Mm]ellanox SN|[Ee]dge-?[Cc]ore|[Aa]sterfusion CX|[Uu]fi[Ss]pace)",
+    "PC.Whitebox": "([Mm]ellanox SN|[Ee]dge-?[Cc]ore|NVIDIA|[Aa]sterfusion CX|[Uu]fi[Ss]pace)",
     "PC.Whitebox.Mellanox": "[Mm]ellanox",
     "PC.Whitebox.Mellanox.SN": " SN",
     "PC.Whitebox.Mellanox.SN.SN2100": " SN2100",
@@ -118,6 +118,7 @@
     "PC.Whitebox.Edgecore.AS9736": "AS9736",
     "PC.Whitebox.NVIDIA": "NVIDIA",
     "PC.Whitebox.NVIDIA.SN": " SN",
+    "PC.Whitebox.NVIDIA.SN.SN5400": " SN5400",
     "PC.Whitebox.NVIDIA.SN.SN5600": " SN5600",
     "PC.Moxa": "[Mm]oxa",
     "PC.Moxa.NPort": " [Nn][Pp]ort",

annet/bgp_models.py

@@ -1,3 +1,4 @@
+from collections.abc import Sequence, Iterable
 from dataclasses import dataclass, field
 from typing import Literal, Union, Optional
 
@@ -244,6 +245,7 @@ class VrfOptions:
     ipv6_labeled_unicast: FamilyOptions
 
     vrf_name_global: Optional[str] = None
+    as_path_relax: bool = False
     rt_import: list[str] = field(default_factory=list)
     rt_export: list[str] = field(default_factory=list)
     rt_import_v4: list[str] = field(default_factory=list)
@@ -261,6 +263,7 @@ class GlobalOptions:
     ipv4_labeled_unicast: FamilyOptions
     ipv6_labeled_unicast: FamilyOptions
 
+    as_path_relax: bool = False
     local_as: ASN = ASN(None)
     loops: int = 0
     multipath: int = 0
@@ -268,3 +271,28 @@ class GlobalOptions:
     vrf: dict[str, VrfOptions] = field(default_factory=dict)
 
     groups: list[PeerGroup] = field(default_factory=list)
+
+
+@dataclass
+class BgpConfig:
+    global_options: GlobalOptions
+    peers: list[Peer]
+
+
+def _used_policies(peer: Union[Peer, PeerGroup]) -> Iterable[str]:
+    if peer.import_policy:
+        yield peer.import_policy
+    if peer.export_policy:
+        yield peer.export_policy
+
+
+def extract_policies(config: BgpConfig) -> Sequence[str]:
+    result: list[str] = []
+    for vrf in config.global_options.vrf.values():
+        for group in vrf.groups:
+            result.extend(_used_policies(group))
+    for group in config.global_options.groups:
+        result.extend(_used_policies(group))
+    for peer in config.peers:
+        result.extend(_used_policies(peer))
+    return result

annet/implicit.py

@@ -133,17 +133,29 @@ def _implicit_tree(device):
                         no shutdown
             """
     elif device.hw.Cisco:
-        text += r"""
-            !interface */\S*Ethernet\S+/
-                mtu 1500
-                no shutdown
-            !interface */Loopback[0-9.]+/
-                mtu 1500
-                no shutdown
-            !interface */port-channel[0-9.]+/
-                mtu 1500
-                no shutdown
-        """
+        # C2900/C3500/C3600 does not support the MTU on a per-interface basis
+        if device.hw.Cisco.Catalyst.C2900 or device.hw.Cisco.Catalyst.C3500 \
+           or device.hw.Cisco.Catalyst.C3600:
+            text += r"""
+                !interface */\S*Ethernet\S+/
+                    no shutdown
+                !interface */Loopback[0-9.]+/
+                    no shutdown
+                !interface */port-channel[0-9.]+/
+                    no shutdown
+            """
+        else:
+            text += r"""
+                !interface */\S*Ethernet\S+/
+                    mtu 1500
+                    no shutdown
+                !interface */Loopback[0-9.]+/
+                    mtu 1500
+                    no shutdown
+                !interface */port-channel[0-9.]+/
+                    mtu 1500
+                    no shutdown
+            """
         if device.hw.Cisco.Catalyst:
             # this configuration is not visible in running-config when enabled
             text += r"""

annet/mesh/__init__.py

@@ -10,6 +10,9 @@ __all__ = [
     "Match",
     "VirtualLocal",
     "VirtualPeer",
+    "PortProcessor",
+    "separate_ports",
+    "united_ports"
 ]
 
 from .executor import MeshExecutor
@@ -17,3 +20,4 @@ from .match_args import Left, Right, Match
 from .registry import (
     DirectPeer, IndirectPeer, MeshSession, GlobalOptions, MeshRulesRegistry, VirtualLocal, VirtualPeer,
 )
+from .port_processor import PortProcessor, united_ports, separate_ports

annet/mesh/basemodel.py

@@ -60,6 +60,11 @@ class Concat(Merger):
         return x + y  # type: ignore[operator]
 
 
+class Unite(Merger):
+    def _merge(self, name: str, x: T, y: T) -> T:
+        return x | y  # type: ignore[operator]
+
+
 class Merge(Merger):
     def _merge(self, name: str, x: "ModelT", y: "ModelT") -> "ModelT":  # type: ignore[override]
         return merge(x, y)

annet/mesh/device_models.py

@@ -61,6 +61,7 @@ class VrfOptions(_FamiliesMixin, BaseMeshModel):
 
     vrf_name: str
     vrf_name_global: Optional[str]
+    as_path_relax: bool
     import_policy: Optional[str]
     export_policy: Optional[str]
     rt_import: Annotated[tuple[str, ...], Concat()]
@@ -78,6 +79,7 @@ class GlobalOptionsDTO(_FamiliesMixin, BaseMeshModel):
         kwargs.setdefault("vrf", KeyDefaultDict(lambda x: VrfOptions(vrf_name=x)))
         super().__init__(**kwargs)
 
+    as_path_relax: bool
     local_as: Union[int, str]
     loops: int
     multipath: int

annet/mesh/executor.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from logging import getLogger
 from typing import Annotated, Callable, Optional, Union
 
-from annet.bgp_models import Peer, GlobalOptions
+from annet.bgp_models import Peer, GlobalOptions, BgpConfig
 from annet.storage import Device, Storage
 from .basemodel import merge, BaseMeshModel, Merge, UseLast, MergeForbiddenError
 from .device_models import GlobalOptionsDTO
@@ -12,6 +12,7 @@ from .registry import (
     DirectPeer,
     GlobalOptions as MeshGlobalOptions,
     IndirectPeer,
+    MatchedDirectPair,
     MeshRulesRegistry,
     MeshSession,
     VirtualLocal,
@@ -21,12 +22,6 @@ from .registry import (
 logger = getLogger(__name__)
 
 
-@dataclass
-class MeshExecutionResult:
-    global_options: GlobalOptions
-    peers: list[Peer]
-
-
 @dataclass(frozen=True)
 class PeerKey:
     fqdn: str
@@ -38,6 +33,7 @@ class Pair(BaseMeshModel):
     local: Annotated[Union[DirectPeerDTO, IndirectPeerDTO], Merge()]
     connected: Annotated[Union[DirectPeerDTO, IndirectPeerDTO], Merge()]
     device: Annotated[Device, UseLast()]
+    ports: list[str]
 
 
 class VirtualPair(BaseMeshModel):
@@ -76,72 +72,92 @@ class MeshExecutor:
         except AttributeError:
             return str(handler)
 
+    def _execute_direct_pair(
+            self,
+            device: Device,
+            neighbor_device: Device,
+            rule: MatchedDirectPair,
+            ports: list[tuple[str, str]],
+            all_connected_ports: list[tuple[str, str]],
+    ) -> Pair:
+        session = MeshSession()
+        handler_name = self._handler_name(rule.handler)
+        logger.debug("Running direct handler: %s", handler_name)
+        if rule.direct_order:
+            peer_device = DirectPeer(rule.match_left, device, [], [])
+            peer_neighbor = DirectPeer(rule.match_right, neighbor_device, [], [])
+        else:
+            peer_neighbor = DirectPeer(rule.match_left, neighbor_device, [], [])
+            peer_device = DirectPeer(rule.match_right, device, [], [])
+
+        for local_port, remote_port in ports:
+            peer_device.ports.append(local_port)
+            peer_neighbor.ports.append(remote_port)
+        for local_port, remote_port in all_connected_ports:
+            peer_device.all_connected_ports.append(local_port)
+            peer_neighbor.all_connected_ports.append(remote_port)
+
+        if rule.direct_order:
+            rule.handler(peer_device, peer_neighbor, session)
+        else:
+            rule.handler(peer_neighbor, peer_device, session)
+
+        try:
+            neighbor_dto = merge(DirectPeerDTO(), peer_neighbor, session)
+        except MergeForbiddenError as e:
+            raise ValueError(
+                f"Handler `{handler_name}` provided session data conflicting with "
+                f"peer data for device `{neighbor_device.fqdn}`:\n" + str(e)
+            ) from e
+        try:
+            device_dto = merge(DirectPeerDTO(), peer_device, session)
+        except MergeForbiddenError as e:
+            raise ValueError(
+                f"Handler `{handler_name}` provided session data conflicting with "
+                f"peer data for device `{device.fqdn}`:\n" + str(e)
+            ) from e
+
+        return Pair(local=device_dto, connected=neighbor_dto, device=neighbor_device, ports=peer_device.ports)
+
     def _execute_direct(self, device: Device) -> list[Pair]:
         # we can have multiple rules for the same pair
         # we merge them according to remote fqdn
         neighbor_peers: dict[PeerKey, Pair] = {}
         # TODO batch resolve
         for rule in self._registry.lookup_direct(device.fqdn, device.neighbours_fqdns):
-            session = MeshSession()
             handler_name = self._handler_name(rule.handler)
-            logger.debug("Running direct handler: %s", handler_name)
             if rule.direct_order:
                 neighbor_device = self._storage.make_devices([rule.name_right])[0]
-                peer_device = DirectPeer(rule.match_left, device, [])
-                peer_neighbor = DirectPeer(rule.match_right, neighbor_device, [])
             else:
                 neighbor_device = self._storage.make_devices([rule.name_left])[0]
-                peer_neighbor = DirectPeer(rule.match_left, neighbor_device, [])
-                peer_device = DirectPeer(rule.match_right, device, [])
-
-            interfaces = self._storage.search_connections(device, neighbor_device)
-            for local_port, remote_port in interfaces:
-                peer_device.ports.append(local_port.name)
-                peer_neighbor.ports.append(remote_port.name)
-
-            if rule.direct_order:
-                rule.handler(peer_device, peer_neighbor, session)
-            else:
-                rule.handler(peer_neighbor, peer_device, session)
-
-            try:
-                neighbor_dto = merge(DirectPeerDTO(), peer_neighbor, session)
-            except MergeForbiddenError as e:
-                raise ValueError(
-                    f"Handler `{handler_name}` provided session data conflicting with "
-                    f"peer data for device `{neighbor_device.fqdn}`:\n" + str(e)
-                ) from e
-            try:
-                device_dto = merge(DirectPeerDTO(), peer_device, session)
-            except MergeForbiddenError as e:
-                raise ValueError(
-                    f"Handler `{handler_name}` provided session data conflicting with "
-                    f"peer data for device `{device.fqdn}`:\n" + str(e)
-                ) from e
-
-            pair = Pair(local=device_dto, connected=neighbor_dto, device=neighbor_device)
-            addr = getattr(neighbor_dto, "addr", None)
-            if addr is None:
-                raise ValueError(f"Handler `{handler_name}` returned no peer addr")
-            peer_key = PeerKey(
-                fqdn=neighbor_device.fqdn,
-                addr=addr,
-                vrf=getattr(neighbor_dto, "vrf", "")
-            )
-            try:
-                if peer_key in neighbor_peers:
-                    pair = merge(neighbor_peers[peer_key], pair)
-            except MergeForbiddenError as e:
-                if rule.direct_order:
-                    pair_names = device.fqdn, neighbor_device.fqdn
-                else:
-                    pair_names = neighbor_device.fqdn, device.fqdn
-                raise ValueError(
-                    f"Handler `{handler_name}` provides data conflicting with "
-                    f"previously loaded for device pair {pair_names} "
-                    f"with addr={peer_key.addr}, vrf{peer_key.vrf}:\n" + str(e)
-                ) from e
-            neighbor_peers[peer_key] = pair
+            all_connected_ports = [
+                (p1.name, p2.name)
+                for p1, p2 in self._storage.search_connections(device, neighbor_device)
+            ]
+            for ports in rule.port_processor(all_connected_ports):
+                pair = self._execute_direct_pair(device, neighbor_device, rule, ports, all_connected_ports)
+                addr = getattr(pair.connected, "addr", None)
+                if addr is None:
+                    raise ValueError(f"Handler `{handler_name}` returned no peer addr")
+                peer_key = PeerKey(
+                    fqdn=pair.device.fqdn,
+                    addr=addr,
+                    vrf=getattr(pair.connected, "vrf", "")
+                )
+                try:
+                    if peer_key in neighbor_peers:
+                        pair = merge(neighbor_peers[peer_key], pair)
+                except MergeForbiddenError as e:
+                    if rule.direct_order:
+                        pair_names = device.fqdn, pair.device.fqdn
+                    else:
+                        pair_names = pair.device.fqdn, device.fqdn
+                    raise ValueError(
+                        f"Handler `{handler_name}` provides data conflicting with "
+                        f"previously loaded for device pair {pair_names} "
+                        f"with addr={peer_key.addr}, vrf{peer_key.vrf}:\n" + str(e)
+                    ) from e
+                neighbor_peers[peer_key] = pair
         return list(neighbor_peers.values())
 
     def _execute_virtual(self, device: Device) -> list[VirtualPair]:
@@ -249,8 +265,15 @@ class MeshExecutor:
     def _to_bgp_global(self, global_options: GlobalOptionsDTO) -> GlobalOptions:
         return to_bgp_global_options(global_options)
 
-    def _apply_interface_changes(self, device: Device, neighbor: Device, changes: InterfaceChanges) -> str:
-        port_pairs = self._storage.search_connections(device, neighbor)
+    def _apply_interface_changes(
+            self, device: Device, neighbor: Device, ports: list[str], changes: InterfaceChanges,
+    ) -> str:
+        # filter ports according to processed in pair
+        port_pairs = [
+            p
+            for p in self._storage.search_connections(device, neighbor)
+            if p[0].name in ports
+        ]
         if len(port_pairs) > 1:
             if changes.lag is changes.svi is None:
                 raise ValueError(
@@ -279,7 +302,7 @@ class MeshExecutor:
     def _apply_virtual_interface_changes(self, device: Device, local: VirtualLocalDTO) -> str:
         return device.add_svi(local.svi).name  # we check if SVI configured in execute method
 
-    def execute_for(self, device: Device) -> MeshExecutionResult:
+    def execute_for(self, device: Device) -> BgpConfig:
         all_fqdns = self._storage.resolve_all_fdnds()
 
         global_options = self._to_bgp_global(self._execute_globals(device))
@@ -289,6 +312,7 @@ class MeshExecutor:
             target_interface = self._apply_interface_changes(
                 device,
                 direct_pair.device,
+                direct_pair.ports,
                 to_interface_changes(direct_pair.local),
             )
             peers.append(self._to_bgp_peer(direct_pair, target_interface))
@@ -303,7 +327,7 @@ class MeshExecutor:
         for connected_pair in self._execute_indirect(device, all_fqdns):
             peers.append(self._to_bgp_peer(connected_pair, None))
 
-        return MeshExecutionResult(
+        return BgpConfig(
             global_options=global_options,
             peers=peers,
         )

annet/mesh/peer_models.py

@@ -1,6 +1,6 @@
 from typing import Literal, Annotated, Union, Optional
 
-from .basemodel import BaseMeshModel, Concat
+from .basemodel import BaseMeshModel, Concat, Unite
 from ..bgp_models import BFDTimers
 
 FamilyName = Literal["ipv4_unicast", "ipv6_unicast", "ipv4_labeled_unicast", "ipv6_labeled_unicast"]
@@ -25,7 +25,7 @@ class MeshSession(_SharedOptionsDTO):
     """
     asnum: Union[int, str]
     vrf: str
-    families: Annotated[set[FamilyName], Concat()]
+    families: Annotated[set[FamilyName], Unite()]
     group_name: str
 
     bmp_monitor: bool
@@ -116,7 +116,7 @@ class VirtualPeerDTO(MeshSession):
 
 class MeshPeerGroup(_OptionsDTO):
     name: str
-    families: Annotated[set[FamilyName], Concat()]
+    families: Annotated[set[FamilyName], Unite()]
     local_as: Union[int, str]
     remote_as: Union[int, str]
     internal_name: str

annet/mesh/port_processor.py

@@ -0,0 +1,18 @@
+from abc import abstractmethod
+from typing import Protocol, Sequence
+
+PortPair = tuple[str, str]
+
+
+class PortProcessor(Protocol):
+    @abstractmethod
+    def __call__(self, pairs: Sequence[PortPair]) -> Sequence[list[PortPair]]:
+        raise NotImplementedError
+
+
+def united_ports(pairs: Sequence[PortPair]) -> Sequence[list[PortPair]]:
+    return [list(pairs)]
+
+
+def separate_ports(pairs: Sequence[PortPair]) -> Sequence[list[PortPair]]:
+    return [[pair] for pair in pairs]

annet/mesh/registry.py

@@ -5,18 +5,21 @@ from .match_args import MatchExpr, PairMatcher, SingleMatcher
 from .match_args import MatchedArgs
 from .device_models import GlobalOptionsDTO
 from .peer_models import MeshSession, IndirectPeerDTO, VirtualLocalDTO, VirtualPeerDTO, DirectPeerDTO
+from .port_processor import PortProcessor, united_ports
 
 
 class DirectPeer(DirectPeerDTO):
     match: MatchedArgs
     device: Any
     ports: list[str]
+    all_connected_ports: list[str]
 
-    def __init__(self, match: MatchedArgs, device: Any, ports: list[str]) -> None:
+    def __init__(self, match: MatchedArgs, device: Any, ports: list[str], all_connected_ports: list[str]) -> None:
         super().__init__()
         self.match = match
         self.device = device
         self.ports = ports
+        self.all_connected_ports = all_connected_ports
 
 
 class IndirectPeer(IndirectPeerDTO):
@@ -69,9 +72,10 @@ VirtualHandler = Callable[[VirtualLocal, VirtualPeer, MeshSession], None]
 
 @dataclass
 class DirectRule:
-    __slots__ = ("matcher", "handler")
+    __slots__ = ("matcher", "handler", "port_processor")
     matcher: PairMatcher
     handler: DirectHandler
+    port_processor: PortProcessor
 
 
 @dataclass
@@ -98,8 +102,9 @@ class MatchedGlobal:
 
 @dataclass
 class MatchedDirectPair:
-    __slots__ = ("handler", "direct_order", "name_left", "name_right", "match_left", "match_right")
+    __slots__ = ("handler", "port_processor", "direct_order", "name_left", "name_right", "match_left", "match_right")
     handler: DirectHandler
+    port_processor: PortProcessor
     direct_order: bool
     name_left: str
     name_right: str
@@ -154,11 +159,12 @@ class MeshRulesRegistry:
 
     def direct(
             self, left_mask: str, right_mask: str, *match: MatchExpr,
+            port_processor: PortProcessor = united_ports,
     ) -> Callable[[DirectHandler], DirectHandler]:
         matcher = PairMatcher(left_mask, right_mask, match)
 
         def register(handler: DirectHandler) -> DirectHandler:
-            self.direct_rules.append(DirectRule(matcher, handler))
+            self.direct_rules.append(DirectRule(matcher, handler, port_processor))
             return handler
 
         return register
@@ -194,6 +200,7 @@ class MeshRulesRegistry:
                 if args := rule.matcher.match_pair(device, neighbor):
                     found.append(MatchedDirectPair(
                         handler=rule.handler,
+                        port_processor=rule.port_processor,
                         direct_order=True,
                         name_left=device,
                         name_right=neighbor,
@@ -203,6 +210,7 @@ class MeshRulesRegistry:
                 if args := rule.matcher.match_pair(neighbor, device):
                     found.append(MatchedDirectPair(
                         handler=rule.handler,
+                        port_processor=rule.port_processor,
                         direct_order=False,
                         name_left=neighbor,
                         name_right=device,

annet/rpl/match_builder.py

@@ -7,7 +7,9 @@ from .condition import SingleCondition, ConditionOperator, AndCondition
 
 class MatchField(str, Enum):
     community = "community"
-    extcommunity = "extcommunity"
+    large_community = "large_community"
+    extcommunity_rt = "extcommunity_rt"
+    extcommunity_soo = "extcommunity_soo"
     rd = "rd"
     interface = "interface"
     protocol = "protocol"
@@ -63,14 +65,17 @@ class SetConditionFactory(Generic[ValueT]):
 
 @dataclass(frozen=True)
 class PrefixMatchValue:
-    names: Sequence[str]
-    or_longer: Optional[tuple[int, int]]  # ????
+    names: tuple[str, ...]
+    greater_equal: Optional[int]
+    less_equal: Optional[int]
 
 
 class Checkable:
     def __init__(self):
         self.community = SetConditionFactory[str](MatchField.community)
-        self.extcommunity = SetConditionFactory[str](MatchField.extcommunity)
+        self.large_community = SetConditionFactory[str](MatchField.large_community)
+        self.extcommunity_rt = SetConditionFactory[str](MatchField.extcommunity_rt)
+        self.extcommunity_soo = SetConditionFactory[str](MatchField.extcommunity_soo)
         self.rd = SetConditionFactory[str](MatchField.rd)
         self.interface = ConditionFactory[str](MatchField.interface, ["=="])
         self.protocol = ConditionFactory[str](MatchField.protocol, ["=="])
@@ -83,11 +88,27 @@ class Checkable:
     def as_path_filter(self, name: str) -> SingleCondition[str]:
         return SingleCondition(MatchField.as_path_filter, ConditionOperator.EQ, name)
 
-    def match_v6(self, *names: str, or_longer: Optional[tuple[int, int]] = None) -> SingleCondition[PrefixMatchValue]:
-        return SingleCondition(MatchField.ipv6_prefix, ConditionOperator.CUSTOM, PrefixMatchValue(names, or_longer))
-
-    def match_v4(self, *names: str, or_longer: Optional[tuple[int, int]] = None) -> SingleCondition[PrefixMatchValue]:
-        return SingleCondition(MatchField.ip_prefix, ConditionOperator.CUSTOM, PrefixMatchValue(names, or_longer))
+    def match_v6(
+            self,
+            *names: str,
+            or_longer: tuple[Optional[int], Optional[int]] = (None, None),
+    ) -> SingleCondition[PrefixMatchValue]:
+        return SingleCondition(
+            MatchField.ipv6_prefix,
+            ConditionOperator.CUSTOM,
+            PrefixMatchValue(names, greater_equal=or_longer[0], less_equal=or_longer[1]),
+        )
+
+    def match_v4(
+            self,
+            *names: str,
+            or_longer: tuple[Optional[int], Optional[int]] = (None, None),
+    ) -> SingleCondition[PrefixMatchValue]:
+        return SingleCondition(
+            MatchField.ip_prefix,
+            ConditionOperator.CUSTOM,
+            PrefixMatchValue(names, greater_equal=or_longer[0], less_equal=or_longer[1]),
+        )
 
 
 def merge_conditions(and_condition: AndCondition) -> AndCondition: