annet 3.19.0__tar.gz → 3.20.0__tar.gz

{annet-3.19.0/annet.egg-info → annet-3.20.0}/PKG-INFO

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

{annet-3.19.0 → annet-3.20.0}/annet/generators/__init__.py

@@ -26,11 +26,12 @@ from annet.types import (
 )
 from annet.vendors import registry_connector, tabparser
 
+from .annotate import AbstractAnnotateFormatter, annotate_formatter_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 .exceptions import GeneratorError, InvalidValueFromGenerator, NotSupportedDevice
 from .jsonfragment import JSONFragment
 from .partial import PartialGenerator
 from .perf import GeneratorPerfMesurer
@@ -165,11 +166,10 @@ def _run_partial_generator(gen: "PartialGenerator", run_args: GeneratorPartialRu
     safe_config = odict()
 
     if not gen.supports_device(device):
-        logger.info("generator %s is not supported for device %s", gen, device.hostname)
+        logger.debug("generator %s is not supported for device %s", gen, device.hostname)
         return None
 
-    span = tracing_connector.get().get_current_span()
-    if span:
+    if span := tracing_connector.get().get_current_span():
         tracing_connector.get().set_device_attributes(span, run_args.device)
         tracing_connector.get().set_dimensions_attributes(span, gen, run_args.device)
         span.set_attributes({
@@ -184,8 +184,7 @@ def _run_partial_generator(gen: "PartialGenerator", run_args: GeneratorPartialRu
                 logger.info("Generating PARTIAL ...")
             try:
                 output = gen(device, run_args.annotate)
-            except NotSupportedDevice:
-                # это исключение нужно передать выше в оригинальном виде
+            except NotSupportedDevice:  # это исключение нужно передать выше в оригинальном виде
                 raise
             except Exception as err:
                 filename, lineno = gen.get_running_line()

annet-3.20.0/annet/generators/annotate.py

@@ -0,0 +1,37 @@
+import abc
+from types import GeneratorType
+
+from annet.connectors import Connector
+
+from .base import BaseGenerator
+
+
+class AbstractAnnotateFormatter(abc.ABC):
+    def __init__(self, gen: BaseGenerator):
+        self.gen = gen
+        self._annotation_module = ".".join(gen.__class__.__module__.split(".")[-2:])
+
+    @abc.abstractmethod
+    def make_annotation(self, running_gen: GeneratorType) -> str:
+        raise NotImplementedError
+
+    def get_running_line(self, running_gen: GeneratorType) -> tuple[str, int]:
+        if not running_gen or not running_gen.gi_frame:
+            return repr(running_gen), -1
+        return self._annotation_module, running_gen.gi_frame.f_lineno
+
+
+class DefaultAnnotateFormatter(AbstractAnnotateFormatter):
+    def make_annotation(self, running_gen: GeneratorType) -> str:
+        return "%s:%d" % self.get_running_line(running_gen)
+
+
+class _AnnotateFormatterConnector(Connector[AbstractAnnotateFormatter]):
+    name = "AnnotateFormatterConnector"
+    ep_name = "annotate_formatter"
+
+    def _get_default(self) -> type[AbstractAnnotateFormatter]:
+        return DefaultAnnotateFormatter
+
+
+annotate_formatter_connector = _AnnotateFormatterConnector()

{annet-3.19.0 → annet-3.20.0}/annet/generators/base.py

@@ -2,15 +2,20 @@ from __future__ import annotations
 
 import abc
 import contextlib
+import re
 import textwrap
-from typing import Union, List
+from typing import List, Union
 
 from annet import tracing
-from annet.vendors import tabparser
 from annet.tracing import tracing_connector
+from annet.vendors import tabparser
+
 from .exceptions import InvalidValueFromGenerator
 
 
+NONE_SEARCHER = re.compile(r"\bNone\b")
+
+
 class DefaultBlockIfCondition:
     pass
 
@@ -53,11 +58,15 @@ def _split_and_strip(text):
 # =====
 class BaseGenerator:
     TYPE: str
-    TAGS: List[str]
+    TAGS: List[str] = []
 
     def supports_device(self, device) -> bool:  # pylint: disable=unused-argument
         return True
 
+    @classmethod
+    def get_aliases(cls) -> set[str]:
+        return {cls.__name__, *cls.TAGS}
+
 
 class TreeGenerator(BaseGenerator):
     def __init__(self, indent="  "):

{annet-3.19.0 → annet-3.20.0}/annet/generators/entire.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 
 import pkgutil
-import re
 import types
-from typing import FrozenSet, Iterable, List, Optional, Set, Union
+from typing import FrozenSet, Iterable, List, Optional, Union
 
 from annet.lib import flatten, mako_render
 
-from .base import BaseGenerator, _filter_str
-from .exceptions import NotSupportedDevice
+from .base import NONE_SEARCHER, BaseGenerator, _filter_str
+from .exceptions import InvalidValueFromGenerator
 
 
 class Entire(BaseGenerator):
@@ -62,10 +61,6 @@ class Entire(BaseGenerator):
 
     # =====
 
-    @classmethod
-    def get_aliases(cls) -> Set[str]:
-        return {cls.__name__, *cls.TAGS}
-
     def __call__(self, device):
         self.__device = device
         parts = []
@@ -73,15 +68,19 @@ class Entire(BaseGenerator):
         if isinstance(run_res, str):
             run_res = (run_res,)
         if run_res is None or not isinstance(run_res, (tuple, types.GeneratorType)):
-            raise Exception("generator %s returns %s" % (
-                self.__class__.__name__, type(run_res)))
+            raise Exception("generator %s returns %s" % (self.__class__.__name__, type(run_res)))
+
         for text in run_res:
             if isinstance(text, tuple):
                 text = " ".join(map(_filter_str, flatten(text)))
-            assert re.search(r"\bNone\b", text) is None, \
-                "Found 'None' in yield result: %s" % text
+            if NONE_SEARCHER.search(text):
+                raise InvalidValueFromGenerator(
+                    "Found 'None' in yield result: %s" % text
+                )
             parts.append(text)
+
         ret = "\n".join(parts)
         if self.ENSURE_END_NEWLINE and not ret.endswith("\n"):
             ret += "\n"
+
         return ret

{annet-3.19.0 → annet-3.20.0}/annet/generators/jsonfragment.py

@@ -1,16 +1,10 @@
 from __future__ import annotations
 
 import contextlib
-from typing import (
-    Any,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Union,
-)
+from typing import Any, Optional, Union
 
 from annet.storage import Device, Storage
+
 from .base import TreeGenerator, _filter_str
 
 
@@ -18,13 +12,12 @@ class JSONFragment(TreeGenerator):
     """Generates parts of JSON config file."""
 
     TYPE = "JSON_FRAGMENT"
-    TAGS: List[str] = []
 
     def __init__(self, storage: Storage):
         super().__init__()
         self.storage = storage
-        self._json_config: Dict[str, Any] = {}
-        self._config_pointer: List[str] = []
+        self._json_config: dict[str, Any] = {}
+        self._config_pointer: list[str] = []
 
         # if two generators edit same file, commands from generator with greater `reload_prio` will be used
         if not hasattr(self, "reload_prio"):
@@ -36,11 +29,7 @@ class JSONFragment(TreeGenerator):
     def path(self, device: Device) -> Optional[str]:
         raise NotImplementedError("Required PATH for JSON_FRAGMENT generator")
 
-    @classmethod
-    def get_aliases(cls) -> Set[str]:
-        return {cls.__name__, *cls.TAGS}
-
-    def acl(self, device: Device) -> Union[str, List[str]]:
+    def acl(self, device: Device) -> Union[str, list[str]]:
         """
         Restrict the generator to a specified ACL using JSON Pointer syntax.
 
@@ -48,7 +37,7 @@ class JSONFragment(TreeGenerator):
         """
         raise NotImplementedError("Required ACL for JSON_FRAGMENT generator")
 
-    def acl_safe(self, device: Device) -> Union[str, List[str]]:
+    def acl_safe(self, device: Device) -> Union[str, list[str]]:
         """
         Restrict the generator to a specified safe ACL using JSON Pointer syntax.
 

{annet-3.19.0 → annet-3.20.0}/annet/generators/partial.py

@@ -1,32 +1,23 @@
 from __future__ import annotations
 
-import re
-from typing import (
-    Iterable,
-    List,
-    Set,
-    Union,
-)
-
-from annet.lib import (
-    add_annotation,
-    flatten,
-)
-from .base import TreeGenerator, _filter_str
-from .exceptions import NotSupportedDevice
+from typing import Iterable, Union
+
+from annet.lib import add_annotation, flatten
+
+from .annotate import AbstractAnnotateFormatter, annotate_formatter_connector
+from .base import NONE_SEARCHER, TreeGenerator, _filter_str
+from .exceptions import InvalidValueFromGenerator
 
 
 class PartialGenerator(TreeGenerator):
     TYPE = "PARTIAL"
-    TAGS: List[str] = []
 
     def __init__(self, storage):
         super().__init__()
         self.storage = storage
-        self._annotate = False
         self._running_gen = None
+        self._annotate: AbstractAnnotateFormatter = annotate_formatter_connector.get(self)
         self._annotations = []
-        self._annotation_module = self.__class__.__module__ or ""
 
     def supports_device(self, device) -> bool:
         if self.__class__.run is PartialGenerator.run:
@@ -35,19 +26,19 @@ class PartialGenerator(TreeGenerator):
             return True
 
     def acl(self, device):
-        acl_func = self._get_vendor_func(device.hw.vendor, "acl")
-        if acl_func:
+        if acl_func := self._get_vendor_func(device.hw.vendor, "acl"):
             return acl_func(device)
+        return None
 
     def acl_safe(self, device):
-        acl_func = self._get_vendor_func(device.hw.vendor, "acl_safe")
-        if acl_func:
+        if acl_func := self._get_vendor_func(device.hw.vendor, "acl_safe"):
             return acl_func(device)
+        return None
 
-    def run(self, device) -> Iterable[Union[str, tuple]]:
-        run_func = self._get_vendor_func(device.hw.vendor, "run")
-        if run_func:
+    def run(self, device) -> Iterable[Union[str, tuple]] | None:
+        if run_func := self._get_vendor_func(device.hw.vendor, "run"):
             return run_func(device)
+        return None
 
     def get_user_runner(self, device):
         if self.__class__.run is not PartialGenerator.run:
@@ -56,26 +47,15 @@ class PartialGenerator(TreeGenerator):
 
     def _get_vendor_func(self, vendor: str, func_name: str):
         attr_name = f"{func_name}_{vendor}"
-        if hasattr(self, attr_name):
-            return getattr(self, attr_name)
-        return None
+        return getattr(self, attr_name, None)
 
     # =====
 
-    @classmethod
-    def get_aliases(cls) -> Set[str]:
-        return {cls.__name__, *cls.TAGS}
-
-    def __call__(self, device, annotate=False):
+    def __call__(self, device, annotate: bool = False):
         self._indents = []
         self._rows = []
-        self._running_gen = self.run(device)
-        self._annotate = annotate
-
-        if annotate and self.__class__.__module__:
-            self._annotation_module = ".".join(
-                self.__class__.__module__.split(".")[-2:])
 
+        self._running_gen = self.run(device)
         for text in self._running_gen:
             if isinstance(text, tuple):
                 text = " ".join(map(_filter_str, flatten(text)))
@@ -83,9 +63,12 @@ class PartialGenerator(TreeGenerator):
                 text = _filter_str(text)
             self._append_text(text)
 
-        for row in self._rows:
-            assert re.search(r"\bNone\b", row) is None, \
-                "Found 'None' in yield result: %s" % (row)
+        for (row, annotation) in zip(self._rows, self._annotations):
+            if NONE_SEARCHER.search(row):
+                raise InvalidValueFromGenerator(
+                    "Found 'None' in yield result: %s" % add_annotation(row, annotation)
+                )
+
         if annotate:
             generated_rows = (
                 add_annotation(x, y)
@@ -93,23 +76,20 @@ class PartialGenerator(TreeGenerator):
             )
         else:
             generated_rows = self._rows
-        return "\n".join(generated_rows) + "\n"
+
+        return "\n".join((*generated_rows, ""))
 
     def _append_text(self, text):
         def annotation_cb(row):
-            annotation = "%s:%d" % self.get_running_line()
-            self._annotations.append(annotation)
+            self._annotations.append(
+                self._annotate.make_annotation(self._running_gen)
+            )
             return row
 
-        self._append_text_cb(
-            text,
-            annotation_cb if self._annotate else None
-        )
+        self._append_text_cb(text, row_cb=annotation_cb)
 
-    def get_running_line(self):
-        if not self._running_gen or not self._running_gen.gi_frame:
-            return (repr(self._running_gen), -1)
-        return self._annotation_module, self._running_gen.gi_frame.f_lineno
+    def get_running_line(self) -> tuple[str, int]:
+        return self._annotate.get_running_line(self._running_gen)
 
     @classmethod
     def literal(cls, item):

{annet-3.19.0 → annet-3.20.0}/annet/generators/result.py

@@ -2,19 +2,10 @@ from __future__ import annotations
 
 import textwrap
 from collections import OrderedDict as odict
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Optional,
-    Sequence,
-    Tuple,
-)
+from typing import Any, Callable, Optional, Sequence
 
 from annet.annlib import jsontools
-from annet.lib import (
-    merge_dicts,
-)
+from annet.lib import merge_dicts
 from annet.reference import RefMatcher, RefTracker
 from annet.types import (
     GeneratorEntireResult,
@@ -24,7 +15,7 @@ from annet.types import (
 
 
 def _combine_acl_text(
-        partial_results: Dict[str, GeneratorPartialResult],
+        partial_results: dict[str, GeneratorPartialResult],
         acl_getter: Callable[[GeneratorPartialResult], str]
 ) -> str:
     acl_text = ""
@@ -43,9 +34,9 @@ class RunGeneratorResult:
     """
 
     def __init__(self):
-        self.partial_results: Dict[str, GeneratorPartialResult] = {}
-        self.entire_results: Dict[str, GeneratorEntireResult] = {}
-        self.json_fragment_results: Dict[str, GeneratorJSONFragmentResult] = {}
+        self.partial_results: dict[str, GeneratorPartialResult] = {}
+        self.entire_results: dict[str, GeneratorEntireResult] = {}
+        self.json_fragment_results: dict[str, GeneratorJSONFragmentResult] = {}
         self.ref_track: RefTracker = RefTracker()
         self.ref_matcher: RefMatcher = RefMatcher()
 
@@ -62,14 +53,14 @@ class RunGeneratorResult:
     def add_json_fragment(self, result: GeneratorJSONFragmentResult) -> None:
         self.json_fragment_results[result.name] = result
 
-    def config_tree(self, safe: bool = False) -> Dict[str, Any]:  # OrderedDict
+    def config_tree(self, safe: bool = False) -> dict[str, Any]:  # OrderedDict
         tree = odict()
         for gr in self.partial_results.values():
             config = gr.safe_config if safe else gr.config
             tree = merge_dicts(tree, config)
         return tree
 
-    def new_files(self, safe: bool = False) -> Dict[str, Tuple[str, str]]:
+    def new_files(self, safe: bool = False) -> dict[str, tuple[str, str]]:
         files = {}
         for gr in self.entire_results.values():
             if not safe or gr.is_safe:
@@ -84,14 +75,14 @@ class RunGeneratorResult:
 
     def new_json_fragment_files(
             self,
-            old_files: Dict[str, Optional[str]],
+            old_files: dict[str, Optional[str]],
             use_acl: bool = True,
             safe: bool = False,
             filters: Sequence[str] | None = None,
-    ) -> Dict[str, Tuple[Any, Optional[str]]]:
+    ) -> dict[str, tuple[Any, Optional[str]]]:
         # TODO: safe
-        files: Dict[str, Tuple[Any, Optional[str]]] = {}
-        reload_prios: Dict[str, int] = {}
+        files: dict[str, tuple[Any, Optional[str]]] = {}
+        reload_prios: dict[str, int] = {}
         for generator_result in self.json_fragment_results.values():
             filepath = generator_result.path
             if filepath not in files:
@@ -105,7 +96,7 @@ class RunGeneratorResult:
                     result_acl = generator_result.acl_safe
             else:
                 result_acl = None
-            previous_config: Dict[str, Any] = files[filepath][0]
+            previous_config: dict[str, Any] = files[filepath][0]
             new_fragment = generator_result.config
             new_config = jsontools.apply_json_fragment(
                 previous_config, new_fragment,
@@ -126,7 +117,7 @@ class RunGeneratorResult:
             files[filepath] = (new_config, reload_cmd)
         return files
 
-    def perf_mesures(self) -> Dict[str, Dict[str, int]]:
+    def perf_mesures(self) -> dict[str, dict[str, int]]:
         mesures = {}
         for gr in self.partial_results.values():
             mesures[gr.name] = {"total": gr.perf.total,

{annet-3.19.0 → annet-3.20.0/annet.egg-info}/PKG-INFO

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

{annet-3.19.0 → annet-3.20.0}/annet.egg-info/SOURCES.txt

@@ -91,6 +91,7 @@ annet/api/__init__.py
 annet/configs/context.yml
 annet/configs/logging.yaml
 annet/generators/__init__.py
+annet/generators/annotate.py
 annet/generators/base.py
 annet/generators/entire.py
 annet/generators/exceptions.py