annet 2.6.0__tar.gz → 3.1.0__tar.gz

{annet-2.6.0/annet.egg-info → annet-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: annet
-Version: 2.6.0
+Version: 3.1.0
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-2.6.0 → annet-3.1.0}/annet/__init__.py

@@ -7,14 +7,15 @@ from argparse import SUPPRESS, Namespace
 
 import colorama
 import yaml
-from annet.annlib.errors import (  # pylint: disable=wrong-import-position
-    DeployCancelled,
-    ExecError,
-)
 from contextlog import patch_logging, patch_threading
 from valkit.python import valid_logging_level
 
 import annet.argparse
+from annet.annlib import tabparser  # pylint: disable=unused-import
+from annet.annlib.errors import (  # pylint: disable=wrong-import-position
+    DeployCancelled,
+    ExecError,
+)
 
 
 __all__ = ("DeployCancelled", "ExecError")

{annet-2.6.0 → annet-3.1.0}/annet/adapters/file/provider.py

@@ -1,13 +1,16 @@
-from annet.annlib.netdev.views.dump import DumpableView
-from annet.storage import Query
+import dataclasses
 from dataclasses import dataclass, fields
-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
-from annet.annlib.netdev.views.hardware import vendor_to_hw, HardwareView
+from typing import Any, Iterable, List, Optional, Sequence
+
 import yaml
 
+from annet.annlib.netdev.views.dump import DumpableView
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.connectors import AdapterWithName
+from annet.hardware import hardware_connector
+from annet.storage import Device as DeviceProtocol
+from annet.storage import Query, Storage, StorageProvider
+
 
 @dataclass
 class Interface(DumpableView):
@@ -23,29 +26,46 @@ class Interface(DumpableView):
 @dataclass
 class DeviceStorage:
     fqdn: str
-    vendor: str
+
+    vendor: Optional[str] = None
+    hw_model: Optional[str] = None
+    sw_version: Optional[str] = None
+
     hostname: Optional[str] = None
     serial: Optional[str] = None
     id: Optional[str] = None
     interfaces: Optional[list[Interface]] = None
     storage: Optional[Storage] = None
 
+    hw: HardwareView = dataclasses.field(init=False)
+
     def __post_init__(self):
         if not self.id:
             self.id = self.fqdn
         if not self.hostname:
             self.hostname = self.fqdn.split(".")[0]
-        hw = vendor_to_hw(self.vendor)
-        if not hw:
-            raise Exception("unknown vendor")
+
+        if self.hw_model:
+            hw = HardwareView(self.hw_model, self.sw_version)
+            if self.vendor and self.vendor != hw.vendor:
+                raise Exception(f"Vendor {self.vendor} is not vendor from hw model ({hw.vendor})")
+            else:
+                self.vendor = hw.vendor
+        else:
+            hw_provider = hardware_connector.get()
+            hw: HardwareView = hw_provider.vendor_to_hw(self.vendor)
+            if not hw:
+                raise Exception("unknown vendor")
+            self.hw_model = hw.model
         self.hw = hw
+
         if isinstance(self.interfaces, list):
             interfaces = []
             for iface in self.interfaces:
                 try:
                     interfaces.append(Interface(**iface))
                 except Exception as e:
-                    raise Exception("unable to parse %s as Interface %s" % (iface, e))
+                    raise Exception("unable to parse %s as Interface: %s" % (iface, e))
             self.interfaces = interfaces
 
     def set_storage(self, storage: Storage):
@@ -53,7 +73,7 @@ class DeviceStorage:
 
 
 @dataclass
-class Device(DeviceCls, DumpableView):
+class Device(DeviceProtocol, DumpableView):
     dev: DeviceStorage
 
     def __hash__(self):
@@ -79,7 +99,7 @@ class Device(DeviceCls, DumpableView):
 
     @property
     def storage(self) -> Storage:
-        return self
+        return self.dev.storage
 
     @property
     def hw(self) -> HardwareView:
@@ -91,7 +111,11 @@ class Device(DeviceCls, DumpableView):
 
     @property
     def neighbours_ids(self):
-        pass
+        return []
+
+    @property
+    def neighbours_fqdns(self) -> list[str]:
+        return []
 
     def make_lag(self, lag: int, ports: Sequence[str], lag_min_links: Optional[int]) -> Interface:
         raise NotImplementedError
