annet 2.6.0__py3-none-any.whl → 3.1.0__py3-none-any.whl

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

annet/diff.py

@@ -21,8 +21,8 @@ from annet.cli_args import ShowDiffOptions
 from annet.connectors import CachedConnector
 from annet.output import output_driver_connector
 from annet.storage import Device
-from annet.tabparser import make_formatter
 from annet.types import Diff, PCDiff, PCDiffFile
+from annet.vendors import registry_connector
 
 from .gen import Loader, old_new
 
@@ -159,7 +159,7 @@ def _transform_text_diff_for_collapsing(text_diff) -> List[str]:
 
 
 def _make_text_diff(device: Device, diff: Diff) -> List[str]:
-    formatter = make_formatter(device.hw)
+    formatter = registry_connector.get().match(device.hw).make_formatter()
     res = formatter.diff(diff)
     return res
 
@@ -226,7 +226,7 @@ class FrrFileDiffer(UnifiedFileDiffer):
         indent = "  "
         rb = rulebook.rulebook_provider_connector.get()
         rulebook_data = rb.get_rulebook(hw)
-        formatter = tabparser.make_formatter(hw, indent=indent)
+        formatter = registry_connector.get().match(hw).make_formatter(indent=indent)
 
         old_tree = tabparser.parse_to_tree(old_text or "", splitter=formatter.split)
         new_tree = tabparser.parse_to_tree(new_text or "", splitter=formatter.split)

annet/gen.py

@@ -29,7 +29,7 @@ from annet import generators, implicit, patching, tabparser, tracing
 from annet.annlib import jsontools
 from annet.annlib.rbparser.acl import compile_acl_text
 from annet.cli_args import DeployOptions, GenOptions, ShowGenOptions
