annet 3.19.0__py3-none-any.whl → 3.20.1__py3-none-any.whl

annet/annlib/rbparser/syntax.py

@@ -72,19 +72,15 @@ def _parse_tree_with_params(raw_tree, scheme, context=None):
     return tree
 
 
-def _parse_raw_rule(raw_rule, scheme):
-    try:
-        index = raw_rule.index("%")
-        params = {
-            key: (value.strip() if len(value.strip()) != 0 else "1")
-            for (key, value) in re.findall(r"%([a-zA-Z_]\w*)(?:=([^%]*))?", raw_rule[index:])
-        }
-        if params:
-            raw_rule = raw_rule[:index].strip()
-    except ValueError:
-        params = {}
+def _parse_raw_rule(raw_rule: str, scheme) -> tuple[str, dict[str, str]]:
+    params: dict[str, str] = {}
+
+    row, *params_raw = re.split(r"(?:^|\s)%(?=[a-zA-Z_]\w*)", raw_rule)
+    for param in params_raw:
+        name, _, value = param.partition("=")
+        params[name] = value.strip() or "1"
 
-    row = re.sub(r"\s+", " ", raw_rule.strip())
+    row = re.sub(r"\s+", " ", row.strip())
     params = _fill_and_validate(params, scheme, raw_rule)
     return row, params
 

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/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/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/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/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/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/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.dist-info → annet-3.20.1.dist-info}/METADATA

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

{annet-3.19.0.dist-info → annet-3.20.1.dist-info}/RECORD

@@ -72,21 +72,22 @@ annet/annlib/rbparser/acl.py,sha256=I_1VUZQgF-s4dYTxyEDxQ-GkAP2MeXonzzsc2xROpTM,
 annet/annlib/rbparser/deploying.py,sha256=ACT8QNhDAhJx3ZKuGh2nYBOrpdka2qEKuLDxvQAGKLk,1649
 annet/annlib/rbparser/ordering.py,sha256=XknggB92N4IbhHBZZHL0StwCCITt8mkho4D4Nu5Kb4k,2185
 annet/annlib/rbparser/platform.py,sha256=wndmmg3ds2PS-g8vq_Iq4lCLUcK6J6YaJq-RspsqYGE,36
-annet/annlib/rbparser/syntax.py,sha256=Q-AIjoRnM54pNLKknAxmGdXLg5vpikh6Lal-J330TjY,3530
+annet/annlib/rbparser/syntax.py,sha256=tX_Ukp64k0k-4rZApaXGPgKWOUPoqbktVwOjewOlccQ,3437
 annet/annlib/rulebook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/annlib/rulebook/common.py,sha256=6A3sOkOanDRTuR7F426zakShGaGKRBmBLDCnqBbBJr8,13531
 annet/api/__init__.py,sha256=5YzScmeCDsHiDhtT3RwY_lMuikRZ6o7CVrlnJCln2A8,34116
 annet/configs/context.yml,sha256=RVLrKLIHpCty7AGwOnmqf7Uu0iZQCn-AjYhophDJer8,259
 annet/configs/logging.yaml,sha256=EUagfir99QqA73Scc3k7sfQccbU3E1SvEQdyhLFtCl4,997
-annet/generators/__init__.py,sha256=LnW6G_7K5ScGYkFjFk7_QfuUaFAk5oTSHYaTaL6xUwA,16735
-annet/generators/base.py,sha256=iIDshBnA6Jb6gXz-qSm3L7gyK5_ZRCw05fVPeIjOEmY,3695
-annet/generators/entire.py,sha256=jFTbx9BKoiXMstq_QeesRH2yi01LHyYHxgCtvvwBmeM,2872
+annet/generators/__init__.py,sha256=jxQJ5rLeXHiWGJgwhqygmBgCJsxc6oG-E9gDI9LzLog,16818
+annet/generators/annotate.py,sha256=TG7ozOkQmjiz7BVAKRrXfvuekGBR5Wl1nKmA4PLkG_g,1188
+annet/generators/base.py,sha256=qvvxKFzvgJWGBUcw8_bK1oFKTc4AQotN4CCuICWHXSk,3850
+annet/generators/entire.py,sha256=H_xQ33GH8P696fnKBFFJs9NQcdX9h-gV3D-jJYtpX0U,2823
 annet/generators/exceptions.py,sha256=GPXTBgn2xZ3Ev_bdOPlfCLGRC1kQHe_dEq88S-uyi5s,151