@@ -105,8 +129,8 @@ class Device(DeviceCls, DumpableView):
     def find_interface(self, name: str) -> Optional[Interface]:
         raise NotImplementedError
 
-    def neighbours_fqdns(self) -> list[str]:
-        return []
+    def flush_perf(self):
+        pass
 
 
 @dataclass
@@ -120,7 +144,7 @@ class Devices:
                 try:
                     devices.append(Device(dev=DeviceStorage(**dev)))
                 except Exception as e:
-                    raise Exception("unable to parse %s as Device %s" % (dev, e))
+                    raise Exception("unable to parse %s as Device: %s" % (dev, e))
             self.devices = devices
 
 
@@ -193,12 +217,12 @@ class FS(Storage):
         return [dev.fqdn for dev in result]
 
     def make_devices(
-            self,
-            query: Query | list,
-            preload_neighbors=False,
-            use_mesh=None,
-            preload_extra_fields=False,
-            **kwargs,
+        self,
+        query: Query | list,
+        preload_neighbors=False,
+        use_mesh=None,
+        preload_extra_fields=False,
+        **kwargs,
     ) -> list[Device]:
         if isinstance(query, list):
             query = Query.new(query)
@@ -231,8 +255,7 @@ def filter_query(devices: list[Device], query: Query) -> list[Device]:
 
 def read_inventory(path: str, storage: Storage) -> Devices:
     with open(path, "r") as f:
-        data = f.read()
-    file_data = yaml.load(data, Loader=yaml.BaseLoader)
+        file_data = yaml.load(f, Loader=yaml.SafeLoader)
     res = dataclass_from_dict(Devices, file_data)
     for dev in res.devices:
         dev.dev.set_storage(storage)

{annet-2.6.0 → annet-3.1.0}/annet/adapters/netbox/common/manufacturer.py

@@ -4,32 +4,13 @@ from annet.annlib.netdev.views.hardware import HardwareView
 
 logger = getLogger(__name__)
 
-_VENDORS = {
-    "cisco": "Cisco",
-    "catalyst": "Cisco Catalyst",
-    "nexus": "Cisco Nexus",
-    "iosxr": "Cisco XR",
-    "huawei": "Huawei",
-    "optixtrans": "Huawei OptiXtrans",
-    "juniper": "Juniper",
-    "arista": "Arista",
-    "pc": "PC",
-    "nokia": "Nokia",
-    "aruba": "Aruba",
-    "routeros": "RouterOS",
-    "ribbon": "Ribbon",
-    "b4com": "B4com",
-    "h3c": "H3C",
-}
-
 
 def get_hw(manufacturer: str, model: str, platform_name: str):
-    # by some reason Netbox calls Mellanox SN as MSN, so we fix them here
+    # By some reason Netbox calls Mellanox SN as MSN, so we fix them here
     if manufacturer == "Mellanox" and model.startswith("MSN"):
         model = model.replace("MSN", "SN", 1)
-    vendor = manufacturer + " " + model
-    hw = HardwareView(_VENDORS.get(vendor.lower(), vendor), platform_name)
-    return hw
+
+    return HardwareView(manufacturer + " " + model, platform_name)
 
 
 def get_breed(manufacturer: str, model: str):

{annet-2.6.0 → annet-3.1.0}/annet/adapters/netbox/common/models.py

@@ -5,8 +5,9 @@ from ipaddress import ip_interface, IPv6Interface
 from typing import List, Optional, Any, Dict, Sequence, TypeVar, Generic
 
 from annet.annlib.netdev.views.dump import DumpableView
-from annet.annlib.netdev.views.hardware import HardwareView, lag_name, svi_name
+from annet.annlib.netdev.views.hardware import HardwareView, lag_name
 from annet.storage import Storage
+from annet.vendors import registry_connector
 
 
 @dataclass
@@ -259,7 +260,7 @@ class NetboxDevice(Entity, Generic[_InterfaceT]):
         return lag_interface
 
     def _svi_name(self, svi: int) -> str:
-        return svi_name(self.hw, svi)
+        return registry_connector.get().match(self.hw).svi_name(svi)
 
     def add_svi(self, svi: int) -> _InterfaceT:
         name = self._svi_name(svi)

{annet-2.6.0 → annet-3.1.0}/annet/adapters/netbox/v24/models.py

@@ -1,11 +1,12 @@
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from ipaddress import ip_interface, IPv6Interface
-from typing import List, Optional, Any, Dict, Sequence, Callable
+from typing import List, Optional, Any, Dict, Sequence
 
 from annet.annlib.netdev.views.dump import DumpableView
