annet 3.5.0__py3-none-any.whl → 3.6.0__py3-none-any.whl

annet/adapters/netbox/common/adapter.py

@@ -1,14 +1,19 @@
 from abc import abstractmethod, ABC
-from typing import Protocol, Generic, TypeVar
+from typing import Generic, TypeVar
 
 from annet.annlib.netdev.views.hardware import HardwareView
 from .manufacturer import get_breed, get_hw
-from .models import NetboxDevice, Interface, IpAddress, Prefix
+from .models import NetboxDevice, Interface, IpAddress, Prefix, \
+    FHRPGroupAssignment, FHRPGroup
 
 NetboxDeviceT = TypeVar("NetboxDeviceT", bound=NetboxDevice)
 InterfaceT = TypeVar("InterfaceT", bound=Interface)
 IpAddressT = TypeVar("IpAddressT", bound=IpAddress)
 PrefixT = TypeVar("PrefixT", bound=Prefix)
+FHRPGroupT = TypeVar("FHRPGroupT", bound=FHRPGroup)
+FHRPGroupAssignmentT = TypeVar(
+    "FHRPGroupAssignmentT", bound=FHRPGroupAssignment,
+)
 
 
 def get_device_breed(device: NetboxDeviceT) -> str:
@@ -30,7 +35,17 @@ def get_device_hw(device: NetboxDeviceT) -> HardwareView:
     return HardwareView("", "")
 
 
-class NetboxAdapter(ABC, Generic[NetboxDeviceT, InterfaceT, IpAddressT, PrefixT]):
+class NetboxAdapter(
+    ABC,
+    Generic[
+        NetboxDeviceT,
+        InterfaceT,
+        IpAddressT,
+        PrefixT,
+        FHRPGroupT,
+        FHRPGroupAssignmentT,
+    ],
+):
     @abstractmethod
     def list_all_fqdns(self) -> list[str]:
         raise NotImplementedError()
