annet 2.2.2__py3-none-any.whl → 2.3.1__py3-none-any.whl

annet/api/__init__.py

@@ -1,4 +1,5 @@
 import abc
+import inspect
 import os
 import re
 import sys
@@ -8,16 +9,14 @@ from collections import OrderedDict as odict
 from itertools import groupby, chain
 from operator import itemgetter
 from typing import (
-    Any,
     Dict,
     Generator,
     Iterable,
     List,
     Mapping,
-    Optional,
     Set,
     Tuple,
-    Union, cast,
+    Union, cast, Any,
 )
 
 import colorama
@@ -41,7 +40,6 @@ from annet.rulebook import deploying
 from annet.filtering import Filterer
 from annet.hardware import hardware_connector
 from annet.output import (
-    LABEL_NEW_PREFIX,
     format_file_diff,
     output_driver_connector,
     print_err_label,
@@ -51,7 +49,6 @@ from annet.reference import RefTracker
 from annet.storage import Device, get_storage
 from annet.types import Diff, ExitCode, OldNewResult, Op, PCDiff, PCDiffFile
 
-
 DEFAULT_INDENT = "  "
 
 
@@ -240,15 +237,6 @@ def gen(args: cli_args.ShowGenOptions, loader: ann_gen.Loader):
 
 
 # =====
-def _diff_files(hw, old_files, new_files):
-    ret = {}
-    differ = file_differ_connector.get()
-    for (path, (new_text, reload_data)) in new_files.items():
-        old_text = old_files.get(path)
-        is_new = old_text is None
-        diff_lines = differ.diff_file(hw, path, old_text, new_text)
-        ret[path] = (diff_lines, reload_data, is_new)
-    return ret
 
 
 def patch(args: cli_args.ShowPatchOptions, loader: ann_gen.Loader):
@@ -322,62 +310,41 @@ def res_diff_patch(
 
 
 def diff(
-        args: cli_args.DiffOptions,
-        loader: ann_gen.Loader,
-        device_ids: List[int],
-        filterer: filtering.Filterer,
-) -> Mapping[Device, Union[Diff, PCDiff]]:
-    ret = {}
-    for res in ann_gen.old_new(
-        args,
-        config=args.config,
-        loader=loader,
-        no_new=args.clear,
-        do_files_download=True,
-        device_ids=device_ids,
-        filterer=filterer,
-    ):
-        old = res.get_old(args.acl_safe)
-        new = res.get_new(args.acl_safe)
-        device = res.device
-        acl_rules = res.get_acl_rules(args.acl_safe)
-        new_files = res.get_new_files(args.acl_safe)
-        new_json_fragment_files = res.get_new_file_fragments(args.acl_safe)
-
-        pc_diff_files = []
-        if res.old_files or new_files:
-            pc_diff_files.extend(_pc_diff(res.device.hw, device.hostname, res.old_files, new_files))
-        if res.old_json_fragment_files or new_json_fragment_files:
-            pc_diff_files.extend(_json_fragment_diff(res.device.hw, device.hostname, res.old_json_fragment_files, new_json_fragment_files))
+    args: cli_args.DiffOptions,
+    loader: ann_gen.Loader,
+    device_ids: List[Any]
+) -> tuple[Mapping[Device, Union[Diff, PCDiff]], Mapping[Device, Exception]]:
+    """ Сгенерировать конфиг для устройств """
+    stdin = args.stdin(filter_acl=args.filter_acl, config=None)
 
-        if pc_diff_files:
-            pc_diff_files.sort(key=lambda f: f.label)
-            ret[device] = PCDiff(hostname=device.hostname, diff_files=pc_diff_files)
-        elif old is not None:
-            orderer = patching.Orderer.from_hw(device.hw)
-            rb = rulebook.get_rulebook(device.hw)
-            diff_tree = patching.make_diff(
-                old,
-                orderer.order_config(new),
-                rb,
-                [acl_rules, res.filter_acl_rules],
-            )
-            diff_tree = patching.strip_unchanged(diff_tree)
-            ret[device] = diff_tree
+    filterer = filtering.filterer_connector.get()
+    pool = Parallel(ann_diff.worker, args, stdin, loader, filterer).tune_args(args)
+    if args.show_hosts_progress:
+        fqdns = {k: v for k, v in loader.device_fqdns.items() if k in device_ids}
+        pool.add_callback(PoolProgressLogger(fqdns))
 
-    return ret
+    return pool.run(device_ids, args.tolerate_fails, args.strict_exit_code)
 
 
-def collapse_texts(texts: Mapping[str, str]) -> Mapping[Tuple[str, ...], str]:
+def collapse_texts(texts: Mapping[str, str | Generator[str, None, None]]) -> Mapping[Tuple[str, ...], str]:
     """
     Группировка текстов.
     :param texts:
     :return: словарь с несколькими хостнеймами в ключе.
     """
-    diffs_with_orig = {key: [value, value.splitlines()] for key, value in texts.items()}
+    diffs_with_orig = {}
+    for key, value in texts.items():
+        if inspect.isgenerator(value):
+            lines = list(value)
+            diffs_with_orig[key] = ["".join(lines), lines]
+        else:
+            diffs_with_orig[key] = [value, value.splitlines()]
+
     res = {}
-    for _, collapsed_diff_iter in groupby(sorted(diffs_with_orig.items(), key=lambda x: (x[0], x[1][1])),
-                                          key=lambda x: x[1][1]):
+    for _, collapsed_diff_iter in groupby(
+        sorted(diffs_with_orig.items(), key=lambda x: (x[0], x[1][1])),
+        key=lambda x: x[1][1]
+    ):
         collapsed_diff = list(collapsed_diff_iter)
         res[tuple(x[0] for x in collapsed_diff)] = collapsed_diff[0][1][0]
 
@@ -535,7 +502,6 @@ class Deployer:
 
         self._collapseable_diffs = {}
         self._diff_lines: List[str] = []
-        self._filterer = filtering.filterer_connector.get()
 
     def parse_result(self, job: DeployerJob, result: ann_gen.OldNewResult):
         logger = get_logger(job.device.hostname)
@@ -629,14 +595,28 @@ class Deployer:
             self.args,
             config="running",
         )