-from annet.annlib.netdev.views.hardware import HardwareView, lag_name, svi_name
+from annet.annlib.netdev.views.hardware import HardwareView, lag_name
 from annet.storage import Storage
+from annet.vendors import registry_connector
 
 
 @dataclass
@@ -259,7 +260,7 @@ class NetboxDevice(Entity):
         return lag_interface
 
     def _svi_name(self, svi: int) -> str:
-        return svi_name(self.hw, svi)
+        return registry_connector.get().match(self.hw).svi_name(svi)
 
     def add_svi(self, svi: int) -> Interface:
         name = self._svi_name(svi)

{annet-2.6.0 → annet-3.1.0}/annet/annlib/netdev/views/hardware.py

@@ -1,3 +1,4 @@
+import functools
 from typing import Optional
 
 from annet.annlib.netdev.devdb import parse_hw_model
@@ -51,20 +52,31 @@ class HardwareLeaf(DumpableView):
 
 
 class HardwareView(HardwareLeaf):
-    def __init__(self, hw_model, sw_version):
-        (true_sequences, false_sequences) = parse_hw_model(hw_model or "")
+    def __init__(self, hw_model, sw_version: Optional[str] = None):
+        true_sequences, false_sequences = parse_hw_model(hw_model or "")
         super().__init__((), true_sequences, false_sequences)
         self.model = hw_model or ""
         self._soft = sw_version or ""
 
     @property
     def vendor(self) -> Optional[str]:
-        return hw_to_vendor(self)
+        from annet.hardware import hardware_connector
+        return hardware_connector.get().hw_to_vendor(self)
 
     @property
     def soft(self) -> str:
         return self._soft
 
+    @soft.setter
+    def soft(self, value: str) -> None:
+        self._soft = value
+
+    def match(self, expr: str) -> bool:
+        dev_path = expr.split(".")
+        if dev_path and dev_path[0] == "hw":
+            dev_path = dev_path[1:]
+        return bool(functools.reduce(getattr, dev_path, self))
+
     def __hash__(self):
         return hash(self.model)
 
@@ -72,62 +84,6 @@ class HardwareView(HardwareLeaf):
         return self.model == other.model
 
 
-def hw_to_vendor(hw: HardwareView) -> Optional[str]:
-    if hw.Nexus:
-        return "nexus"
-    elif hw.Cisco.XR or hw.Cisco.ASR or hw.Cisco.XRV:
-        return "iosxr"
-    elif hw.Cisco:
-        return "cisco"
-    elif hw.OptiXtrans:
-        return "optixtrans"
-    elif hw.Huawei:
-        return "huawei"
-    elif hw.Juniper:
-        return "juniper"
-    elif hw.Arista:
-        return "arista"
-    elif hw.PC:
-        return "pc"
-    elif hw.Nokia:
-        return "nokia"
-    elif hw.RouterOS:
-        return "routeros"
-    elif hw.Aruba:
-        return "aruba"
-    elif hw.Ribbon:
-        return "ribbon"
-    elif hw.H3C:
-        return "h3c"
-    elif hw.B4com:
-        return "b4com"
-    return None
-
-
-def vendor_to_hw(vendor):
-    hw = HardwareView(
-        {
-            "cisco": "Cisco",
-            "catalyst": "Cisco Catalyst",
-            "nexus": "Cisco Nexus",
-            "iosxr": "Cisco XR",
-            "huawei": "Huawei",
-            "optixtrans": "Huawei OptiXtrans",
-            "juniper": "Juniper",
-            "arista": "Arista",
-            "pc": "PC",
-            "nokia": "Nokia",
-            "aruba": "Aruba",
-            "routeros": "RouterOS",
-            "ribbon": "Ribbon",
-            "h3c": "H3C",
-            "b4com": "B4com",
-        }.get(vendor.lower(), vendor),
-        None,
-    )
-    return hw
-
-
 def lag_name(hw: HardwareView, nlagg: int) -> str:
     if hw.Huawei:
         return f"Eth-Trunk{nlagg}"
@@ -148,14 +104,3 @@ def lag_name(hw: HardwareView, nlagg: int) -> str:
     if hw.Nokia:
         return f"lagg-{nlagg}"
     raise NotImplementedError(hw)