-annet/generators/jsonfragment.py,sha256=Cl43t9_OtNWRxesk3B69h60KvD37tiK9W7sLLmppAT4,4379
-annet/generators/partial.py,sha256=XI01KDA--XwjSEU33SOQCCJZRXFq5boRz1uJA8lVA1g,3502
+annet/generators/jsonfragment.py,sha256=H_hmZTHwnm_cToUbBNQRLf_1LlOZgLuXpSWpCVZ177o,4212
+annet/generators/partial.py,sha256=lm6uCTUDgGq7MFPmnAOzGochNwu7nUVy7x2dvW9OkBI,3167
 annet/generators/perf.py,sha256=IaAcfEVtX7UNO11VOCXzp-FPj_tOx_CDQ34HGThCn4c,2225
 annet/generators/ref.py,sha256=QVdeL8po1D0kBsVLOpCjFR81D8yNTk-kaQj5WUM4hng,438
-annet/generators/result.py,sha256=YFXKWHzTyNweF2ioVpKiH3IVSw475qLsqJPsCToWFFE,5187
+annet/generators/result.py,sha256=XnVaCsRVAKxlARM7jFERu5KzGmWFrJJJ_FcMuqp7mwQ,5136
 annet/generators/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/generators/common/initial.py,sha256=qYBxXFhyOPy34cxc6hsIXseod-lYCmmbuNHpM0uteY0,1244
 annet/mesh/__init__.py,sha256=lcgdnBIxc2MAN7Er1bcErEKPqrjWO4uIp_1FldMXTYg,557
@@ -208,8 +209,8 @@ annet/vendors/library/optixtrans.py,sha256=VdME69Ca4HAEgoaKN21fZxnmmsqqaxOe_HZja
 annet/vendors/library/pc.py,sha256=vfv31_NPi7M-4AUDL89UcpawK2E6xvCpELA209cd1ho,1086
 annet/vendors/library/ribbon.py,sha256=DDOBq-_-FL9dCxqXs2inEWZ-pvw-dJ-A-prA7cKMhec,1216
 annet/vendors/library/routeros.py,sha256=iQa7m_4wjuvcgBOI9gyZwlw1BvzJfOkvUbyoEk-NI9I,1254
-annet-3.19.0.dist-info/licenses/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
-annet-3.19.0.dist-info/licenses/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
+annet-3.20.1.dist-info/licenses/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
+annet-3.20.1.dist-info/licenses/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
 annet_generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet_generators/example/__init__.py,sha256=OJ77uj8axc-FIyIu_Xdcnzmde3oQW5mk5qbODkhuVc8,355
 annet_generators/example/hostname.py,sha256=RloLzNVetEoWPLITzfJ13Nk3CC0yi-cZB1RTd6dnuhI,2541
@@ -222,8 +223,8 @@ annet_generators/rpl_example/generator.py,sha256=EWah19gOH8G-QyNyWqxCqdRi0BK7GbM
 annet_generators/rpl_example/items.py,sha256=HPgxScDvSqJPdz0c2SppDrH82DZYC4zUaniQwcWmh4A,1176
 annet_generators/rpl_example/mesh.py,sha256=z_WgfDZZ4xnyh3cSf75igyH09hGvtexEVwy1gCD_DzA,288
 annet_generators/rpl_example/route_policy.py,sha256=z6nPb0VDeQtKD1NIg9sFvmUxBD5tVs2frfNIuKdM-5c,2318
-annet-3.19.0.dist-info/METADATA,sha256=X7dXwFQ2P044gFKaIKKs-nFXyE-QNGwhPGQvcP1OBJ8,906
-annet-3.19.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-annet-3.19.0.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
-annet-3.19.0.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
-annet-3.19.0.dist-info/RECORD,,
+annet-3.20.1.dist-info/METADATA,sha256=XrTRMmpU7-AcqJFX6fmimmMGmTSb2YCZ40NrhwZ6Tug,906
+annet-3.20.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+annet-3.20.1.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
+annet-3.20.1.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
+annet-3.20.1.dist-info/RECORD,,