@@ -58,3 +73,15 @@ class NetboxAdapter(ABC, Generic[NetboxDeviceT, InterfaceT, IpAddressT, PrefixT]
     @abstractmethod
     def list_ipprefixes(self, prefixes: list[str]) -> list[PrefixT]:
         raise NotImplementedError()
+
+    @abstractmethod
+    def list_fhrp_group_assignments(
+            self, iface_ids: list[int],
+    ) -> list[FHRPGroupAssignmentT]:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def list_fhrp_groups(
+            self, ids: list[int],
+    ) -> list[FHRPGroupT]:
+        raise NotImplementedError()

annet/adapters/netbox/common/manufacturer.py

@@ -14,30 +14,31 @@ def get_hw(manufacturer: str, model: str, platform_name: str):
 
 
 def get_breed(manufacturer: str, model: str):
-    if manufacturer == "Huawei" and model.startswith("CE"):
+    hw = get_hw(manufacturer, model, "")
+    if hw.Huawei.CE:
         return "vrp85"
-    elif manufacturer == "Huawei" and model.startswith("NE"):
+    elif hw.Huawei.NE:
         return "vrp85"
-    elif manufacturer == "Huawei":
+    elif hw.Huawei:
         return "vrp55"
-    elif manufacturer == "H3C":
+    elif hw.H3C:
         return "h3c"
-    elif manufacturer in ("Mellanox", "NVIDIA"):
+    elif hw.PC.NVIDIA or hw.PC.Mellanox:
         return "cuml2"
-    elif manufacturer == "Juniper":
+    elif hw.Juniper:
         return "jun10"
-    elif manufacturer == "Cisco":
+    elif hw.Cisco.Nexus:
+        return "nxos"
+    elif hw.Cisco:
         return "ios12"
-    elif manufacturer == "Adva":
-        return "adva8"
-    elif manufacturer == "Arista":
+    elif hw.Arista:
         return "eos4"
-    elif manufacturer == "B4com":
+    elif hw.B4com:
         return "bcom-os"
-    elif manufacturer == "MikroTik":
+    elif hw.RouterOS:
         return "routeros"
-    elif manufacturer in ("Moxa", "Nebius"):
+    elif hw.PC.Moxa or hw.PC.Nebius:
         return "moxa"
-    elif manufacturer == "PC":
+    elif hw.PC:
         return "pc"
     return ""

annet/adapters/netbox/common/models.py

@@ -49,7 +49,6 @@ class DeviceIp(DumpableView):
     id: int
     display: str
     address: str
-    family: int
 
     @property
     def _dump__list_key(self):
@@ -131,8 +130,49 @@ def vrf_object(vrf: str | None) -> Entity | None:
 _IpAddressT = TypeVar("_IpAddressT", bound=IpAddress)
 
 
+_DeviceIPT = TypeVar("_DeviceIPT", bound=DeviceIp)
+
+
+@dataclass
+class FHRPGroup(Generic[_DeviceIPT]):
+    id: int
+    group_id: int
+    display: str
+    protocol: str
+    description: str
+
+    name: str
+    auth_type: str | None
+    auth_key: str
+    tags: list[EntityWithSlug]
+    custom_fields: dict[str, Any]
+    ip_addresses: list[_DeviceIPT]
+    comments: str | None = None
+
+
+_FHRPGroupT = TypeVar("_FHRPGroupT", bound=FHRPGroup)
+
+
+@dataclass
+class FHRPGroupAssignment(Generic[_FHRPGroupT]):
+    id: int
+    display: str
+    priority: int
+    group: _FHRPGroupT
+    fhrp_group_id: int
+
+    interface_type: str | None
+    interface_id: int | None
+
+
+_FHRPGroupAssignmentT = TypeVar(
+    "_FHRPGroupAssignmentT",
+    bound=FHRPGroupAssignment,
+)
+
+
 @dataclass
-class Interface(Entity, Generic[_IpAddressT]):
+class Interface(Entity, Generic[_IpAddressT, _FHRPGroupAssignmentT]):
     device: Entity
     enabled: bool
     description: str
@@ -143,13 +183,17 @@ class Interface(Entity, Generic[_IpAddressT]):
     tagged_vlans: Optional[List[InterfaceVlan]]
     tags: List[EntityWithSlug] = field(default_factory=list)
     display: str = ""
-    ip_addresses: List[_IpAddressT] = field(default_factory=list)
     vrf: Optional[Entity] = None
     mtu: int | None = None
     lag: Entity | None = None
     lag_min_links: int | None = None
     speed: int | None = None
 
+    ip_addresses: List[_IpAddressT] = field(default_factory=list)
+    count_ipaddresses: int = 0
+    fhrp_groups: List[_FHRPGroupAssignmentT] = field(default_factory=list)
+    count_fhrp_groups: int = 0
+
     def add_addr(self, address_mask: str, vrf: str | None) -> None:
         addr = ip_interface(address_mask)
 
@@ -183,7 +227,7 @@ _InterfaceT = TypeVar("_InterfaceT", bound=Interface)
 
 
 @dataclass
-class NetboxDevice(Entity, Generic[_InterfaceT]):
+class NetboxDevice(Entity, Generic[_InterfaceT, _DeviceIPT]):
     url: str
     storage: Storage
 
@@ -199,14 +243,16 @@ class NetboxDevice(Entity, Generic[_InterfaceT]):
     position: Optional[float]
     face: Optional[Label]
     status: Label
-    primary_ip: Optional[DeviceIp]
-    primary_ip4: Optional[DeviceIp]
-    primary_ip6: Optional[DeviceIp]
+    primary_ip: Optional[_DeviceIPT]
+    primary_ip4: Optional[_DeviceIPT]
+    primary_ip6: Optional[_DeviceIPT]
     tags: List[EntityWithSlug]
     custom_fields: Dict[str, Any]
     created: datetime
     last_updated: datetime
     cluster: Optional[Entity]
+    config_context: Optional[dict[str, Any]]
+    config_template: Optional[dict[str, Any]]
 
     fqdn: str
     hostname: str

annet/adapters/netbox/common/storage_base.py

@@ -9,13 +9,19 @@ from annet.adapters.netbox.common.query import NetboxQuery, FIELD_VALUE_SEPARATO
 from annet.adapters.netbox.common.storage_opts import NetboxStorageOpts
 from annet.storage import Storage
 from .adapter import NetboxAdapter
-from .models import IpAddress, Interface, NetboxDevice, Prefix
+from .models import (
+    IpAddress, Interface, NetboxDevice, Prefix, FHRPGroup, FHRPGroupAssignment,
+)
 
 logger = getLogger(__name__)
 NetboxDeviceT = TypeVar("NetboxDeviceT", bound=NetboxDevice)
 InterfaceT = TypeVar("InterfaceT", bound=Interface)
 IpAddressT = TypeVar("IpAddressT", bound=IpAddress)
 PrefixT = TypeVar("PrefixT", bound=Prefix)
+FHRPGroupT = TypeVar("FHRPGroupT", bound=FHRPGroup)
+FHRPGroupAssignmentT = TypeVar(
+    "FHRPGroupAssignmentT", bound=FHRPGroupAssignment,
+)
 
 
 class BaseNetboxStorage(
@@ -25,6 +31,8 @@ class BaseNetboxStorage(
         InterfaceT,
         IpAddressT,
         PrefixT,
+        FHRPGroupT,
+        FHRPGroupAssignmentT,
     ],
 ):
     """
@@ -58,7 +66,7 @@ class BaseNetboxStorage(
             token: str,
             ssl_context: Optional[ssl.SSLContext],
             threads: int,
-    ) -> NetboxAdapter[NetboxDeviceT, InterfaceT, IpAddressT, PrefixT]:
+    ) -> NetboxAdapter[NetboxDeviceT, InterfaceT, IpAddressT, PrefixT, FHRPGroupT, FHRPGroupAssignmentT]:
         raise NotImplementedError()
 
     def __enter__(self):
@@ -129,10 +137,22 @@ class BaseNetboxStorage(
         interfaces = self.netbox.list_interfaces_by_devices(list(device_mapping))
         for interface in interfaces:
             device_mapping[interface.device.id].interfaces.append(interface)
+        self._fill_interface_fhrp_groups(interfaces)
         self._fill_interface_ipaddress(interfaces)
 
+    def _fill_interface_fhrp_groups(self, interfaces: list[InterfaceT]) -> None:
+        interface_mapping = {i.id: i for i in interfaces if i.count_fhrp_groups}
+        assignments = self.netbox.list_fhrp_group_assignments(list(interface_mapping))
+        group_ids = {r.fhrp_group_id for r in assignments}
+        groups = {
+            g.id: g for g in self.netbox.list_fhrp_groups(list(group_ids))
+        }
+        for assignment in assignments:
+            assignment.group = groups[assignment.fhrp_group_id]
+            interface_mapping[assignment.interface_id].fhrp_groups.append(assignment)
+
     def _fill_interface_ipaddress(self, interfaces: list[InterfaceT]) -> None:
-        interface_mapping = {i.id: i for i in interfaces}
+        interface_mapping = {i.id: i for i in interfaces if i.count_ipaddresses}
         ips = self.netbox.list_ipaddr_by_ifaces(list(interface_mapping))
         for ip in ips:
             interface_mapping[ip.assigned_object_id].ip_addresses.append(ip)

annet/adapters/netbox/v37/models.py

@@ -3,10 +3,16 @@ from datetime import datetime, timezone
 from typing import Optional
 
 from annet.adapters.netbox.common.models import (
-    IpAddress, NetboxDevice, Entity, Prefix, InterfaceType, Interface, IpFamily, Label,
+    IpAddress, NetboxDevice, Entity, Prefix, InterfaceType, Interface,
+    IpFamily, Label, FHRPGroupAssignment, DeviceIp, FHRPGroup,
 )
 
 
+@dataclass
+class DeviceIpV37(DeviceIp):
+    family: int
+
+
 @dataclass
 class PrefixV37(Prefix):
     site: Optional[Entity] = None
@@ -18,7 +24,17 @@ class IpAddressV37(IpAddress[PrefixV37]):
 
 
 @dataclass
-class InterfaceV37(Interface[IpAddressV37]):
+class FHRPGroupV37(FHRPGroup[DeviceIpV37]):
+    pass
+
+
+@dataclass
+class FHRPGroupAssignmentV37(FHRPGroupAssignment[FHRPGroupV37]):
+    pass
+
+
+@dataclass
+class InterfaceV37(Interface[IpAddressV37, FHRPGroupAssignmentV37]):
     def _add_new_addr(self, address_mask: str, vrf: Entity | None, family: IpFamily) -> None:
         self.ip_addresses.append(IpAddressV37(
             id=0,
@@ -36,7 +52,7 @@ class InterfaceV37(Interface[IpAddressV37]):
 
 
 @dataclass
-class NetboxDeviceV37(NetboxDevice[InterfaceV37]):
+class NetboxDeviceV37(NetboxDevice[InterfaceV37, DeviceIpV37]):
     device_role: Entity
 
     def __hash__(self):

annet/adapters/netbox/v37/storage.py

@@ -7,10 +7,15 @@ from annetbox.v37 import models as api_models, client_sync
 from annet.adapters.netbox.common.adapter import NetboxAdapter, get_device_breed, get_device_hw
 from annet.adapters.netbox.common.storage_base import BaseNetboxStorage
 from annet.storage import Storage
-from .models import IpAddressV37, NetboxDeviceV37, InterfaceV37, PrefixV37
+from .models import (
+    IpAddressV37, NetboxDeviceV37, InterfaceV37, PrefixV37,
+    FHRPGroupAssignmentV37, FHRPGroupV37,
+)
 
 
-class NetboxV37Adapter(NetboxAdapter[NetboxDeviceV37, InterfaceV37, IpAddressV37, PrefixV37]):
+class NetboxV37Adapter(NetboxAdapter[
+    NetboxDeviceV37, InterfaceV37, IpAddressV37, PrefixV37, FHRPGroupV37, FHRPGroupAssignmentV37,
+]):
     def __init__(
             self,
             storage: Storage,
@@ -37,6 +42,7 @@ class NetboxV37Adapter(NetboxAdapter[NetboxDeviceV37, InterfaceV37, IpAddressV37
             list[InterfaceV37],
             recipe=[
                 link_constant(P[InterfaceV37].ip_addresses, factory=list),
+                link_constant(P[InterfaceV37].fhrp_groups, factory=list),
                 link_constant(P[InterfaceV37].lag_min_links, value=None),
             ]
         )
@@ -51,6 +57,18 @@ class NetboxV37Adapter(NetboxAdapter[NetboxDeviceV37, InterfaceV37, IpAddressV37
             list[api_models.Prefix],
             list[PrefixV37],
         )
+        self.convert_fhrp_group_assignments = get_converter(
+            list[api_models.FHRPGroupAssignmentBrief],
+            list[FHRPGroupAssignmentV37],
+            recipe=[
+                link_constant(P[FHRPGroupAssignmentV37].group, value=None),
+                link_function(lambda model: model.group.id, P[FHRPGroupAssignmentV37].fhrp_group_id),
+            ]
+        )
+        self.convert_fhrp_groups = get_converter(
+            list[api_models.FHRPGroup],
+            list[FHRPGroupV37],
+        )
 
     def list_all_fqdns(self) -> list[str]:
         return [
@@ -79,13 +97,27 @@ class NetboxV37Adapter(NetboxAdapter[NetboxDeviceV37, InterfaceV37, IpAddressV37
     def list_ipprefixes(self, prefixes: list[str]) -> list[PrefixV37]:
         return self.convert_ip_prefixes(self.netbox.ipam_all_prefixes(prefix=prefixes).results)
 
+    def list_fhrp_group_assignments(
+            self, iface_ids: list[int],
+    ) -> list[FHRPGroupAssignmentV37]:
+        raw_assignments = self.netbox.ipam_all_fhrp_group_assignments_by_interface(
+            interface_id=iface_ids,
+        )
+        return self.convert_fhrp_group_assignments(raw_assignments.results)
+
+    def list_fhrp_groups(self, ids: list[int]) -> list[FHRPGroupV37]:
+        raw_groups = self.netbox.ipam_all_fhrp_groups_by_id(id=list(ids))
+        return self.convert_fhrp_groups(raw_groups.results)
+
 
-class NetboxStorageV37(BaseNetboxStorage[NetboxDeviceV37, InterfaceV37, IpAddressV37, PrefixV37]):
+class NetboxStorageV37(BaseNetboxStorage[
+    NetboxDeviceV37, InterfaceV37, IpAddressV37, PrefixV37, FHRPGroupV37, FHRPGroupAssignmentV37,
+]):
     def _init_adapter(
             self,
             url: str,
             token: str,
             ssl_context: ssl.SSLContext | None,
             threads: int,
-    ) -> NetboxAdapter[NetboxDeviceV37, InterfaceV37, IpAddressV37, PrefixV37]:
+    ) -> NetboxAdapter[NetboxDeviceV37, InterfaceV37, IpAddressV37, PrefixV37, FHRPGroupV37, FHRPGroupAssignmentV37]:
         return NetboxV37Adapter(self, url, token, ssl_context, threads)

annet/adapters/netbox/v41/models.py

@@ -2,7 +2,9 @@ from dataclasses import dataclass
 from typing import Optional
 import warnings
 from datetime import datetime, timezone
-from annet.adapters.netbox.common.models import Entity, Interface, InterfaceType, IpAddress, Label, NetboxDevice, DeviceIp, IpFamily, Prefix
+from annet.adapters.netbox.common.models import Entity, Interface, \
+    InterfaceType, IpAddress, Label, NetboxDevice, DeviceIp, IpFamily, Prefix, \
+    FHRPGroupAssignment, FHRPGroup
 
 
 @dataclass
@@ -16,7 +18,22 @@ class IpAddressV41(IpAddress[PrefixV41]):
 
 
 @dataclass
-class InterfaceV41(Interface[IpAddressV41]):
+class DeviceIpV41(DeviceIp):
+    family: IpFamily
+
+
+@dataclass
+class FHRPGroupV41(FHRPGroup[DeviceIpV41]):
+    pass
+
+
+@dataclass
+class FHRPGroupAssignmentV41(FHRPGroupAssignment[FHRPGroupV41]):
+    pass
+
+
+@dataclass
+class InterfaceV41(Interface[IpAddressV41, FHRPGroupAssignmentV41]):
     def _add_new_addr(self, address_mask: str, vrf: Entity | None, family: IpFamily) -> None:
         self.ip_addresses.append(IpAddressV41(
             id=0,
@@ -34,19 +51,8 @@ class InterfaceV41(Interface[IpAddressV41]):
 
 
 @dataclass
-class DeviceIpV41(DeviceIp):
-    id: int
-    display: str
-    address: str
-    family: IpFamily
-
-
-@dataclass
-class NetboxDeviceV41(NetboxDevice[InterfaceV41]):
+class NetboxDeviceV41(NetboxDevice[InterfaceV41, DeviceIpV41]):
     role: Entity
-    primary_ip: Optional[DeviceIpV41]
-    primary_ip4: Optional[DeviceIpV41]
-    primary_ip6: Optional[DeviceIpV41]
 
     @property
     def device_role(self):

annet/adapters/netbox/v41/storage.py

@@ -6,11 +6,17 @@ from annetbox.v41 import models as api_models
 
 from annet.adapters.netbox.common.adapter import NetboxAdapter, get_device_breed, get_device_hw
 from annet.adapters.netbox.common.storage_base import BaseNetboxStorage
-from annet.adapters.netbox.v41.models import InterfaceV41, IpAddressV41, NetboxDeviceV41, PrefixV41
+from annet.adapters.netbox.v41.models import (
+    InterfaceV41, IpAddressV41, NetboxDeviceV41, PrefixV41,
+    FHRPGroupV41, FHRPGroupAssignmentV41,
+)
 from annet.storage import Storage
 
 
-class NetboxV41Adapter(NetboxAdapter[NetboxDeviceV41, InterfaceV41, IpAddressV41, PrefixV41]):
+class NetboxV41Adapter(NetboxAdapter[
+    NetboxDeviceV41, InterfaceV41, IpAddressV41, PrefixV41,
+    FHRPGroupV41, FHRPGroupAssignmentV41
+]):
     def __init__(
             self,
             storage: Storage,
@@ -37,6 +43,7 @@ class NetboxV41Adapter(NetboxAdapter[NetboxDeviceV41, InterfaceV41, IpAddressV41
             list[InterfaceV41],
             recipe=[
                 link_constant(P[InterfaceV41].ip_addresses, factory=list),
+                link_constant(P[InterfaceV41].fhrp_groups, factory=list),
                 link_constant(P[InterfaceV41].lag_min_links, value=None),
             ]
         )
@@ -51,6 +58,18 @@ class NetboxV41Adapter(NetboxAdapter[NetboxDeviceV41, InterfaceV41, IpAddressV41
             list[api_models.Prefix],
             list[PrefixV41],
         )
+        self.convert_fhrp_group_assignments = get_converter(
+            list[api_models.FHRPGroupAssignmentBrief],
+            list[FHRPGroupAssignmentV41],
+            recipe=[
+                link_constant(P[FHRPGroupAssignmentV41].group, value=None),
+                link_function(lambda model: model.group.id, P[FHRPGroupAssignmentV41].fhrp_group_id),
+            ]
+        )
+        self.convert_fhrp_groups = get_converter(
+            list[api_models.FHRPGroup],
+            list[FHRPGroupV41],
+        )
 
     def list_all_fqdns(self) -> list[str]:
         return [
@@ -79,13 +98,28 @@ class NetboxV41Adapter(NetboxAdapter[NetboxDeviceV41, InterfaceV41, IpAddressV41
     def list_ipprefixes(self, prefixes: list[str]) -> list[PrefixV41]:
         return self.convert_ip_prefixes(self.netbox.ipam_all_prefixes(prefix=prefixes).results)
 
+    def list_fhrp_group_assignments(
+            self, iface_ids: list[int],
+    ) -> list[FHRPGroupAssignmentV41]:
+        raw_assignments = self.netbox.ipam_all_fhrp_group_assignments_by_interface(
+            interface_id=iface_ids,
+        )
+        return self.convert_fhrp_group_assignments(raw_assignments.results)
+
+    def list_fhrp_groups(self, ids: list[int]) -> list[FHRPGroupV41]:
+        raw_groups = self.netbox.ipam_all_fhrp_groups_by_id(id=list(ids))
+        return self.convert_fhrp_groups(raw_groups.results)
+
 
-class NetboxStorageV41(BaseNetboxStorage[NetboxDeviceV41, InterfaceV41, IpAddressV41, PrefixV41]):
+class NetboxStorageV41(BaseNetboxStorage[
+    NetboxDeviceV41, InterfaceV41, IpAddressV41, PrefixV41,
+    FHRPGroupV41, FHRPGroupAssignmentV41
+]):
     def _init_adapter(
             self,
             url: str,
             token: str,
             ssl_context: ssl.SSLContext | None,
             threads: int,
-    ) -> NetboxAdapter[NetboxDeviceV41, InterfaceV41, IpAddressV41, PrefixV41]:
+    ) -> NetboxAdapter[NetboxDeviceV41, InterfaceV41, IpAddressV41, PrefixV41, FHRPGroupV41, FHRPGroupAssignmentV41]:
         return NetboxV41Adapter(self, url, token, ssl_context, threads)

annet/adapters/netbox/v42/models.py

@@ -1,8 +1,10 @@
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Optional
-from annet.adapters.netbox.common.models import InterfaceType, IpFamily, Label, Prefix, Entity
-from annet.adapters.netbox.v41.models import InterfaceV41, IpAddressV41, NetboxDeviceV41
+from annet.adapters.netbox.common.models import InterfaceType, IpFamily, Label, \
+    Prefix, Entity, Interface, IpAddress
+from annet.adapters.netbox.v41.models import InterfaceV41, IpAddressV41, \
+    NetboxDeviceV41, FHRPGroupAssignmentV41
 import annetbox.v42.models
 
 
@@ -19,12 +21,12 @@ class PrefixV42(Prefix):
 
 
 @dataclass
-class IpAddressV42(IpAddressV41):
+class IpAddressV42(IpAddress[PrefixV42]):
     prefix: Optional[PrefixV42] = None
 
 
 @dataclass
-class InterfaceV42(InterfaceV41):
+class InterfaceV42(Interface[IpAddressV42, FHRPGroupAssignmentV41]):
     def _add_new_addr(self, address_mask: str, vrf: Entity | None, family: IpFamily) -> None:
         self.ip_addresses.append(IpAddressV42(
             id=0,

annet/adapters/netbox/v42/storage.py

@@ -9,11 +9,15 @@ from annetbox.v42 import models as api_models
 from annet.adapters.netbox.common.adapter import NetboxAdapter, get_device_breed, get_device_hw
 from annet.adapters.netbox.common.storage_base import BaseNetboxStorage
 from annet.adapters.netbox.common.storage_opts import NetboxStorageOpts
+from annet.adapters.netbox.v41.models import FHRPGroupAssignmentV41, FHRPGroupV41
 from annet.adapters.netbox.v42.models import InterfaceV42, NetboxDeviceV42, PrefixV42, IpAddressV42, Vlan, Vrf
 from annet.storage import Storage
 
 
-class NetboxV42Adapter(NetboxAdapter[NetboxDeviceV42, InterfaceV42, IpAddressV42, PrefixV42]):
+class NetboxV42Adapter(NetboxAdapter[
+    NetboxDeviceV42, InterfaceV42, IpAddressV42, PrefixV42,
+    FHRPGroupV41, FHRPGroupAssignmentV41,
+]):
     def __init__(
             self,
             storage: Storage,
@@ -40,6 +44,7 @@ class NetboxV42Adapter(NetboxAdapter[NetboxDeviceV42, InterfaceV42, IpAddressV42
             list[InterfaceV42],
             recipe=[
                 link_constant(P[InterfaceV42].ip_addresses, factory=list),
+                link_constant(P[InterfaceV42].fhrp_groups, factory=list),
                 link_constant(P[InterfaceV42].lag_min_links, value=None),
             ]
         )
@@ -54,6 +59,18 @@ class NetboxV42Adapter(NetboxAdapter[NetboxDeviceV42, InterfaceV42, IpAddressV42
             list[api_models.Prefix],
             list[PrefixV42],
         )
+        self.convert_fhrp_group_assignments = get_converter(
+            list[api_models.FHRPGroupAssignmentBrief],
+            list[FHRPGroupAssignmentV41],
+            recipe=[
+                link_constant(P[FHRPGroupAssignmentV41].group, value=None),
+                link_function(lambda model: model.group.id, P[FHRPGroupAssignmentV41].fhrp_group_id),
+            ]
+        )
+        self.convert_fhrp_groups = get_converter(
+            list[api_models.FHRPGroup],
+            list[FHRPGroupV41],
+        )
 
     def list_all_fqdns(self) -> list[str]:
         return [
@@ -88,8 +105,23 @@ class NetboxV42Adapter(NetboxAdapter[NetboxDeviceV42, InterfaceV42, IpAddressV42
     def list_all_vlans(self) -> list[Vlan]:
         return self.netbox.ipam_all_vlans().results
 
+    def list_fhrp_group_assignments(
+            self, iface_ids: list[int],
+    ) -> list[FHRPGroupAssignmentV41]:
+        raw_assignments = self.netbox.ipam_all_fhrp_group_assignments_by_interface(
+            interface_id=iface_ids,
+        )
+        return self.convert_fhrp_group_assignments(raw_assignments.results)
+
+    def list_fhrp_groups(self, ids: list[int]) -> list[FHRPGroupV41]:
+        raw_groups = self.netbox.ipam_all_fhrp_groups_by_id(id=list(ids))
+        return self.convert_fhrp_groups(raw_groups.results)
+
 
-class NetboxStorageV42(BaseNetboxStorage[NetboxDeviceV42, InterfaceV42, IpAddressV42, PrefixV42]):
+class NetboxStorageV42(BaseNetboxStorage[
+    NetboxDeviceV42, InterfaceV42, IpAddressV42, PrefixV42,
+    FHRPGroupV41, FHRPGroupAssignmentV41,
+]):
     netbox: NetboxV42Adapter
 
     def __init__(self, opts: Optional[NetboxStorageOpts] = None):
@@ -103,7 +135,10 @@ class NetboxStorageV42(BaseNetboxStorage[NetboxDeviceV42, InterfaceV42, IpAddres
             token: str,
             ssl_context: ssl.SSLContext | None,
             threads: int,
-    ) -> NetboxAdapter[NetboxDeviceV42, InterfaceV42, IpAddressV42, PrefixV42]:
+    ) -> NetboxAdapter[
+        NetboxDeviceV42, InterfaceV42, IpAddressV42, PrefixV42,
+        FHRPGroupV41, FHRPGroupAssignmentV41,
+    ]:
         return NetboxV42Adapter(self, url, token, ssl_context, threads)
 
     def resolve_all_vlans(self) -> list[Vlan]:

annet/annlib/command.py

@@ -12,6 +12,7 @@ class Question:
     question: str  # frame it using / if it is a regular expression
     answer: str
     is_regexp: Optional[bool] = False
+    not_send_nl: bool = False
 
 
 @dataclass

annet/annlib/rulebook/common.py

@@ -10,7 +10,7 @@ from annet.vendors import registry_connector
 # =====
 def default(rule, key, diff, **_):
     r"""
-        Функция default() обеспичвает базовую логику обработки всех правил. Ее можно заменить с помощью
+        Функция default() обеспечивает базовую логику обработки всех правил. Ее можно заменить с помощью
         параметра %logic в текстовом рулбуке. Она вызывается для каждой команды с уникальным ключом и
         должна возвратить сгенерированный текст патча на основе предоставленного диффа, и, при необходимости,
         вызвать обработку дочерних правил/данных.
@@ -49,8 +49,8 @@ def default(rule, key, diff, **_):
     """
     for op in [Op.ADDED, Op.REMOVED, Op.AFFECTED, Op.MOVED]:
         # Дефолтная функция генерации патчей считает, что не бывает команд с одинаковыми
-        # ключами и разным значением. при этом unchanged мы так не проверяем поскольку
-        # такие случаи возможны когда у нас подмешиваются implicit команды
+        # ключами и разным значением. При этом unchanged мы так не проверяем, поскольку
+        # такие случаи возможны, когда у нас подмешиваются implicit команды
         assert 0 <= len(diff[op]) <= 1, "Too many %s actions for rows %r" % (op, [x["row"] for x in diff[op]])
     if diff[Op.AFFECTED]:
         # При изменении блока нужно вызвать обработку чилдов
@@ -60,7 +60,7 @@ def default(rule, key, diff, **_):
         # При модификации строки удаление нас не интересует, добавление проходит как affected
         yield (True, diff[key][0]["row"], diff[key][0]["children"])
     elif diff[Op.REMOVED]:
-        # При удалении или перемещеннии блока просто снести строку
+        # При удалении или перемещении блока просто снести строку
         yield (False, rule["reverse"].format(*key), None)
 
 
@@ -179,7 +179,7 @@ def multiline_diff(old: odict, new: odict, diff_pre: odict, _pops: tuple[Op, ...
     Особая логика diff'a для хуавейных мультилайнов.
     Она трактует все дочерние элементы %multiline-команды как
     одну общую команду, покидывая внутрь тот Op который был
-    определен на вернем уровне
+    определен на верхнем уровне
     """
 
     def process_multiline(op, tree):