annet 0.16.25__tar.gz → 0.16.27__tar.gz

{annet-0.16.25/annet.egg-info → annet-0.16.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: annet
-Version: 0.16.25
+Version: 0.16.27
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT
@@ -23,4 +23,4 @@ Requires-Dist: yarl>=1.8.2
 Requires-Dist: adaptix==3.0.0b7
 Requires-Dist: dataclass-rest==0.4
 Provides-Extra: netbox
-Requires-Dist: annetbox[sync]>=0.1.8; extra == "netbox"
+Requires-Dist: annetbox[sync]>=0.1.10; extra == "netbox"

{annet-0.16.25 → annet-0.16.27}/README.md

@@ -1,5 +1,13 @@
 # Annet - configuration generation and deploying utility for network equipment
 
+[![Telegram](https://img.shields.io/badge/💬-Telegram-blue)](https://t.me/annet_sup)
+[![PyPI version](https://badge.fury.io/py/annet.svg)](https://pypi.python.org/pypi/annet)
+[![Downloads](https://img.shields.io/pypi/dm/annet.svg)](https://pypistats.org/packages/annet)
+[![License](https://img.shields.io/github/license/annetutil/annet)](https://github.com/annetutil/annet/blob/master/LICENSE)
+[![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/annetutil/annet/setup.yml)](https://github.com/annetutil/annet/actions)
+[![Doc](https://img.shields.io/github/actions/workflow/status/annetutil/annet/docs.yaml?label=docs)](https://annetutil.github.io/annet)
+
+
 Annet is a configuration generator that can translate differences between old and new configurations into sequence of commands. This feature is vital for CLI-based devices, such as Huawei, Cisco IOS, Cisco NX-OS, Juniper. Devices configured via separate config files, Linux, FreeBSD and Cumulus are also supported.
 
 It works this way. Annet `gen`erates configuration for a device by running Python code, which usually goes to the Network Source of Truth, like NetBox. Annet then gets the `diff`erence by getting the configuration from the device and comparing it. Finally, Annet translates the difference into a sequence of commands, called a `patch`. After `deploy`ing these commands, the diff will be empty.

{annet-0.16.25 → annet-0.16.27}/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-0.16.25 → annet-0.16.27}/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-0.16.25 → annet-0.16.27}/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-0.16.25 → annet-0.16.27}/annet/annlib/patching.py

@@ -54,11 +54,30 @@ class PatchItem:
     row: str
     child: "Union[PatchTree, None]"
     context: Dict[str, str]
+    sort_key: Tuple[Any, ...]
 
-    def __init__(self, row, child, context):
+    def __init__(self, row, child, context, sort_key):
         self.row = row
         self.child = child
         self.context = context
+        self.sort_key = sort_key
+
+    def to_json(self) -> dict[str, Any]:
+        return {
+            "row": self.row,
+            "child": self.child.to_json() if self.child is not None else None,
+            "context": self.context,
+            "sort_key": self.sort_key,
+        }
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "PatchItem":
+        return cls(
+            row=data["row"],
+            child=PatchTree.from_json(data["child"]) if data["child"] is not None else None,
+            context=data["context"],
+            sort_key=data["sort_key"],
+        )
 
     def __str__(self):
         return (
@@ -66,6 +85,7 @@ class PatchItem:
             f'    row="{self.row}",\n'
             f"    child={textwrap.indent(str(self.child), '    ').strip()},\n"
             f"    context={self.context}\n"
+            f"    sort_key={self.sort_key}\n"
             f")"
         )
 
@@ -78,15 +98,15 @@ class PatchTree:
         if row:
             self.add(row, {})
 
-    def add(self, row: str, context: Dict[str, str]) -> None:
-        self.itms.append(PatchItem(row, None, context))
+    def add(self, row: str, context: Dict[str, str], sort_key=()) -> None:
+        self.itms.append(PatchItem(row, None, context, sort_key))
 
-    def add_block(self, row: str, subtree: "Optional[PatchTree]" = None, context: Dict[str, str] = None) -> "PatchTree":
+    def add_block(self, row: str, subtree: "Optional[PatchTree]" = None, context: Dict[str, str] = None, sort_key=()) -> "PatchTree":
         if subtree is None:
             subtree = PatchTree()
         if context is None:
             context = {}
-        self.itms.append(PatchItem(row, subtree, context))
+        self.itms.append(PatchItem(row, subtree, context, sort_key))
         return subtree
 
     def items(self) -> "Iterator[Tuple[str, Union[PatchTree, None]]]":
@@ -106,6 +126,21 @@ class PatchTree:
                 ret[str(row)] = None
         return ret
 
+    def to_json(self) -> list[dict[str, Any]]:
+        return [i.to_json() for i in self.itms]
+
+    @classmethod
+    def from_json(cls, data: list[dict[str, Any]]) -> "PatchTree":
+        ret = cls()
+        ret.itms = [PatchItem.from_json(i) for i in data]
+        return ret
+
+    def sort(self) -> None:
+        self.itms.sort(key=operator.attrgetter("sort_key"))
+        for item in self.itms:
+            if item.child:
+                item.child.sort()
+
     def __bool__(self):
         return bool(self.itms)
 
@@ -409,18 +444,19 @@ def make_patch(pre, rb, hw, add_comments, orderer=None, _root_pre=None, do_commi
                         "context": attrs["context"],
                     })
     tree = PatchTree()
-    sorted_patch = sorted(patch, key=(lambda item: (
-        (item["order"] if item["order_direct"] else -item["order"]),
-        item["raw_rule"],
-        item["order_direct"],
-    )))
-    for item in sorted_patch:
+    for item in patch:
+        sort_key = (
+            (item["order"] if item["order_direct"] else -item["order"]),
+            item["raw_rule"],
+            item["order_direct"],
+        )
         if (not item["children"] and not item["parent"]) or not item["direct"]:
-            tree.add(item["row"], item["context"])
+            tree.add(item["row"], item["context"], sort_key)
         else:
-            tree.add_block(item["row"], item["children"], item["context"])
+            tree.add_block(item["row"], item["children"], item["context"], sort_key)
         if item["force_commit"]:
-            tree.add("commit", item["context"])
+            tree.add("commit", item["context"], sort_key)
+    tree.sort()
     return tree
 
 

{annet-0.16.25 → annet-0.16.27}/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-0.16.25 → annet-0.16.27}/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-0.16.25 → annet-0.16.27}/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-0.16.25 → annet-0.16.27}/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-0.16.25 → annet-0.16.27}/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-0.16.25 → annet-0.16.27}/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-0.16.27/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]