annet 0.0__py3-none-any.whl

annet/annlib/netdev/devdb/data/devdb.json

@@ -0,0 +1,137 @@
+{
+    "Cisco": "^[Cc]isco",
+    "Cisco.CGS": " CGS",
+    "Cisco.IE": " IE",
+    "Cisco.AIR": "AIR",
+    "Cisco.ASR": " ASR",
+    "Cisco.ASR.ASR9000": " 9\\d{3}",
+    "Cisco.XRV": "XRv",
+    "Cisco.Catalyst": "Catalyst",
+    "Cisco.Catalyst.C2900": " 29\\d\\d",
+    "Cisco.Catalyst.C2900.C2950": " 2950",
+    "Cisco.Catalyst.C2900.C2960": " 2960",
+    "Cisco.Catalyst.C2900.C2960.C2960Plus": " 2960-Plus",
+    "Cisco.Catalyst.C2900.C2960.C2960S": " 2960S",
+    "Cisco.Catalyst.C2900.C2960.C2960X": " 2960X",
+    "Cisco.Catalyst.C3500": " 35\\d\\d",
+    "Cisco.Catalyst.C3600": " 36\\d\\d",
+    "Cisco.Catalyst.C3700": " 37\\d\\d",
+    "Cisco.Catalyst.C4900": " 49\\d\\d",
+    "Cisco.Catalyst.C6500": " 65\\d\\d",
+    "Cisco.Nexus": " [Nn]exus",
+    "Cisco.Nexus.N3x": " 3\\d\\d\\d",
+    "Cisco.Nexus.N3x.N3100": " 31\\d\\d",
+    "Cisco.Nexus.N3x.N3432": " 3432",
+    "Cisco.Nexus.N3x.N3500": " 35\\d\\d",
+    "Cisco.Nexus.N5x": " 5\\d\\d\\d",
+    "Cisco.Nexus.N5x.N5000": " 50\\d\\d",
+    "Cisco.Nexus.N5x.N5500": " 55\\d\\d",
+    "Cisco.Nexus.N6x": " 6\\d\\d\\d",
+    "Cisco.Nexus.N6x.N6000": " 60\\d\\d",
+    "Cisco.Nexus.N7x": " 7\\d{3}",
+    "Cisco.Nexus.N7x.N7000": " 70\\d\\d",
+    "Cisco.Nexus.N7x.N7700": " 77\\d\\d",
+    "Cisco.Nexus.N9x": " (N9K-[A-Z])?9\\d\\d\\d",
+    "Cisco.Nexus.N9x.N9316": " 9316",
+    "Cisco.Nexus.N9x.N9500": " 95\\d\\d",
+    "Cisco.Nexus.N9x.N9364": " N9K-C9364",
+
+    "Huawei": "^[Hh]uawei",
+    "Huawei.CE": " CE\\d+",
+    "Huawei.CE.CE12800": " CE128\\d{2}",
+    "Huawei.CE.CE5800": " CE58\\d\\d",
+    "Huawei.CE.CE6800": " CE68\\d\\d",
+    "Huawei.CE.CE6800.CE6850": " CE6850",
+    "Huawei.CE.CE6800.CE6860": "CE6860",
+    "Huawei.CE.CE6800.CE6865": " CE6865",
+    "Huawei.CE.CE6800.CE6870": " CE6870",
+    "Huawei.CE.CE6800.CE6865E": " CE6865E",
+    "Huawei.CE.CE6800.CE6865FM": " CE6865FM",
+    "Huawei.CE.CE7800": " CE78\\d\\d",
+    "Huawei.CE.CE8800": " CE88\\d\\d",
+    "Huawei.CE.CE8800.CE8850": " CE8850",
+    "Huawei.CE.CE8800.CE8851": " CE8851",
+    "Huawei.CE.CE9800": " CE98\\d\\d",
+    "Huawei.Quidway": " S\\d+",
+    "Huawei.Quidway.S2x": " S2\\d{3}",
+    "Huawei.Quidway.S2x.S2300": " S23\\d\\d",
+    "Huawei.Quidway.S2x.S2700": " S27\\d\\d",
+    "Huawei.Quidway.S5300": " S53\\d\\d",
+    "Huawei.Quidway.S5700": " S57\\d\\d",
+    "Huawei.Quidway.S6700": " S67\\d\\d",
+    "Huawei.NE": " NE\\d+",
+    "Huawei.NE.NE40E": " NE40E",
+    "Huawei.NE.NE8000": " NE8000",
+    "Huawei.EI": "-EI(-|$)",
+    "Huawei.HI": "-HI(-|$)",
+    "Huawei.SI": "-SI(-|$)",
+
+    "Juniper": "^[Jj]uniper",
+    "Juniper.MX": " MX",
+    "Juniper.MX.MX2000": " MX20\\d\\d",
+    "Juniper.MX.MX2000.MX2010": " MX2010",
+    "Juniper.MX.MX2000.MX2020": " MX2020",
+    "Juniper.MX.MX240": " MX240",
+    "Juniper.MX.MX480": " MX480",
+    "Juniper.MX.MX80": " MX80",
+    "Juniper.MX.MX960": " MX960",
+    "Juniper.QFX": " QFX",
+    "Juniper.QFX.QFX5200": " QFX5200",
+    "Juniper.VMX": " VMX",
+    "Juniper.VRR": " VRR",
+    "Juniper.PTX": " PTX",
+
+    "Arista": "^[Aa]rista",
+    "Arista.A7368": " 7368",
+    "Arista.A7368.X4": "X4",
+    "Arista.A7280": " DCS-7280",
+    "Arista.A7260": " DCS-7260",
+    "Arista.A7260.CX3": "CX3",
+    "Arista.A7050": " 7050",
+    "Arista.A7050.SX3": "SX3",
+    "Arista.A7060": " DCS-7060",
+    "Arista.A7060.DX4": "DX4",
+
+    "Nokia": "^[Nn]okia",
+    "Nokia.NS7750": " 7750",
+    "Nokia.SR_1s": "SR-1s",
+
+    "PC": "^(PC|pc|[Mm]ellanox SN|[Ee]dge-?[Cc]ore|[Mm]oxa)",
+
+    "PC.Whitebox": "([Mm]ellanox SN|[Ee]dge-?[Cc]ore)",
+    "PC.Whitebox.Mellanox": "[Mm]ellanox",
+    "PC.Whitebox.Mellanox.SN": " SN",
+    "PC.Whitebox.Mellanox.SN.SN2100": " SN2100",
+    "PC.Whitebox.Mellanox.SN.SN2410": " SN2410",
+    "PC.Whitebox.Mellanox.SN.SN3700": " SN3700",
+    "PC.Whitebox.Mellanox.SN.SN4700": " SN4700",
+    "PC.Whitebox.Edgecore": "[Ee]dge-?[Cc]ore",
+    "PC.Whitebox.Edgecore.AS": "AS",
+    "PC.Whitebox.Edgecore.AS9736": "AS9736",
+    "PC.Moxa": "[Mm]oxa",
+    "PC.Moxa.NPort": " [Nn][Pp]ort",
+    "PC.Moxa.NPort.6610": "6610",
+
+    "RouterOS": "^([Rr]outer[Oo][Ss]|[Mm]ikro[Tt]ik)",
+
+    "Aruba": "^Aruba",
+    "Aruba.AP": " I?AP-",
+    "Aruba.AP.AP200": " AP-2\\d\\d",
+    "Aruba.AP.AP200.AP224": " AP-224",
+    "Aruba.AP.AP200.AP225": " AP-225",
+    "Aruba.AP.AP300": " AP-3\\d\\d",
+    "Aruba.AP.AP300.AP367": " AP-367",
+    "Aruba.AP.AP300.AP377": " AP-377",
+    "Aruba.AP.AP500": " AP-5\\d\\d",
+    "Aruba.AP.AP500.AP514": " AP-514",
+    "Aruba.AP.AP500.AP515": " AP-515",
+    "Aruba.AP.IAP": " IAP-",
+    "Aruba.AP.IAP.IAP300": " IAP-3\\d\\d",
+    "Aruba.AP.IAP.IAP300.IAP304": " IAP-304",
+    "Aruba.AP.IAP.IAP300.IAP324": " IAP-324",
+    "Aruba.AP.IAP.IAP300.IAP325": " IAP-325",
+
+    "Ribbon": "^Ribbon",
+    "Ribbon.OPT": " OPT",
+    "Ribbon.OPT.OPT9608": "9608D?"
+}