-
-
-def svi_name(hw: HardwareView, num: int) -> str:
-    if hw.Juniper:
-        return f"irb.{num}"
-    elif hw.Huawei:
-        return f"Vlanif{num}"
-    elif hw.Arista or hw.Cisco:
-        return f"Vlan{num}"
-    else:
-        return f"vlan{num}"

{annet-2.6.0 → annet-3.1.0}/annet/annlib/patching.py

@@ -19,6 +19,7 @@ from .rulebook.common import call_diff_logic
 from .rulebook.common import default as common_default
 from .tabparser import CommonFormatter
 from .types import Diff, Op
+from ..vendors import registry_connector
 
 
 # =====
@@ -183,7 +184,8 @@ class Orderer:
         f_rule = ""
         children = []
         ordering = self.rb
-        block_exit = platform.VENDOR_EXIT[self.vendor]
+
+        block_exit = registry_connector.get()[self.vendor].exit
 
         for (order, (raw_rule, rule)) in enumerate(ordering.items()):
             if (
@@ -224,14 +226,15 @@ class Orderer:
         return (f_order or 0), cmd_direct, odict(children), f_rule
 
     def order_config(self, config):
-        if self.vendor not in platform.VENDOR_REVERSES:
+        if self.vendor not in registry_connector.get():
             return config
-
-        ordered = []
-        reverse_prefix = platform.VENDOR_REVERSES[self.vendor]
         if not config:
             return odict()
-        for (row, children) in config.items():
+
+        ordered = []
+        reverse_prefix = registry_connector.get()[self.vendor].reverse
+
+        for row, children in config.items():
             cmd_direct = not row.startswith(reverse_prefix)
             (order, direct, rb, _) = self.get_order(row, cmd_direct)
             child_orderer = Orderer(rb, self.vendor)

{annet-2.6.0 → annet-3.1.0}/annet/annlib/rbparser/acl.py

@@ -5,7 +5,8 @@ from typing import Any, Callable, List, Optional
 from valkit import add_validator_magic
 from valkit.common import valid_bool, valid_number, valid_string_list
 
-from . import platform, syntax
+from annet.vendors import registry_connector
+from . import syntax
 
 
 # =====
@@ -13,7 +14,7 @@ from . import platform, syntax
 def compile_acl_text(text, vendor, allow_ignore=False):
     return _compile_acl(
         trees=[syntax.parse_text(text, _PARAMS_SCHEME)],
-        reverse_prefix=platform.VENDOR_REVERSES[vendor],
+        reverse_prefix=registry_connector.get()[vendor].reverse,
         allow_ignore=allow_ignore,
         vendor=vendor,
     )

{annet-2.6.0 → annet-3.1.0}/annet/annlib/rbparser/ordering.py

@@ -4,7 +4,8 @@ from collections import OrderedDict as odict
 
 from valkit.common import valid_bool, valid_string_list
 
-from . import platform, syntax
+from annet.vendors import registry_connector
+from . import syntax
 
 
 # =====
@@ -25,7 +26,7 @@ def compile_ordering_text(text, vendor):
                 "default": None,
             }
         }),
-        reverse_prefix=platform.VENDOR_REVERSES[vendor],
+        reverse_prefix=registry_connector.get()[vendor].reverse,
     )
 
 

annet-3.1.0/annet/annlib/rbparser/platform.py

@@ -0,0 +1,3 @@
+VENDOR_ALIASES = {
+    "h3c": "huawei",
+}

{annet-2.6.0 → annet-3.1.0}/annet/annlib/rulebook/common.py

@@ -135,20 +135,21 @@ class DiffItem(typing.NamedTuple):
     diff_pre: typing.Dict[str, typing.Any]
 
 
-def default_diff(old, new, diff_pre, _pops=(Op.AFFECTED,)):
+Differ = typing.Callable[[odict, odict, odict, tuple[Op, ...]], list[DiffItem]]
+
+
+def default_diff(old: odict, new: odict, diff_pre: odict, _pops: tuple[Op, ...] = (Op.AFFECTED,)) -> list[DiffItem]:
     diff = base_diff(old, new, diff_pre, _pops, moved_to_affected=True)
     return diff
 
 
-def ordered_diff(old, new, diff_pre, _pops=(Op.AFFECTED,)):
+def ordered_diff(old: odict, new: odict, diff_pre: odict, _pops: tuple[Op, ...] = (Op.AFFECTED,)) -> list[DiffItem]:
     diff = base_diff(old, new, diff_pre, _pops, moved_to_affected=False)
     return diff
 
 