+
         if diff_args.query:
             ann_gen.live_configs = None
-            diffs = diff(diff_args, loader, success_device_ids, self._filterer)
-            non_pc_diffs = {dev: diff for dev, diff in diffs.items() if not isinstance(diff, PCDiff)}
+
+            diffs, failed = diff(diff_args, loader, success_device_ids)
+            for device_id, exc in failed.items():
+                self.failed_configs[loader.get_device(device_id).fqdn] = exc
+
+            non_pc_diffs = {
+                loader.get_device(device_id): diff
+                for device_id, diff in diffs.items()
+                if not isinstance(diff, PCDiff)
+            }
             devices_to_diff = ann_diff.collapse_diffs(non_pc_diffs)
-            devices_to_diff.update({(dev,): diff for dev, diff in diffs.items() if isinstance(diff, PCDiff)})
+            devices_to_diff.update({
+                (loader.get_device(device_id),): diff
+                for device_id, diff in diffs.items()
+                if isinstance(diff, PCDiff)}
+            )
         else:
             devices_to_diff = {}
+
         for devices, diff_obj in devices_to_diff.items():
             if diff_obj:
                 for dev in devices:
@@ -744,8 +724,10 @@ def file_diff(args: cli_args.FileDiffOptions):
     return pool.run(old_new, tolerate_fails=True)
 
 
-def file_diff_worker(old_new: Tuple[str, str], args: cli_args.FileDiffOptions) -> Generator[
-    Tuple[str, str, bool], None, None]:
+def file_diff_worker(
+    old_new: Tuple[str, str],
+    args: cli_args.FileDiffOptions
+) -> Generator[Tuple[str, str, bool], None, None]:
     old_path, new_path = old_new
     hw = args.hw
     if isinstance(args.hw, str):
@@ -753,10 +735,12 @@ def file_diff_worker(old_new: Tuple[str, str], args: cli_args.FileDiffOptions) -
 
     if os.path.isdir(old_path) and os.path.isdir(new_path):
         hostname = os.path.basename(new_path)
-        new_files = {relative_cfg_path: (cfg_text, "") for relative_cfg_path, cfg_text in
-                     ann_gen.load_pc_config(new_path).items()}
+        new_files = {
+            relative_cfg_path: (cfg_text, "")
+            for relative_cfg_path, cfg_text in ann_gen.load_pc_config(new_path).items()
+        }
         old_files = ann_gen.load_pc_config(old_path)