annet/annlib/netdev/views/dump.py

@@ -0,0 +1,121 @@
+import inspect
+import sys
+import traceback
+
+
+class DumpResult(str):
+    """
+    строка, у которой repr = value
+    """
+    def __new__(cls, value):
+        return super().__new__(cls, value)
+
+    __repr__ = str.__str__
+
+
+class _EnumAllAttrs:
+    pass
+
+
+class DumpableView:
+    def _enum_attrs(self):
+        for attr in dir(self):
+            if not attr.startswith("_") and attr != "dump":
+                yield attr
+
+    def _getter_for_dump(self, attr):
+        dumper_name = "_dump_" + attr
+        if hasattr(self, dumper_name) and callable(getattr(self, dumper_name)):
+            return getattr(self, dumper_name)
+
+    @staticmethod
+    def strip_dumper(attr, lines=None, chars=None, chars_in_line=None):
+        def bound_method(self):
+            lines_list = []
+            value = getattr(self, attr)
+            assert isinstance(value, str)
+            total_lines = 0
+            total_chars = 0
+            add_tail = True
+            for line in value.split("\n"):
+                if lines and total_lines >= lines:
+                    break
+
+                if chars and total_chars + len(line) >= chars:
+                    lines_list.append(line[chars - total_chars:])
+                    break
+
+                if chars_in_line and len(line) > chars_in_line:
+                    lines_list.append(line[chars - total_chars:] + " ...")
+                else:
+                    lines_list.append(line)
+                total_lines += 1
+                total_chars += len(line) + 1
+            else:
+                add_tail = False
+
+            ret = repr("\n".join(lines_list))
+            if add_tail:
+                ret += " ..."
+            return DumpResult(ret)
+        return bound_method
+
+    def __dump_value(self, prefix, value, seen):
+        ret = []
+        op = "="
+        if isinstance(value, DumpableView):
+            # защита от рекурсии - последующие ссылки на объекты, а не новые дампы
+            if id(value) in seen:
+                value = DumpResult(seen[id(value)])
+                op = "->"
+            else:
+                seen[id(value)] = prefix
+
+        if isinstance(value, DumpableView):
+            ret += value.dump(prefix, seen=seen)  # pylint: disable=no-member
+        else:
+            fmt = repr(value)
+            vtype = type(value)
+            if not isinstance(value, DumpResult) and (vtype.__module__ != "builtins") and vtype.__name__ not in fmt:
+                fmt += "  # %s" % (vtype)
+            ret += ["%s %s %s" % (prefix, op, fmt)]
+        return ret
+
+    def dump(self, prefix="", value=_EnumAllAttrs, seen=None):
+        """
+        В собственных DumpableView-классах нужно определить dump примерно так:
+        def dump(self, prefix, **kwargs):
+            ret = super().dump(prefix, **kwargs) + [ your_own_lines ]
+        """
+        if seen is None:
+            seen = {id(self): prefix}
+
+        ret = []
+        if value is not _EnumAllAttrs:
+            ret.extend(self.__dump_value(prefix, value, seen))
+        else:
+            for attr in self._enum_attrs():
+                getter = self._getter_for_dump(attr)
+                try:
+                    if getter:
+                        value = getter()
+                    else:
+                        value = getattr(self, attr)
+                        if inspect.isroutine(value):
+                            continue
+                except Exception as exc:
+                    exc_tb = sys.exc_info()[2]
+                    frame_index = -1
+                    tb_list = traceback.extract_tb(exc_tb)
+                    value = DumpResult("%r at %s:%s" % (exc, tb_list[frame_index][0], tb_list[frame_index][1]))
+
+                ret.extend(self.__dump_value("%s.%s" % (prefix, attr), value, seen))
+        return ret
+
+    # Filter out cached lru_methods from state
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        for key in list(state.keys()):  # For thread-safe: dictionary changed size during iteration
+            if inspect.ismethod(state[key]):
+                del state[key]
+        return state