-from annet.deploy import scrub_config, get_fetcher
+from annet.deploy import get_fetcher, scrub_config
 from annet.filtering import Filterer
 from annet.generators import (
     BaseGenerator,
@@ -40,12 +40,12 @@ from annet.generators import (
     PartialGenerator,
     RefGenerator,
 )
-from annet.lib import merge_dicts, percentile, do_async
+from annet.lib import do_async, merge_dicts, percentile
 from annet.output import output_driver_connector
-from annet.parallel import Parallel
-from annet.storage import Device, Storage, storage_connector
+from annet.storage import Device, Storage
 from annet.tracing import tracing_connector
 from annet.types import OldNewResult
+from annet.vendors import registry_connector
 
 
 # Вывод всех генераторов вместе.
@@ -162,7 +162,7 @@ def _old_new_per_device(ctx: OldNewDeviceContext, device: Device, filterer: Filt
         if ctx.config != "empty":
             old = tabparser.parse_to_tree(
                 text=text,
-                splitter=tabparser.make_formatter(device.hw).split,
+                splitter=registry_connector.get().match(device.hw).make_formatter().split,
             )
         if not old:
             res = generators.run_partial_initial(device)
@@ -638,7 +638,7 @@ def _existing_cfg_file_name(config_dir: str, device) -> Optional[str]:
 
 
 def format_config_blocks(config, hw, indent, _level=0):
-    formatter = tabparser.make_formatter(hw, indent=indent)
+    formatter = registry_connector.get().match(hw).make_formatter(indent=indent)
     return formatter.join(config)
 
 

annet/generators/__init__.py

@@ -7,24 +7,15 @@ import os
 import re
 import textwrap
 from collections import OrderedDict as odict
-from typing import (
-    FrozenSet,
-    Iterable,
-    List,
-    Optional,
-    Union,
-)
+from typing import FrozenSet, Iterable, List, Optional, Union
 
-from annet.annlib.rbparser.acl import compile_acl_text
 from contextlog import get_logger
 
-from annet.storage import Device
-
 from annet import patching, tabparser, tracing
+from annet.annlib.rbparser.acl import compile_acl_text
 from annet.cli_args import GenSelectOptions, ShowGeneratorsOptions
-from annet.lib import (
-    get_context,
-)
+from annet.lib import get_context
+from annet.storage import Device
 from annet.tracing import tracing_connector
 from annet.types import (
     GeneratorEntireResult,
@@ -33,19 +24,20 @@ from annet.types import (
     GeneratorPartialRunArgs,
     GeneratorResult,
 )
-from .base import (
-    BaseGenerator,
-    TextGenerator as TextGenerator,
-    ParamsList as ParamsList,
-)
-from .exceptions import NotSupportedDevice, GeneratorError
+from annet.vendors import registry_connector
+
+from .base import BaseGenerator
+from .base import ParamsList as ParamsList
+from .base import TextGenerator as TextGenerator
+from .entire import Entire
+from .exceptions import GeneratorError, NotSupportedDevice
 from .jsonfragment import JSONFragment
 from .partial import PartialGenerator
-from .entire import Entire
-from .ref import RefGenerator
 from .perf import GeneratorPerfMesurer
+from .ref import RefGenerator
 from .result import RunGeneratorResult
 
+
 # =====
 DISABLED_TAG = "disable"
 
@@ -200,7 +192,8 @@ def _run_partial_generator(gen: "PartialGenerator", run_args: GeneratorPartialRu
                 logger.error("Generator error in file '%s:%i'", filename, lineno)
                 raise GeneratorError(f"{gen} on {device}") from err
 
-            fmtr = tabparser.make_formatter(device.hw)
+            fmtr = registry_connector.get().match(device.hw).make_formatter()
+
             try:
                 config = tabparser.parse_to_tree(text=output, splitter=fmtr.split)
             except tabparser.ParserError as err:

annet/hardware.py

@@ -1,17 +1,11 @@
 import abc
 from typing import Any
 
-from annet.annlib.netdev.views.hardware import HardwareView, hw_to_vendor
-
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.vendors import registry_connector
 from annet.connectors import Connector
 
 
-try:
-    from annet.annlib.netdev.views.hardware import vendor_to_hw
-except ImportError:
-    from netdev.views.hardware import vendor_to_hw
-
-
 class _HardwareConnector(Connector["HarwareProvider"]):
     name = "Hardware"
     ep_name = "hardware"
@@ -31,7 +25,7 @@ class HarwareProvider(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def hw_to_vendor(self, hw: Any) -> str:
+    def hw_to_vendor(self, hw: Any) -> str | None:
         pass
 
 
@@ -40,7 +34,9 @@ class AnnetHardwareProvider(HarwareProvider):
         return HardwareView(hw_model, sw_version)
 
     def vendor_to_hw(self, vendor: str) -> HardwareView:
-        return vendor_to_hw(vendor)
+        return registry_connector.get().get(vendor.lower()).hardware
 
-    def hw_to_vendor(self, hw: HardwareView) -> str:
-        return hw_to_vendor(hw)
+    def hw_to_vendor(self, hw: HardwareView) -> str | None:
+        if vendor := registry_connector.get().match(hw, None):
+            return vendor.NAME
+        return None

annet/rulebook/__init__.py

@@ -5,11 +5,12 @@ from typing import Iterable, Union
 
 from annet.annlib.lib import mako_render
 from annet.annlib.rbparser.ordering import compile_ordering_text
-from annet.annlib.rbparser.platform import VENDOR_REVERSES, VENDOR_ALIASES
+from annet.annlib.rbparser.platform import VENDOR_ALIASES
 
 from annet.connectors import CachedConnector
 from annet.rulebook.deploying import compile_deploying_text
 from annet.rulebook.patching import compile_patching_text
+from annet.vendors import registry_connector
 
 
 class RulebookProvider(ABC):
@@ -63,7 +64,7 @@ class DefaultRulebookProvider(RulebookProvider):
         if hw in self._rulebook_cache:
             return self._rulebook_cache[hw]
 
-        assert hw.vendor in VENDOR_REVERSES, "Unknown vendor: %s" % (hw.vendor)
+        assert hw.vendor in registry_connector.get(), "Unknown vendor: %s" % (hw.vendor)
         rul_vendor_name = VENDOR_ALIASES.get(hw.vendor, hw.vendor)
         patching = compile_patching_text(self._render_rul(rul_vendor_name + ".rul", hw), rul_vendor_name)
 

annet/rulebook/deploying.py

@@ -2,8 +2,9 @@ import functools
 from collections import OrderedDict as odict
 from collections import namedtuple
 
-from annet.annlib.rbparser import platform, syntax
+from annet.annlib.rbparser import syntax
 from annet.annlib.rbparser.deploying import compile_messages
+from annet.vendors import registry_connector
 from valkit.common import valid_bool, valid_number, valid_string_list
 from valkit.python import valid_object_path
 
@@ -38,7 +39,7 @@ def compile_deploying_text(text, vendor):
                 "default": [],
             }
         }),
-        reverse_prefix=platform.VENDOR_REVERSES[vendor],
+        reverse_prefix=registry_connector.get()[vendor].reverse,
     )
 
 

annet/rulebook/juniper/__init__.py

@@ -1,10 +1,10 @@
+import functools
 import re
 from collections import OrderedDict as odict
-import functools
 
 from annet.annlib.lib import jun_activate, jun_is_inactive, merge_dicts
+from annet.annlib.tabparser import JuniperFormatter
 from annet.annlib.types import Op
-from annet.tabparser import JuniperFormatter
 from annet.rulebook import common
 
 

annet/rulebook/patching.py

@@ -1,14 +1,13 @@
 import functools
 import re
 from collections import OrderedDict as odict
-
 from annet.annlib.rbparser import platform, syntax
+from annet.vendors import registry_connector
 from valkit.common import valid_bool, valid_string_list
 from valkit.python import valid_object_path
 
 from .common import import_rulebook_function
 
-
 DEFAULT_PATCH_LOGIC = "common.default"
 ORDERED_PATCH_LOGIC = "common.ordered"
 REWRITE_PATCH_LOGIC = "common.rewrite"
@@ -19,6 +18,7 @@ MULTILINE_DIFF_LOGIC = "common.multiline_diff"
 # =====
 @functools.lru_cache()
 def compile_patching_text(text, vendor):
+
     return _compile_patching(
         tree=syntax.parse_text(text, params_scheme={
             "global": {
@@ -31,7 +31,7 @@ def compile_patching_text(text, vendor):
             },
             "diff_logic": {
                 "validator": valid_object_path,
-                "default": platform.VENDOR_DIFF[vendor],
+                "default": registry_connector.get()[vendor].diff(False),
             },
             "comment": {
                 "validator": valid_string_list,
@@ -62,7 +62,7 @@ def compile_patching_text(text, vendor):
                 "default": False,
             },
         }),
-        reverse_prefix=platform.VENDOR_REVERSES[vendor],
+        reverse_prefix=registry_connector.get()[vendor].reverse,
         vendor=vendor,
     )
 
@@ -86,7 +86,7 @@ def _compile_patching(tree, reverse_prefix, vendor):
             }
         else:
             if attrs["params"]["ordered"]:
-                attrs["params"]["diff_logic"] = platform.VENDOR_DIFF_ORDERED[vendor]
+                attrs["params"]["diff_logic"] = registry_connector.get()[vendor].diff(True)
                 attrs["params"]["logic"] = ORDERED_PATCH_LOGIC
             elif attrs["params"]["rewrite"]:
                 attrs["params"]["diff_logic"] = REWRITE_DIFF_LOGIC

annet/vendors/__init__.py

@@ -0,0 +1,33 @@
+from typing import Callable
+
+from annet.connectors import Connector
+from annet.vendors.base import AbstractVendor
+
+from .library import (
+    arista,
+    aruba,
+    b4com,
+    cisco,
+    h3c,
+    huawei,
+    iosxr,
+    juniper,
+    nexus,
+    nokia,
+    optixtrans,
+    pc,
+    ribbon,
+    routeros,
+)
+from .registry import Registry, registry
+
+
+class _RegistryConnector(Connector[Registry]):
+    name = "Registry"
+    ep_name = "vendors"
+
+    def _get_default(self) -> Callable[[], Registry]:
+        return lambda: registry
+
+
+registry_connector = _RegistryConnector()

annet/vendors/base.py

@@ -0,0 +1,38 @@
+import abc
+from typing import ClassVar
+
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import CommonFormatter
+
+
+class AbstractVendor(abc.ABC):
+    NAME: ClassVar[str]
+
+    @abc.abstractmethod
+    def match(self) -> list[str]:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def reverse(self) -> str:
+        raise NotImplementedError
+
+    def diff(self, order: bool) -> str:
+        return "common.ordered_diff" if order else "common.default_diff"
+
+    @property
+    @abc.abstractmethod
+    def exit(self) -> str:
+        raise NotImplementedError
+
+    @property
+    @abc.abstractmethod
+    def hardware(self) -> HardwareView:
+        raise NotImplementedError
+
+    def svi_name(self, num: int) -> str:
+        return f"vlan{num}"
+
+    @abc.abstractmethod
+    def make_formatter(self, **kwargs) -> CommonFormatter:
+        raise NotImplementedError