-        for diff_file in _pc_diff(hw, hostname, old_files, new_files):
+        for diff_file in ann_diff.pc_diff(hw, hostname, old_files, new_files):
             diff_text = (
                 "\n".join(diff_file.diff_lines)
                 if args.no_color
@@ -796,39 +780,6 @@ def file_patch_worker(old_new: Tuple[str, str], args: cli_args.FileDiffOptions)
             yield dest_name, patch_text, False
 
 
-def _pc_diff(hw, hostname: str, old_files: Dict[str, str], new_files: Dict[str, str]) -> Generator[PCDiffFile, None, None]:
-    sorted_lines = sorted(_diff_files(hw, old_files, new_files).items())
-    for (path, (diff_lines, _reload_data, is_new)) in sorted_lines:
-        if not diff_lines:
-            continue
-        label = hostname + os.sep + path
-        if is_new:
-            label = LABEL_NEW_PREFIX + label
-        yield PCDiffFile(label=label, diff_lines=diff_lines)
-
-
-def _json_fragment_diff(
-        hw,
-        hostname: str,
-        old_files: Dict[str, Any],
-        new_files: Dict[str, Tuple[Any, Optional[str]]],
-) -> Generator[PCDiffFile, None, None]:
-    def jsonify_multi(files):
-        return {
-            path: jsontools.format_json(cfg)
-            for path, cfg in files.items()
-        }
-
-    def jsonify_multi_with_cmd(files):
-        ret = {}
-        for path, cfg_reload_cmd in files.items():
-            cfg, reload_cmd = cfg_reload_cmd
-            ret[path] = (jsontools.format_json(cfg), reload_cmd)
-        return ret
-    jold, jnew = jsonify_multi(old_files), jsonify_multi_with_cmd(new_files)
-    return _pc_diff(hw, hostname, jold, jnew)
-
-
 def guess_hw(config_text: str):
     """Пытаемся угадать вендора и hw на основе
     текста конфига и annet/rulebook/texts/*.rul"""

annet/cli.py

@@ -113,6 +113,7 @@ def show_device_dump(args: cli_args.QueryOptions, arg_out: cli_args.FileOutOptio
                 )
             else:
                 get_logger().warning("method `dump` not implemented for %s", type(device))
+
     arg_gens = cli_args.GenOptions(arg_out, args)
     with get_loader(arg_gens, args) as loader:
         if not loader.devices:
@@ -190,7 +191,7 @@ def gen(args: cli_args.ShowGenOptions):
         output_driver = output_driver_connector.get()
         if args.dest is None:
             text_mapping = {item[0]: item[1] for item in out}
-            out = [(",".join(key), value, False) for key, value in collapse_texts(text_mapping).items()]
+            out = [(", ".join(key), value, False) for key, value in collapse_texts(text_mapping).items()]
 
         out.extend(output_driver.format_fails(fail, loader.device_fqdns))
         total = len(success) + len(fail)
@@ -203,13 +204,19 @@ def gen(args: cli_args.ShowGenOptions):
 def diff(args: cli_args.ShowDiffOptions):
     """ Generate configuration for devices and show a diff with current configuration using the rulebook """
     with get_loader(args, args) as loader:
-        filterer = filtering.filterer_connector.get()
-        device_ids = loader.device_ids
-        output_driver_connector.get().write_output(
-            args,
-            gen_sort_diff(api.diff(args, loader, device_ids, filterer), args),
-            len(loader.device_ids)
-        )
+        success, fail = api.diff(args, loader, loader.device_ids)
+
+        out = list(gen_sort_diff({loader.get_device(k): v for k, v in success.items()}, args))
+        output_driver = output_driver_connector.get()
+        if args.dest is None:
+            text_mapping = {item[0]: item[1] for item in out}
+            out = [(", ".join(key), value, False) for key, value in collapse_texts(text_mapping).items()]
+        out.extend(output_driver.format_fails(fail, loader.device_fqdns))
+
+        if total := len(success) + len(fail):
+            output_driver.write_output(args, out, total)
+        else:
+            get_logger().error("No devices found for %s", args.query)
 
 
 @subcommand(cli_args.ShowPatchOptions)

annet/cli_args.py

@@ -442,6 +442,7 @@ class FileOutOptions(ArgGroup):
 class DiffOptions(GenOptions, ComocutorOptions):
     clear = opt_clear
     config = opt_config
+    show_hosts_progress = opt_show_hosts_progress
 
 
 class FileInputOptions(ArgGroup):

annet/deploy.py

@@ -49,8 +49,8 @@ class ProgressBar(abc.ABC):
 
 
 class DeployResult(_DeployResultBase):  # noqa: E302
-    def add_results(self, results: dict[str, tuple[list[str], list[Exception]]]) -> None:
-        for hostname, (excs, result) in results.items():
+    def add_results(self, results: dict[str, Exception]) -> None:
+        for hostname, excs in results.items():
             self.hostnames.append(hostname)
             self.results[hostname] = excs
             self.durations[hostname] = 0.0

annet/diff.py

@@ -1,10 +1,13 @@
 import abc
 import difflib
+import os
 import re
 from itertools import groupby
 from pathlib import Path
-from typing import Generator, List, Mapping, Tuple, Union, Protocol
+from typing import Any, Dict, Generator, List, Mapping, Optional, Protocol, Tuple, Union
 
+from annet import cli_args, filtering, patching, rulebook, tabparser
+from annet.annlib import jsontools
 from annet.annlib.diff import (  # pylint: disable=unused-import
     colorize_line,
     diff_cmp,
@@ -13,23 +16,113 @@ from annet.annlib.diff import (  # pylint: disable=unused-import
     resort_diff,
 )
 from annet.annlib.netdev.views.hardware import HardwareView
-from annet.annlib.output import format_file_diff
-
-from annet import patching, rulebook, tabparser, hardware
+from annet.annlib.output import LABEL_NEW_PREFIX, format_file_diff
 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
+from annet.types import Diff, PCDiff, PCDiffFile
+
+from .gen import Loader, old_new
+
 
+def _diff_files(hw, old_files, new_files):
+    ret = {}
+    differ = file_differ_connector.get()
+    for (path, (new_text, reload_data)) in new_files.items():
+        old_text = old_files.get(path)
+        is_new = old_text is None
+        diff_lines = differ.diff_file(hw, path, old_text, new_text)
+        ret[path] = (diff_lines, reload_data, is_new)
+    return ret
 
-# NOCDEV-1720
+
+def pc_diff(hw, hostname: str, old_files: Dict[str, str], new_files: Dict[str, str]) -> Generator[
+    PCDiffFile, None, None]:
+    sorted_lines = sorted(_diff_files(hw, old_files, new_files).items())
+    for (path, (diff_lines, _reload_data, is_new)) in sorted_lines:
+        if not diff_lines:
+            continue
+        label = hostname + os.sep + path
+        if is_new:
+            label = LABEL_NEW_PREFIX + label
+        yield PCDiffFile(label=label, diff_lines=diff_lines)
+
+
+def json_fragment_diff(
+    hw,
+    hostname: str,
+    old_files: Dict[str, Any],
+    new_files: Dict[str, Tuple[Any, Optional[str]]],
+) -> Generator[PCDiffFile, None, None]:
+    def jsonify_multi(files):
+        return {
+            path: jsontools.format_json(cfg)
+            for path, cfg in files.items()
+        }
+
+    def jsonify_multi_with_cmd(files):
+        ret = {}
+        for path, cfg_reload_cmd in files.items():
+            cfg, reload_cmd = cfg_reload_cmd
+            ret[path] = (jsontools.format_json(cfg), reload_cmd)
+        return ret
+
+    jold, jnew = jsonify_multi(old_files), jsonify_multi_with_cmd(new_files)
+    return pc_diff(hw, hostname, jold, jnew)
+
+
+def worker(
+    device_id,
+    args: cli_args.DiffOptions,
+    stdin,
+    loader: Loader,
+    filterer: filtering.Filterer,
+) -> Union[Diff, PCDiff, None]:
+    for res in old_new(
+        args,
+        config=args.config,
+        loader=loader,
+        no_new=args.clear,
+        do_files_download=True,
+        device_ids=[device_id],
+        filterer=filterer,
+        stdin=stdin,
+    ):
+        old = res.get_old(args.acl_safe)
+        new = res.get_new(args.acl_safe)
+        device = res.device
+        acl_rules = res.get_acl_rules(args.acl_safe)
+        new_files = res.get_new_files(args.acl_safe)
+        new_json_fragment_files = res.get_new_file_fragments(args.acl_safe)
+
+        pc_diff_files = []
+        if res.old_files or new_files:
+            pc_diff_files.extend(pc_diff(res.device.hw, device.hostname, res.old_files, new_files))
+        if res.old_json_fragment_files or new_json_fragment_files:
+            pc_diff_files.extend(json_fragment_diff(res.device.hw, device.hostname, res.old_json_fragment_files,
+                                                    new_json_fragment_files))
+
+        if pc_diff_files:
+            pc_diff_files.sort(key=lambda f: f.label)
+            return PCDiff(hostname=device.hostname, diff_files=pc_diff_files)
+        elif old is not None:
+            orderer = patching.Orderer.from_hw(device.hw)
+            rb = rulebook.get_rulebook(device.hw)
+            diff_tree = patching.make_diff(
+                old,
+                orderer.order_config(new),
+                rb,
+                [acl_rules, res.filter_acl_rules],
+            )
+            diff_tree = patching.strip_unchanged(diff_tree)
+            return diff_tree
 
 
 def gen_sort_diff(
     diffs: Mapping[Device, Union[Diff, PCDiff]], args: ShowDiffOptions
-) -> Generator[Tuple[str, Generator[str, None, None], bool], None, None]:
+) -> Generator[Tuple[str, Generator[str, None, None] | str, bool], None, None]:
     """
     Возвращает осортированный дифф, совместимый с write_output
     :param diffs: Маппинг устройства в дифф
@@ -71,7 +164,7 @@ def _make_text_diff(device: Device, diff: Diff) -> List[str]:
     return res
 
 
-def collapse_diffs(diffs: Mapping[Device, Diff]) -> Mapping[Tuple[Device, ...], Diff]:
+def collapse_diffs(diffs: Mapping[Device, Diff]) -> Dict[Tuple[Device, ...], Diff]:
     """
     Группировка диффов.
     :param diffs:
@@ -128,7 +221,7 @@ class FrrFileDiffer(UnifiedFileDiffer):
             return self._diff_frr_conf(hw, old, new)
         return super().diff_file(hw, path, old, new)
 
-    def _diff_frr_conf(self,  hw: HardwareView, old_text: str | None, new_text: str | None) -> list[str]:
+    def _diff_frr_conf(self, hw: HardwareView, old_text: str | None, new_text: str | None) -> list[str]:
         """Calculate the differences for frr.conf files."""
         indent = "  "
         rb = rulebook.rulebook_provider_connector.get()

{annet-2.2.2.dist-info → annet-2.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: annet
-Version: 2.2.2
+Version: 2.3.1
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT

{annet-2.2.2.dist-info → annet-2.3.1.dist-info}/RECORD

@@ -2,12 +2,12 @@ annet/__init__.py,sha256=0OKkFkqog8As7B6ApdpKQkrEAcEELUREWp82D8WvGA8,1846
 annet/annet.py,sha256=8Hc-n0S6d-YhcMpMiMET_SsYKfHFJeCA_E2gKgzK-2Y,790
 annet/argparse.py,sha256=v1MfhjR0B8qahza0WinmXClpR8UiDFhmwDDWtNroJPA,12855
 annet/bgp_models.py,sha256=oibTSdipNkGL4t8Xn94bhyKHMOtwbPBqmYaAy4FmTxQ,12361
-annet/cli.py,sha256=hDpjIr3w47lgQ_CvCQS1SXFDK-SJrf5slbT__5u6GIA,12342
-annet/cli_args.py,sha256=KQlihxSl-Phhq1-9oJDdNSbIllEX55LlPfH6viEKOuw,13483
+annet/cli.py,sha256=shq3hHzrTxFL3x1_zTOR43QHo0JYs8QSwyOvGtL86Co,12733
+annet/cli_args.py,sha256=jzMKRezWe_87k7VBNzgwPjWGMROJksbgrlX-GDd6oQs,13533
 annet/connectors.py,sha256=aoiDVLPizx8CW2p8SAwGCzyO_WW8H9xc2aujbGC4bDg,4882
-annet/deploy.py,sha256=Dp-l0z7gmVIGpFB4snj6P_5G4siEeGC6vBWGJayJcn0,7732
+annet/deploy.py,sha256=JCcJ2hUmUsaOSrcxFuW8SlN0ubXSnHQ7H_nP_tx-PgE,7698
 annet/deploy_ui.py,sha256=KcP1g_c1HSA3n5qFxbGHd8t_arL4_xJV46PFO-7FLg8,28650
-annet/diff.py,sha256=SOhl706lpXdbrAwElgZqIzsTZEJRyDxOQ51fi910H0M,6088
+annet/diff.py,sha256=vz51az7RrXdYXsPbNMi9Y2awbjNRPQSFl6zzvE36Kx4,9441
 annet/executor.py,sha256=lcKI-EbYqeCiBNpL729kSltduzxbAzOkQ1L_QK7tNv8,5112
 annet/filtering.py,sha256=ZtqxPsKdV9reZoRxtQyBg22BqyMqd-2SotYcxZ-68AQ,903
 annet/gen.py,sha256=m76bL6rVbusNV_uVHrHnA3D7TUvvLtckXx7hlr5HGA0,31897
@@ -68,7 +68,7 @@ annet/annlib/rbparser/platform.py,sha256=65-r9mboRA3gaz9DRkSwPCdCRQneItqxppdMB6z
 annet/annlib/rbparser/syntax.py,sha256=iZ7Y-4QQBw4L3UtjEh54qisiRDhobl7HZxFNdP8mi54,3577
 annet/annlib/rulebook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/annlib/rulebook/common.py,sha256=hqwmmNofm5q2f-hV2usMY-IPMeiANLth28tZcRBYJTw,16640
-annet/api/__init__.py,sha256=YHhYDXAJVUijhjFaha_WxwpOMuc39zuy2e3PWt0yMCE,35106
+annet/api/__init__.py,sha256=BnFu1BbGZVgiT4GKa5x8reIHV40hl8UGR4vtwD8VREI,32992
 annet/configs/context.yml,sha256=RVLrKLIHpCty7AGwOnmqf7Uu0iZQCn-AjYhophDJer8,259
 annet/configs/logging.yaml,sha256=EUagfir99QqA73Scc3k7sfQccbU3E1SvEQdyhLFtCl4,997
 annet/generators/__init__.py,sha256=rVHHDTPKHPZsml1eNEAj3o-8RweFTN8J7LX3tKMXdIY,16402
@@ -178,10 +178,10 @@ annet_generators/rpl_example/generator.py,sha256=zndIGfV4ZlTxPgAGYs7bMQvTc_tYScO
 annet_generators/rpl_example/items.py,sha256=d99HSXDHFjZq511EvGhIqRTWK3F4ZsCWfdUqFYQcyhE,772
 annet_generators/rpl_example/mesh.py,sha256=z_WgfDZZ4xnyh3cSf75igyH09hGvtexEVwy1gCD_DzA,288
 annet_generators/rpl_example/route_policy.py,sha256=z6nPb0VDeQtKD1NIg9sFvmUxBD5tVs2frfNIuKdM-5c,2318
-annet-2.2.2.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
-annet-2.2.2.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
-annet-2.2.2.dist-info/METADATA,sha256=abzM5hJelHin2tMKnt1w3m9BIZd8210em5Bw6IjUSM0,793
-annet-2.2.2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-annet-2.2.2.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
-annet-2.2.2.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
-annet-2.2.2.dist-info/RECORD,,
+annet-2.3.1.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
+annet-2.3.1.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
+annet-2.3.1.dist-info/METADATA,sha256=U_8hFGlPprmgg8gwixbZkAinKUK9VW--rWrkVGPNiC0,793
+annet-2.3.1.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+annet-2.3.1.dist-info/entry_points.txt,sha256=5lIaDGlGi3l6QQ2ry2jZaqViP5Lvt8AmsegdD0Uznck,192
+annet-2.3.1.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
+annet-2.3.1.dist-info/RECORD,,

{annet-2.2.2.dist-info → annet-2.3.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any