-def rewrite_diff(old, new, diff_pre, _pops=(Op.AFFECTED,)):
-    def iter_diff(
-        diff: typing.List[DiffItem],
-    ) -> typing.Iterable[typing.Tuple[int, typing.List[DiffItem]]]:
+def rewrite_diff(old: odict, new: odict, diff_pre: odict, _pops: tuple[Op, ...] = (Op.AFFECTED,)) -> list[DiffItem]:
+    def iter_diff(diff: list[DiffItem]) -> typing.Iterable[tuple[int, list[DiffItem]]]:
         queue = [diff]
         while queue:
             items, queue = queue[0], queue[1:]
@@ -173,16 +174,18 @@ def rewrite_diff(old, new, diff_pre, _pops=(Op.AFFECTED,)):
     return diff
 
 
-def multiline_diff(old, new, diff_pre, _pops=(Op.AFFECTED,)):
+def multiline_diff(old: odict, new: odict, diff_pre: odict, _pops: tuple[Op, ...] = (Op.AFFECTED,)) -> list[DiffItem]:
     """
     Особая логика diff'a для хуавейных мультилайнов.
     Она трактует все дочерние элементы %multiline-команды как
     одну общую команду, покидывая внутрь тот Op который был
     определен на вернем уровне
     """
+
     def process_multiline(op, tree):
-        for (row, children) in tree.items():
-            yield (op, row, list(process_multiline(op, children)), None)
+        for row, children in tree.items():
+            yield op, row, list(process_multiline(op, children)), None
+
     ret = []
     for item in default_diff(old, new, diff_pre, _pops):
         if old.get(item.row, {}) == new.get(item.row, {}):
@@ -192,23 +195,27 @@ def multiline_diff(old, new, diff_pre, _pops=(Op.AFFECTED,)):
             op, tree = Op.REMOVED, old
         children = list(process_multiline(op, tree[item.row]))
         ret.append(DiffItem(item.op, item.row, children, item.diff_pre))
+
     return ret
 
 
-def base_diff(old, new, diff_pre, pops, moved_to_affected=False) -> typing.List[DiffItem]:
+def base_diff(
+    old: odict, new: odict, diff_pre: odict, pops: tuple[Op, ...], moved_to_affected: bool = False
+) -> list[DiffItem]:
     diff_indexed: typing.List[typing.Tuple[int, DiffItem]] = []
     old = _ignore_case(diff_pre, old)
     new = _ignore_case(diff_pre, new)
 
-    for (index, row) in enumerate(old):
+    for index, row in enumerate(old):
         if row not in new:
-            children = call_diff_logic(diff_pre[row]["subtree"], old[row], {}, pops + (Op.REMOVED,))
+            children = call_diff_logic(diff_pre[row]["subtree"], old[row], odict(), pops + (Op.REMOVED,))
             diff_indexed.append((index, DiffItem(
                 op=Op.REMOVED,
                 row=row,
                 children=children,
                 diff_pre=diff_pre[row]["match"],
             )))
+
     old_indexes = {row: index for (index, row) in enumerate(old)}
     block_in_disorder = False
     parent_op = pops[-1]