annet/vendors/registry.py

@@ -0,0 +1,93 @@
+import enum
+from operator import itemgetter
+
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import CommonFormatter
+
+from .base import AbstractVendor
+
+
+_SENTINEL = enum.Enum("_SENTINEL", "sentinel")
+sentinel = _SENTINEL.sentinel
+
+
+class GenericVendor(AbstractVendor):
+    def match(self) -> list[str]:
+        return []
+
+    @property
+    def reverse(self) -> str:
+        return "-"
+
+    @property
+    def hardware(self) -> HardwareView:
+        return HardwareView("")
+
+    def make_formatter(self, **kwargs) -> CommonFormatter:
+        return CommonFormatter(**kwargs)
+
+    @property
+    def exit(self) -> str:
+        return ""
+
+
+GENERIC_VENDOR = GenericVendor()
+
+
+class Registry:
+    def __init__(self):
+        self.vendors: dict[str, AbstractVendor] = {}
+        self._matchers = {}
+
+    def register(self, cls: type[AbstractVendor]) -> type[AbstractVendor]:
+        if not cls.NAME:
+            raise RuntimeError(f"{cls.__name__} has empty NAME field")
+        if cls.NAME in self.vendors:
+            raise RuntimeError(f"{cls.__name__} with name {cls.NAME} already registered")
+        self.vendors[cls.NAME] = cls()
+
+        return cls
+
+    def __add__(self, other: "Registry"):
+        self.vendors = dict(**other.vendors, **self.vendors)
+
+    def __getitem__(self, item) -> AbstractVendor:
+        if item in self.vendors:
+            return self.vendors[item]
+        raise RuntimeError(f"Unknown vendor {item}")
+
+    def match(
+        self,
+        hw: HardwareView | str,
+        default: _SENTINEL | AbstractVendor | None = sentinel
+    ) -> AbstractVendor | None:
+        if isinstance(hw, str):
+            hw = HardwareView(hw, "")
+
+        matched: list[tuple[AbstractVendor, int]] = []
+        for name, vendor in self.vendors.items():
+            for item in vendor.match():
+                if hw.match(item):
+                    matched.append((vendor, item.count(".")))
+
+        if matched:
+            return next(iter(sorted(matched, key=itemgetter(1), reverse=True)))[0]
+        if default is sentinel:
+            return GENERIC_VENDOR
+        return default
+
+    def get(self, item: str, default: _SENTINEL | AbstractVendor | None = sentinel) -> AbstractVendor | None:
+        if item in self:
+            return self[item]
+        if default is sentinel:
+            return GENERIC_VENDOR
+        return default
+
+    def __contains__(self, item):
+        return item in self.vendors
+
+    def __iter__(self):
+        return iter(self.vendors)
+
+
+registry = Registry()

{annet-2.6.0.dist-info → annet-3.1.0.dist-info}/METADATA

@@ -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