annet/annlib/netdev/views/hardware.py

@@ -0,0 +1,112 @@
+from typing import Optional
+
+from annet.annlib.netdev.devdb import parse_hw_model
+
+from .dump import DumpableView
+
+
+class HardwareLeaf(DumpableView):
+    def __new__(cls, *_, **__):
+        obj = super(HardwareLeaf, cls).__new__(cls)
+        obj.__path = ()
+        obj.__true_sequences = set()
+        obj.__false_sequences = set()
+        return obj
+
+    def __init__(self, path, true_sequences, false_sequences):
+        self.__path = path
+        self.__true_sequences = true_sequences
+        self.__false_sequences = false_sequences
+
+    def __bool__(self):
+        if len(self.__path) == 0 or self.__path in self.__true_sequences:
+            return True
+        elif self.__path in self.__false_sequences:
+            return False
+        raise AttributeError("HW: " + ".".join(self.__path))
+
+    def __getattr__(self, name):
+        path = self.__path + (name,)
+        if path in self.__true_sequences or path in self.__false_sequences:
+            return HardwareLeaf(path, self.__true_sequences, self.__false_sequences)
+        try:
+            return self.__dict__[name]
+        except KeyError:
+            raise AttributeError("HW: " + ".".join(path))
+
+    def __str__(self):
+        return str(" | ".join(".".join(x) for x in self.__true_sequences))
+
+    __repr__ = __str__
+
+    def dump(self, prefix, **kwargs):  # pylint: disable=arguments-differ
+        ret = super().dump(prefix, **kwargs)
+        seen = set()
+        for seq in sorted(self.__true_sequences, key=len, reverse=True):
+            if any(name in seen for name in seq):
+                continue
+            seen.update(seq)
+            ret.append("%s.%s = True" % (prefix, ".".join(seq)))
+        return ret
+
+
+class HardwareView(HardwareLeaf):
+    def __init__(self, hw_model, sw_version):
+        (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)
+
+    def __hash__(self):
+        return hash(self.model)
+
+    def __eq__(self, other):
+        return self.model == other.model
+
+
+def hw_to_vendor(hw: HardwareView) -> Optional[str]:
+    if hw.Nexus:
+        return "nexus"
+    elif hw.Cisco:
+        return "cisco"
+    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"
+    return None
+
+
+def vendor_to_hw(vendor):
+    hw = HardwareView(
+        {
+            "cisco": "Cisco",
+            "catalyst": "Cisco Catalyst",
+            "nexus": "Cisco Nexus",
+            "huawei": "Huawei",
+            "juniper": "Juniper",
+            "arista": "Arista",
+            "pc": "PC",
+            "nokia": "Nokia",
+            "aruba": "Aruba",
+            "routeros": "RouterOS",
+            "ribbon": "Ribbon",
+        }.get(vendor.lower(), vendor),
+        None,
+    )
+    return hw