@@ -232,13 +239,13 @@ def base_diff(old, new, diff_pre, pops, moved_to_affected=False) -> typing.List[
     return [x[1] for x in diff_indexed]
 
 
-def call_diff_logic(diff_pre, old, new, pops=(Op.AFFECTED,)):
+def call_diff_logic(diff_pre: odict, old: odict, new: odict, pops: tuple[Op, ...] = (Op.AFFECTED,)):
     """
     Группируем команды в старом и новом конфиге согласно выставленным
     в рулбуке атрибутам %diff_logic и вызывает их поочереди согласно
     порядку команд в old и new, предпочитая old (т.е. сначала удаления)
     """
-    diff_logics = odict()
+    diff_logics: odict = odict()
     for row in old:
         logic = diff_pre[row]["match"]["attrs"]["diff_logic"]
         if logic not in diff_logics:

{annet-2.6.0 → annet-3.1.0}/annet/annlib/tabparser.py

@@ -819,24 +819,6 @@ class RosFormatter(CommonFormatter):
         return commands
 
 
-def make_formatter(vendor, **kwargs):
-    formatters = {
-        "juniper": JuniperFormatter,
-        "cisco": CiscoFormatter,
-        "nexus": NexusFormatter,
-        "huawei": HuaweiFormatter,
-        "optixtrans": OptixtransFormatter,
-        "arista": AristaFormatter,
-        "nokia": NokiaFormatter,
-        "routeros": RosFormatter,
-        "aruba": ArubaFormatter,
-        "pc": CommonFormatter,
-        "ribbon": RibbonFormatter,
-        "b4com": B4comFormatter,
-    }
-    return formatters[vendor](**kwargs)
-
-
 # ====
 def parse_to_tree(text, splitter, comments=("!", "#")):
     tree = odict()

{annet-2.6.0 → annet-3.1.0}/annet/api/__init__.py

@@ -25,7 +25,6 @@ import annet.deploy_ui
 import annet.lib
 from annet.annlib import jsontools
 from annet.annlib.netdev.views.hardware import HardwareView
-from annet.annlib.rbparser.platform import VENDOR_REVERSES
 from annet.annlib.types import GeneratorType
 from contextlog import get_logger
 
@@ -48,6 +47,7 @@ from annet.parallel import Parallel, TaskResult
 from annet.reference import RefTracker
 from annet.storage import Device, get_storage
 from annet.types import Diff, ExitCode, OldNewResult, Op, PCDiff, PCDiffFile
+from annet.vendors import registry_connector
 
 DEFAULT_INDENT = "  "
 
@@ -138,16 +138,19 @@ def _read_device_config(path, hw):
     _logger = get_logger()
     _logger.debug("Reading %r ...", path)
     score = 1
+    vendor_registry = registry_connector.get()
 
     with open(path) as cfgdump_file:
         text = cfgdump_file.read()
     try:
         if not hw:
             hw, score = guess_hw(text)
+
         config = tabparser.parse_to_tree(
             text=text,
-            splitter=tabparser.make_formatter(hw).split,
+            splitter=vendor_registry.match(hw).make_formatter().split,
         )
+
         return config, hw, score
     except tabparser.ParserError:
         _logger.exception("Parser error: %r", path)
@@ -156,7 +159,7 @@ def _read_device_config(path, hw):
 
 # =====
 def _format_patch_blocks(patch_tree, hw, indent):
-    formatter = tabparser.make_formatter(hw, indent=indent)
+    formatter = registry_connector.get().match(hw).make_formatter(indent=indent)
     return formatter.patch(patch_tree)
 
 
@@ -395,9 +398,12 @@ class CliDeployerJob(DeployerJob):
         (diff_obj, patch_tree) = _diff_and_patch(device, old, new, acl_rules,
                                                  res.filter_acl_rules, self.add_comments,
                                                  do_commit=not self.args.dont_commit)
-        cmds = tabparser.make_formatter(device.hw, indent="").cmd_paths(patch_tree)
+
+        formatter = registry_connector.get().match(device.hw).make_formatter(indent="")
+        cmds = formatter.cmd_paths(patch_tree)
         if not cmds:
             return
+
         self._has_diff = True
         self.diffs[device] = diff_obj
         self.cmd_lines.extend(["= %s " % device.hostname, ""])
@@ -550,7 +556,7 @@ class Deployer:
                 dest_name = "= %s" % ", ".join([dev.hostname for dev in devices])
                 diff_lines.extend([dest_name, ""])
 
-            for line in tabparser.make_formatter(devices[0].hw).diff(diff_obj):
+            for line in registry_connector.get().match(devices[0].hw).make_formatter().diff(diff_obj):
                 diff_lines.append(line)
             diff_lines.append("")
         return diff_lines
@@ -786,14 +792,17 @@ def guess_hw(config_text: str):
     текста конфига и annet/rulebook/texts/*.rul"""
     scores = {}
     hw_provider = hardware_connector.get()
-    for vendor in VENDOR_REVERSES:
+    vendor_registry = registry_connector.get()
+    for vendor in vendor_registry:
         hw = hw_provider.vendor_to_hw(vendor)
-        fmtr = tabparser.make_formatter(hw)
         rb = rulebook.get_rulebook(hw)
+        fmtr = vendor_registry[vendor].make_formatter()
+
         try:
             config = tabparser.parse_to_tree(config_text, fmtr.split)
         except Exception:
             continue
+
         pre = patching.make_pre(patching.make_diff({}, config, rb, []))
         metric = _count_pre_score(pre)
         scores[metric] = hw