annet 3.0.0__tar.gz → 3.1.1__tar.gz

{annet-3.0.0/annet.egg-info → annet-3.1.1}/PKG-INFO

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

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

@@ -184,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 (

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

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

{annet-3.0.0 → annet-3.1.1}/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-3.0.0 → annet-3.1.1}/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-3.0.0 → annet-3.1.1}/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
 
@@ -139,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)
@@ -157,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)
 
 
@@ -396,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, ""])
@@ -551,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
@@ -787,14 +792,17 @@ def guess_hw(config_text: str):
     текста конфига и annet/rulebook/texts/*.rul"""
     scores = {}
     hw_provider = hardware_connector.get()
-    for vendor in registry_connector.get():
+    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-3.0.0 → annet-3.1.1}/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-3.0.0 → annet-3.1.1}/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-3.0.0 → annet-3.1.1}/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-3.0.0 → annet-3.1.1}/annet/rulebook/__init__.py

@@ -5,7 +5,7 @@ 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

{annet-3.0.0 → annet-3.1.1}/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-3.0.0 → annet-3.1.1}/annet/rulebook/patching.py

@@ -1,7 +1,6 @@
 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
@@ -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,
@@ -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-3.0.0 → annet-3.1.1}/annet/vendors/base.py

@@ -2,6 +2,7 @@ import abc
 from typing import ClassVar
 
 from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import CommonFormatter
 
 
 class AbstractVendor(abc.ABC):
@@ -16,6 +17,14 @@ class AbstractVendor(abc.ABC):
     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:
@@ -23,3 +32,7 @@ class AbstractVendor(abc.ABC):
 
     def svi_name(self, num: int) -> str:
         return f"vlan{num}"
+
+    @abc.abstractmethod
+    def make_formatter(self, **kwargs) -> CommonFormatter:
+        raise NotImplementedError

annet-3.1.1/annet/vendors/library/arista.py

@@ -0,0 +1,30 @@
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import AristaFormatter
+from annet.vendors.base import AbstractVendor
+from annet.vendors.registry import registry
+
+
+@registry.register
+class AristaVendor(AbstractVendor):
+    NAME = "arista"
+
+    def match(self) -> list[str]:
+        return ["Arista"]
+
+    @property
+    def reverse(self) -> str:
+        return "no"
+
+    @property
+    def hardware(self) -> HardwareView:
+        return HardwareView("Arista")
+
+    def svi_name(self, num: int) -> str:
+        return f"Vlan{num}"
+
+    def make_formatter(self, **kwargs) -> AristaFormatter:
+        return AristaFormatter(**kwargs)
+
+    @property
+    def exit(self) -> str:
+        return "exit"

annet-3.1.1/annet/vendors/library/aruba.py

@@ -0,0 +1,30 @@
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import ArubaFormatter
+from annet.vendors.base import AbstractVendor
+from annet.vendors.registry import registry
+
+
+@registry.register
+class ArubaVendor(AbstractVendor):
+    NAME = "aruba"
+
+    def match(self) -> list[str]:
+        return ["Aruba"]
+
+    @property
+    def reverse(self) -> str:
+        return "no"
+
+    @property
+    def hardware(self) -> HardwareView:
+        return HardwareView("Aruba")
+
+    def make_formatter(self, **kwargs) -> ArubaFormatter:
+        return ArubaFormatter(**kwargs)
+
+    @property
+    def exit(self) -> str:
+        return "exit"
+
+    def diff(self, order: bool) -> str:
+        return "common.ordered_diff" if order else "aruba.default_diff"

annet-3.1.1/annet/vendors/library/b4com.py

@@ -0,0 +1,27 @@
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import B4comFormatter
+from annet.vendors.base import AbstractVendor
+from annet.vendors.registry import registry
+
+
+@registry.register
+class B4ComVendor(AbstractVendor):
+    NAME = "b4com"
+
+    def match(self) -> list[str]:
+        return ["B4com"]
+
+    @property
+    def reverse(self) -> str:
+        return "no"
+
+    @property
+    def hardware(self) -> HardwareView:
+        return HardwareView("B4com")
+
+    def make_formatter(self, **kwargs) -> B4comFormatter:
+        return B4comFormatter(**kwargs)
+
+    @property
+    def exit(self) -> str:
+        return "exit"

annet-3.1.1/annet/vendors/library/cisco.py

@@ -0,0 +1,30 @@
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import CiscoFormatter
+from annet.vendors.base import AbstractVendor
+from annet.vendors.registry import registry
+
+
+@registry.register
+class CiscoVendor(AbstractVendor):
+    NAME = "cisco"
+
+    def match(self) -> list[str]:
+        return ["Cisco"]
+
+    @property
+    def reverse(self) -> str:
+        return "no"
+
+    @property
+    def hardware(self) -> HardwareView:
+        return HardwareView("Cisco")
+
+    def svi_name(self, num: int) -> str:
+        return f"Vlan{num}"
+
+    def make_formatter(self, **kwargs) -> CiscoFormatter:
+        return CiscoFormatter(**kwargs)
+
+    @property
+    def exit(self) -> str:
+        return "exit"

annet-3.1.1/annet/vendors/library/h3c.py

@@ -0,0 +1,27 @@
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import HuaweiFormatter
+from annet.vendors.base import AbstractVendor
+from annet.vendors.registry import registry
+
+
+@registry.register
+class H3CVendor(AbstractVendor):
+    NAME = "h3c"
+
+    def match(self) -> list[str]:
+        return ["H3C"]
+
+    @property
+    def reverse(self) -> str:
+        return "undo"
+
+    @property
+    def hardware(self) -> HardwareView:
+        return HardwareView("H3C")
+
+    def make_formatter(self, **kwargs) -> HuaweiFormatter:
+        return HuaweiFormatter(**kwargs)
+
+    @property
+    def exit(self) -> str:
+        return "quit"

annet-3.1.1/annet/vendors/library/huawei.py

@@ -0,0 +1,30 @@
+from annet.annlib.netdev.views.hardware import HardwareView
+from annet.annlib.tabparser import HuaweiFormatter
+from annet.vendors.base import AbstractVendor
+from annet.vendors.registry import registry
+
+
+@registry.register
+class HuaweiVendor(AbstractVendor):
+    NAME = "huawei"
+
+    def match(self) -> list[str]:
+        return ["Huawei"]
+
+    @property
+    def reverse(self) -> str:
+        return "undo"
+
+    @property
+    def hardware(self) -> HardwareView:
+        return HardwareView("Huawei")
+
+    def svi_name(self, num: int) -> str:
+        return f"Vlanif{num}"
+
+    def make_formatter(self, **kwargs) -> HuaweiFormatter:
+        return HuaweiFormatter(**kwargs)
+
+    @property
+    def exit(self) -> str:
+        return "quit"