annet/annlib/output.py

@@ -0,0 +1,246 @@
+import abc
+import dataclasses
+import enum
+import io
+import json
+import os
+import sys
+import types
+from collections import OrderedDict as odict
+from contextlib import contextmanager
+from typing import Any, List, Pattern
+
+import colorama
+import pygments
+import pygments.formatters
+import pygments.lexers.data
+import yaml
+
+LABEL_NEW_PREFIX = "new: "
+
+
+# =====
+class OutputWriter:
+    def __init__(self, data):
+        self.data = data
+
+    def write(self, file):
+        if isinstance(self.data, types.GeneratorType):
+            for n in self.data:
+                file.write(n)
+            return
+        file.write(self.data)
+
+        if self.data and self.data[-1:] != "\n":
+            file.write("\n")
+
+
+class YamlWriter(OutputWriter):
+    def write(self, file):
+        print_as_yaml(self.data, file)
+
+
+class JsonWriter(OutputWriter):
+    def write(self, file):
+        print_as_json(self.data, file)
+
+
+def dir_or_file_output(dest, items_count, create_dir=True, suggest_dir=False):
+    if dest is None:
+        dest = ""
+
+    dir_mode = dest.endswith(os.sep) or suggest_dir or dest not in ("-", "") and items_count > 1
+
+    if os.path.exists(dest):
+        is_dir = os.path.isdir(dest)
+        if dir_mode and not is_dir:
+            raise EnvironmentError(
+                f"Output set to dir {dest}, but file with the same name is on the way"
+            )
+        dir_mode = dir_mode or is_dir
+    elif create_dir and dest not in ("-", ""):
+        pdir = dest if dir_mode else os.path.dirname(dest)
+        if pdir:
+            os.makedirs(pdir, exist_ok=True)
+
+    return dir_mode
+
+
+def print_label(label, back_color=colorama.Back.GREEN, file=None):
+    if file is None:
+        file = sys.stdout
+    tty = bool(os.isatty(file.fileno()))
+    print("%s%s# %s %s %s%s%s" % (
+        colorama.Style.BRIGHT * tty, back_color * tty,
+        "-" * 20, label, "-" * 20,
+        colorama.Back.RESET * tty, colorama.Style.RESET_ALL * tty,
+    ), file=file)
+
+
+def print_err_label(label):
+    print_label(label, colorama.Back.RED)
+
+
+def print_as_yaml(data, fh=sys.stdout):
+    class UnsortableTuple(tuple):
+        def __lt__(self, _):
+            raise TypeError
+
+    class Dumper(yaml.Dumper):
+        def ignore_aliases(self, data):
+            return True
+
+        def represent_ordered_dict(self, data):
+            return self.represent_dict([UnsortableTuple(item) for item in data.items()])
+
+    Dumper.add_representer(odict, Dumper.represent_ordered_dict)
+
+    def yaml_dump(data, **kwargs):
+        return yaml.dump(data, allow_unicode=True, indent=4, Dumper=Dumper, **kwargs)
+
+    if fh.isatty():
+        pygments.highlight(
+            code=yaml_dump(data, width=os.get_terminal_size().columns),
+            lexer=pygments.lexers.data.YamlLexer(),
+            formatter=pygments.formatters.TerminalFormatter(bg="dark"),
+            outfile=fh,
+        )
+    else:
+        fh.write(yaml_dump(data))
+
+
+class Dumpable(abc.ABC):
+    def dump(self) -> Any:
+        pass
+
+
+def print_as_json(data, fh=sys.stdout):
+    """
+    В выводе dict ключи отсортированы по имени, кроме ключей в OrderedDict,
+    которые сохраняют свой оригинальный порядок
+    """
+
+    class ODictKey(str):
+        """
+        Строка с дополнительным параметром :index, по которому сортируется
+        """
+
+        @staticmethod
+        def __new__(cls, str_value, index=0):
+            self = str.__new__(cls, str_value)
+            self.ind = index
+            return self
+
+        def __lt__(self, other):
+            assert type(self) is type(other)
+            return (self.ind, self) < (other.ind, other)  # pylint: disable=no-member
+
+    class UnsortableOdict(odict):
+        """
+        Разновидность OrderedDict, ключи которого сохраняют порядок
+        при попытке строковой сортировки (содержат доп. индекс)
+        """
+
+        def __init__(self, orig):
+            super().__init__((ODictKey(key, index), value)
+                             for (index, (key, value)) in enumerate(orig.items()))
+
+        @staticmethod
+        def convert_odicts(data):
+            self = UnsortableOdict.convert_odicts
+            if isinstance(data, dict):
+                data = type(data)((key, self(value)) for (key, value) in data.items())
+            elif isinstance(data, (tuple, list)):
+                data = type(data)(self(value) for value in data)
+            if isinstance(data, odict):
+                data = UnsortableOdict(data)
+            return data
+
+    class JsonEncoder(json.JSONEncoder):
+        def default(self, o):
+            # https://github.com/PyCQA/pylint/issues/3537
+            if isinstance(o, Pattern):  # pylint: disable=isinstance-second-argument-not-valid-type
+                return "(regex obj)/" + o.pattern + "/ (not a string)"
+            elif isinstance(o, Dumpable):
+                return o.dump()
+            elif dataclasses.is_dataclass(o):
+                return dataclasses.asdict(o)
+            elif isinstance(o, enum.Enum):
+                return o.value
+
+            raise TypeError("can't serialize %r to json" % o)
+
+        def encode(self, o):
+            try:
+                return super().encode(o)
+            except TypeError:
+                raise TypeError("can't serialize %r to json" % o)
+
+    dump = json.dumps(UnsortableOdict.convert_odicts(data), cls=JsonEncoder,
+                      ensure_ascii=False, indent=4, sort_keys=True) + "\n"
+    if fh.isatty():
+        pygments.highlight(
+            code=dump,
+            lexer=pygments.lexers.data.JsonLexer(),
+            formatter=pygments.formatters.TerminalFormatter(bg="dark"),
+            outfile=fh,
+        )
+    else:
+        fh.write(dump)
+
+
+class TextArgs:
+    __slots__ = ("text", "color", "offset")
+
+    def __init__(self, text, color=None, offset=None):
+        self.text = text
+        self.color = color
+        self.offset = offset  # смещение от начала линии
+
+    def __repr__(self):
+        return "%s(%r, %s, %s)" % (self.__class__.__name__, self.text, self.color, self.offset)
+
+
+# =====
+@contextmanager
+def capture_output(new_stdout: io.BufferedRandom = None, new_stderr: io.BufferedRandom = None):
+    streams = (
+        (sys.stdout, new_stdout),
+        (sys.stderr, new_stderr),
+    )
+    backup = []
+    for (std_stream, new_stream) in streams:
+        if new_stream is not None:
+            new_stream.seek(0)
+            new_stream.truncate(0)
+            std_fd = std_stream.fileno()
+            std_stream.flush()
+            backup.append((std_fd, os.fdopen(os.dup(std_fd), "w"), new_stream))
+            os.dup2(new_stream.fileno(), std_fd)
+    try:
+        yield
+    finally:
+        for (std_fd, backup_stream, stream) in backup:
+            backup_stream.flush()
+            os.dup2(backup_stream.fileno(), std_fd)
+            backup_stream.close()
+            stream.seek(0)
+
+
+def format_file_diff(diff_lines: List[str]) -> List[str]:
+    colors = (
+        ("+++", colorama.Fore.CYAN),
+        ("---", colorama.Fore.CYAN),
+        ("@@", colorama.Fore.CYAN),
+        ("+", colorama.Fore.GREEN),
+        ("-", colorama.Fore.RED),
+    )
+    ret = []
+    for line in diff_lines:
+        for (check, color) in colors:
+            if line.startswith(check):
+                ret.append(color + line + colorama.Fore.RESET)
+                break
+        else:
+            ret.append(line)
+    return ret