annet 0.6__py3-none-any.whl → 0.8__py3-none-any.whl

annet/generators/__init__.py

@@ -296,8 +296,8 @@ def run_partial_generators(gens: List["PartialGenerator"], run_args: GeneratorPa
     for gen in gens:
         try:
             result = _run_partial_generator(gen, run_args)
-        except NotSupportedDevice:
-            logger.info("generator %s is not supported for this device, skip generator for this devices!", gen)
+        except NotSupportedDevice as exc:
+            logger.info("generator %s raised unsupported error: %r", gen, exc)
             continue
 
         if not result:
@@ -317,13 +317,17 @@ def run_partial_generators(gens: List["PartialGenerator"], run_args: GeneratorPa
 
 
 @tracing.function(name="run_partial_generator")
-def _run_partial_generator(gen: "PartialGenerator", run_args: GeneratorPartialRunArgs) -> GeneratorPartialResult:
+def _run_partial_generator(gen: "PartialGenerator", run_args: GeneratorPartialRunArgs) -> Optional[GeneratorPartialResult]:
     logger = get_logger(generator=_make_generator_ctx(gen))
     device = run_args.device
     output = ""
     config = odict()
     safe_config = odict()
 
+    if not gen.supports_device(device):
+        logger.info("generator %s is not supported for device %s", gen, device.hostname)
+        return None
+
     span = tracing_connector.get().get_current_span()
     if span:
         tracing_connector.get().set_device_attributes(span, run_args.device)
@@ -439,8 +443,8 @@ def run_file_generators(
             raise RuntimeError(f"Unknown generator class type: cls={gen.__class__} TYPE={gen.__class__.TYPE}")
         try:
             result = run_generator_fn(gen, device, storage)
-        except NotSupportedDevice:
-            logger.info("generator %s is not supported for this device", gen)
+        except NotSupportedDevice as exc:
+            logger.info("generator %s raised unsupported error: %r", gen, exc)
             continue
         if result:
             add_result_fn(result)
@@ -450,33 +454,34 @@ def run_file_generators(
 
 @tracing.function(min_duration="0.5")
 def _run_entire_generator(gen: "Entire", device: "Device", storage: Storage) -> Optional[GeneratorResult]:
+    logger = get_logger(generator=_make_generator_ctx(gen))
+    if not gen.supports_device(device):
+        logger.info("generator %s is not supported for device %s", gen, device.hostname)
+        return
+
     span = tracing_connector.get().get_current_span()
     if span:
         tracing_connector.get().set_device_attributes(span, device)
         tracing_connector.get().set_dimensions_attributes(span, gen, device)
 
-    logger = get_logger(generator=_make_generator_ctx(gen))
     path = gen.path(device)
-    if path:
-        logger.info("Generating ENTIRE ...")
-
-        with GeneratorPerfMesurer(gen, storage, trace_min_duration="0.5") as pm:
-            output = gen(device)
-
-        reload_cmds = gen.get_reload_cmds(device)
-        prio = gen.prio
-
-        return GeneratorEntireResult(
-            name=gen.__class__.__name__,
-            tags=gen.TAGS,
-            path=path,
-            output=output,
-            reload=reload_cmds,
-            prio=prio,
-            perf=pm.last_result,
-            is_safe=gen.is_safe(device),
-        )
-    return None
+    if not path:
+        raise RuntimeError("entire generator should return non-empty path")
+
+    logger.info("Generating ENTIRE ...")
+    with GeneratorPerfMesurer(gen, storage, trace_min_duration="0.5") as pm:
+        output = gen(device)
+
+    return GeneratorEntireResult(
+        name=gen.__class__.__name__,
+        tags=gen.TAGS,
+        path=path,
+        output=output,
+        reload=gen.get_reload_cmds(device),
+        prio=gen.prio,
+        perf=pm.last_result,
+        is_safe=gen.is_safe(device),
+    )
 
 
 def _make_generator_ctx(gen):
@@ -489,34 +494,36 @@ def _run_json_fragment_generator(
         storage: Storage,
 ) -> Optional[GeneratorResult]:
     logger = get_logger(generator=_make_generator_ctx(gen))
+    if not gen.supports_device(device):
+        logger.info("generator %s is not supported for device %s", gen, device.hostname)
+
     path = gen.path(device)
+    if not path:
+        raise RuntimeError("json fragment generator should return non-empty path")
 
     acl_item_or_list_of_items = gen.acl(device)
+    if not acl_item_or_list_of_items:
+        raise RuntimeError("json fragment generator should return non-empty acl")
     if isinstance(acl_item_or_list_of_items, list):
         acl = acl_item_or_list_of_items
     else:
         acl = [acl_item_or_list_of_items]
 
-    if path:
-        logger.info("Generating JSON_FRAGMENT ...")
-
-        with GeneratorPerfMesurer(gen, storage) as pm:
-            config = gen(device)
-
-        reload_cmds = gen.get_reload_cmds(device)
-
-        return GeneratorJSONFragmentResult(
-            name=gen.__class__.__name__,
-            tags=gen.TAGS,
-            path=path,
-            acl=acl,
-            config=config,
-            reload=reload_cmds,
-            perf=pm.last_result,
-            is_safe=gen.is_safe(device),
-            reload_prio=gen.reload_prio,
-        )
-    return None
+    logger.info("Generating JSON_FRAGMENT ...")
+    with GeneratorPerfMesurer(gen, storage) as pm:
+        config = gen(device)
+    reload_cmds = gen.get_reload_cmds(device)
+    return GeneratorJSONFragmentResult(
+        name=gen.__class__.__name__,
+        tags=gen.TAGS,
+        path=path,
+        acl=acl,
+        config=config,
+        reload=reload_cmds,
+        perf=pm.last_result,
+        is_safe=gen.is_safe(device),
+        reload_prio=gen.reload_prio,
+    )
 
 
 def _get_generators(module_paths: Union[List[str], dict], storage, device=None):
@@ -538,15 +545,7 @@ def _get_generators(module_paths: Union[List[str], dict], storage, device=None):
         module = importlib.import_module(module_path)
         if hasattr(module, "get_generators"):
             generators: List[BaseGenerator] = module.get_generators(storage)
-            if device is None:
-                res_generators += generators
-            else:
-                logger = get_logger()
-                for gen in generators:
-                    if gen.supports_vendor(device.hw.vendor):
-                        res_generators.append(gen)
-                    else:
-                        logger.info("generator %s does not support device vendor %s, skipping", gen, device.hw.vendor)
+            res_generators += generators
     return res_generators
 
 
@@ -595,7 +594,7 @@ class BaseGenerator:
     TYPE: str
     TAGS: list[str]
 
-    def supports_vendor(self, vendor: str) -> bool:  # pylint: disable=unused-argument
+    def supports_device(self, device: Device) -> bool:  # pylint: disable=unused-argument
         return True
 
 
@@ -689,30 +688,36 @@ class PartialGenerator(TreeGenerator):
         self._annotations = []
         self._annotation_module = self.__class__.__module__ or ""
 
-    def supports_vendor(self, vendor: str) -> bool:
+    def supports_device(self, device: Device) -> bool:
         if self.__class__.run is PartialGenerator.run:
-            return hasattr(self, f"run_{vendor}")
+            return bool(self._get_vendor_func(device.hw.vendor, "run"))
         else:
             return True
 
     def acl(self, device):
-        if hasattr(self, "acl_" + device.hw.vendor):
-            return getattr(self, "acl_" + device.hw.vendor)(device)
+        acl_func = self._get_vendor_func(device.hw.vendor, "acl")
+        if acl_func:
+            return acl_func(device)
 
     def acl_safe(self, device):
-        if hasattr(self, "acl_safe_" + device.hw.vendor):
-            return getattr(self, "acl_safe_" + device.hw.vendor)(device)
+        acl_func = self._get_vendor_func(device.hw.vendor, "acl_safe")
+        if acl_func:
+            return acl_func(device)
 
     def run(self, device) -> Iterable[Union[str, tuple]]:
-        if hasattr(self, "run_" + device.hw.vendor):
-            return getattr(self, "run_" + device.hw.vendor)(device)
-        return iter(())
+        run_func = self._get_vendor_func(device.hw.vendor, "run")
+        if run_func:
+            return run_func(device)
 
     def get_user_runner(self, device):
         if self.__class__.run is not PartialGenerator.run:
             return self.run
-        elif hasattr(self, "run_" + device.hw.vendor):
-            return getattr(self, "run_" + device.hw.vendor)
+        return self._get_vendor_func(device.hw.vendor, "run")
+
+    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
 
     # =====
@@ -792,6 +797,9 @@ class Entire(BaseGenerator):
             self.prio = 100
         self.__device = None
 
+    def supports_device(self, device: Device):
+        return bool(self.path(device))
+
     def run(self, device) -> Union[None, str, Iterable[Union[str, tuple]]]:
         raise NotImplementedError
 
@@ -909,6 +917,9 @@ class JSONFragment(TreeGenerator):
         if not hasattr(self, "reload_prio"):
             self.reload_prio = 100
 
+    def supports_device(self, device: Device):
+        return bool(self.path(device))
+
     def path(self, device: Device) -> Optional[str]:
         raise NotImplementedError("Required PATH for JSON_FRAGMENT generator")
 

annet/output.py

@@ -133,7 +133,9 @@ class OutputDriverBasic(OutputDriver):
         ret = []
         fqdns = {}
         if args:
-            with storage_connector.get().storage()(args) as storage:
+            connector = storage_connector.get()
+            storage_opts = connector.opts().from_cli_opts(args)
+            with connector.storage()(storage_opts) as storage:
                 fqdns = storage.resolve_fdnds_by_query(args.query)
         for (assignment, exc) in fail.items():
             label = assignment

{annet-0.6.dist-info → annet-0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: annet
-Version: 0.6
+Version: 0.8
 Summary: annet
 Home-page: https://github.com/annetutil/annet
 License: MIT
@@ -21,4 +21,6 @@ Requires-Dist: contextlog >=1.1
 Requires-Dist: valkit >=0.1.4
 Requires-Dist: aiohttp >=3.8.4
 Requires-Dist: yarl >=1.8.2
+Requires-Dist: adaptix ==3.0.0b2
+Requires-Dist: dataclass-rest ==0.4
 

{annet-0.6.dist-info → annet-0.8.dist-info}/RECORD

@@ -1,18 +1,18 @@
 annet/__init__.py,sha256=oyElxAW97sHgQccGafhaWVBveBn1gSjjdP_xHROaRLg,2139
 annet/annet.py,sha256=TMdEuM7GJQ4TjRVmuK3bCTZN-21lxjQ9sXqEdILUuBk,725
 annet/argparse.py,sha256=MoBD0LPnHdA6HU7z1uQNArYlkD92znoeGIFTMnS4dRM,12608
-annet/cli.py,sha256=HoVD9DDZZurxG7YHrU8d2kDJS2tBOCMsmMgJFgarNKI,8284
-annet/cli_args.py,sha256=FuyHLANmTXZl4W9Q4pfT3mMtRiVswM88L5WFhSzu6eA,15871
+annet/cli.py,sha256=bkAaHKBYmvdaFawm_KOM7CehMm18RTR8TkMYAxm-7lo,8464
+annet/cli_args.py,sha256=rmBTJ64sljQWFTIbhTEBZRIo08Gi9NAoFZrMermZEuY,16152
 annet/connectors.py,sha256=M2NeyFgBEGJ_tMR9HgQ4cpli0nBciqZJDVMQXEueMws,1908
 annet/deploy.py,sha256=B8E0P_VvCrS2URjFvgmUiIkHp95g7pAWfmT34igaDeo,18893
-annet/diff.py,sha256=0QG_3Ur5k7ajRuWUrM089yt_Fxss06OTBSUE3h54Nxw,3460
+annet/diff.py,sha256=zLcaCnb4lZRUb7frpH1CstQ3kacRcCblZs1uLG8J5lk,3391
 annet/executor.py,sha256=bw7COJNtssuxIqbQehlHYJnkdUeYvvL8WO5B-c67XE0,19040
 annet/filtering.py,sha256=F4ZKUCU3Yb1RlL2zKdyHtVUaWPzjWF4vWyMcdygKNYk,852
-annet/gen.py,sha256=aDrTS3X9Lo47F7Mj21PaGzn27TIgAehcsJ5k5uihB30,31246
+annet/gen.py,sha256=MI82tdc-r3leiyp4Oa35PBsrfj0jNKdbASRnQ8Rk39g,32336
 annet/hardware.py,sha256=HYPDfji_GdRn5S0_0fl4rvM7byOY9aHxG6VMAtsLaxE,1090
 annet/implicit.py,sha256=QigK4uoxvrFho2h9yFjOq1d9rLsC5xFlAU4bKkCuMWk,5139
 annet/lib.py,sha256=zQIfNBg7fAAk2BHbHAqy_McAiXhz0RqpBAcfdU-6pAA,3742
-annet/output.py,sha256=fEKQ_EncOeZzzlO43tctZVbi37QS1j2m4MYxbvpLxAo,6984
+annet/output.py,sha256=XsX3o4vxe7Ayw7ocY-pV5VY-9-D5_Q_yeWy2ZY1Hubk,7090
 annet/parallel.py,sha256=hLkzEht0KhzmzUWDdO4QFYQHzhxs3wPlTA8DxbB2ziw,17160
 annet/patching.py,sha256=nILbY5oJajN0b1j3f0HEJm05H3HVThnWvB7vDVh7UQw,559
 annet/reference.py,sha256=B8mH8VUMcecPnzULiTVb_kTQ7jQrCL7zp4pfIZQa5fk,4035
@@ -21,12 +21,30 @@ annet/tabparser.py,sha256=ZjiI43ZVbrpMVR8qNbTbNh_U3oZ26VDc_2Y9wkkDkYA,874
 annet/text_term_format.py,sha256=CHb6viv45vmYl-SK1A1vyPHGhaEni6jVybBusaQnct8,2813
 annet/tracing.py,sha256=ndpM-au1c88uBBpOuH_z52qWZL773edYozNyys_wA68,4044
 annet/types.py,sha256=f0iwSJGSQ7GvWeXgXqBCoxzYNezMa4YASQEHJzWUrWU,6962
+annet/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annet/adapters/netbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annet/adapters/netbox/provider.py,sha256=OM7Hq2vnMHNVBfubJvx2qJlMYm3VvKhomdLMNO8YnLQ,1024
+annet/adapters/netbox/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annet/adapters/netbox/common/client.py,sha256=-lWZmphD-OPuLIHNKhW_h2bnjrVaiyKYAD_MUPasEbo,2483
+annet/adapters/netbox/common/manufacturer.py,sha256=UH_tEKT3GXC8WSm15q0xxXRE7aj0b0icgwmR--PRWBs,1771
+annet/adapters/netbox/common/models.py,sha256=Kti1T54emv6_FUkhgRiSIo_ZdmvWZZTRvooHO2_H1bM,1731
+annet/adapters/netbox/common/query.py,sha256=OgUuF-bvshpoBUkrOs0tsMUAhjTsttzx3VV30ryFl0Y,577
+annet/adapters/netbox/common/status_client.py,sha256=3oozmdfewPXODEkNrDRfcz_pTeXRVDQiNiD-AE6Lrug,567
+annet/adapters/netbox/common/storage_opts.py,sha256=rl_0pr3VzmOy6PDZIUMkKSBfJh90gD9TFL3yBhK_8ME,337
+annet/adapters/netbox/v24/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annet/adapters/netbox/v24/api_models.py,sha256=xG3n9ILYdD2jNxav8IH6Bm6fX4vbHPUkHBLze4Ly1bc,1314
+annet/adapters/netbox/v24/client.py,sha256=-r91zVTThn12mN1zBj3XNyqlP6BGOrAPm_GbBT2bXpI,1497
+annet/adapters/netbox/v24/storage.py,sha256=SCTSOea8OHiLAPmBXIop80mIUOLuA48rLpKlitYJt1k,5620
+annet/adapters/netbox/v37/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+annet/adapters/netbox/v37/api_models.py,sha256=O59bYesIWlxHx3C2TW4TQnfN9YMsE_rbiw2mYsormcc,886
+annet/adapters/netbox/v37/client.py,sha256=GgFIV5IGlyEplvwOLLd1BxtsbPWkeHEtL22kWV_X0b0,1668
+annet/adapters/netbox/v37/storage.py,sha256=5jp2AgalijTdFkMnjvGGGnxqjwk-bn6QWzTRTfNyyHM,4216
 annet/annlib/__init__.py,sha256=fT1l4xV5fqqg8HPw9HqmZVN2qwS8i6X1aIm2zGDjxKY,252
 annet/annlib/command.py,sha256=uuBddMQphtn8P5MO5kzIa8_QrtMns-k05VeKv1bcAuA,1043
 annet/annlib/diff.py,sha256=UPt3kYFQdQdVVy3ePYzNHPAxMVmHxCrCnZnMCV6ou2Q,4587
 annet/annlib/errors.py,sha256=jBcSFzY6Vj-FxR__vqjFm-87AwYQ0xHuAopTirii5AU,287
 annet/annlib/filter_acl.py,sha256=0w1VF6WcONiTYTQh0yWi6_j9rCTc_kMLAUMr0hbdkNU,7203
-annet/annlib/jsontools.py,sha256=X4gtKcnDArnzKcZDJmRKcZGuUgi3nEFSVKdGPi2uGDw,2644
+annet/annlib/jsontools.py,sha256=TJazOP-1njwbGN7iIz8oGYgWPdry4XfKLjpzNYxdvjg,3364
 annet/annlib/lib.py,sha256=eJ4hcVuQ6pdYBzLs4YKCHFtq45idOfZCYp92XfF7_QI,15317
 annet/annlib/output.py,sha256=_SjJ6G6bejvnTKqNHw6xeio0FT9oO3OIkLaOC3cEga4,7569
 annet/annlib/patching.py,sha256=Gh8uUjFyYND9TJBBQH-DH6-AwFiiR-dXVXOisMS7elg,19784
@@ -47,10 +65,10 @@ annet/annlib/rbparser/platform.py,sha256=iyqy4A-6vUKM4j6hrOA6tsgWBXk7LcvkFrS2QHg
 annet/annlib/rbparser/syntax.py,sha256=eEUmszwPjdw57aofUYNQVcaxHPNV9yx9JNapjYY-BGM,3572
 annet/annlib/rulebook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/annlib/rulebook/common.py,sha256=9kCZwZpsH5UliF2OzaN9nLs2eLlz_d__4L7_oZ3SrCw,16054
-annet/api/__init__.py,sha256=dF9Dnnr31IOKBP0zV-ZP6z1HcwQ8yGTPOHmFC3GdW7g,33212
+annet/api/__init__.py,sha256=VooP9u9f6e8vF7FPUE-r0JAGqCjck9-2b0dVNWAtoLM,33752
 annet/configs/context.yml,sha256=nt4QnzYzrG2hqmaWOUsab2wgFl-CXmFSzbto6rqqFt4,291
 annet/configs/logging.yaml,sha256=Hu42lRK248dssp9TgkbHCaZNl0E6f4IChGb0XaQnTVo,970
-annet/generators/__init__.py,sha256=7yp4OxluAMSozXRaDPabDqfyGJDh4YJXKcAb4KYEzyM,34049
+annet/generators/__init__.py,sha256=iOTaIfTQfGoExmSAzqt1RSWP7V1O_pEkuqvjnsEjBkQ,34476
 annet/generators/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet/generators/common/initial.py,sha256=XI7uWLMuLrHC-uXm38oRbM1YVuELAvMHLZFHM9x5IF8,1229
 annet/rulebook/__init__.py,sha256=14IpOfTbeJtre7JKrfXVYiH0qAXsUSOL7AatUFmSQs0,3847
@@ -102,12 +120,10 @@ annet/rulebook/texts/routeros.rul,sha256=ipfxjj0mjFef6IsUlupqx4BY_Je_OUb8u_U1019
 annet_generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 annet_generators/example/__init__.py,sha256=zVd8_DrXuOASrNzg2Ab94rPyvJff83L-_HppDFxnUjM,228
 annet_generators/example/lldp.py,sha256=68CLrK7vxTQQy9XIBxtywuEdBNlIlfXGYj8_wYWs5UI,1146
-annet_nbexport/__init__.py,sha256=dr_q90ziWR20ckM6l-IWI3PqngHZwqrgPns7NDtq5B8,6362
-annet_nbexport/main.py,sha256=f65WKdS2xvbttllCe5IYkoenPEy8C4SzvNydhh4ZEVM,1216
-annet-0.6.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
-annet-0.6.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
-annet-0.6.dist-info/METADATA,sha256=OO8K6pmnZ0fyA9DZ-V6kysoqMoOKzlk_ONv36XLACJc,622
-annet-0.6.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-annet-0.6.dist-info/entry_points.txt,sha256=g_pJ55300jUXfafHl7izmDJ6RVSo6iW9IaNfysM3Y0w,151
-annet-0.6.dist-info/top_level.txt,sha256=uL47QByRwuZV5yWC58gd4IkHM8sVSAJ1pZb-6W-gMfY,38
-annet-0.6.dist-info/RECORD,,
+annet-0.8.dist-info/AUTHORS,sha256=rh3w5P6gEgqmuC-bw-HB68vBCr-yIBFhVL0PG4hguLs,878
+annet-0.8.dist-info/LICENSE,sha256=yPxl7dno02Pw7gAcFPIFONzx_gapwDoPXsIsh6Y7lC0,1079
+annet-0.8.dist-info/METADATA,sha256=biTv9OtMLS-HnbvanEbTm3B-tYG9SGFV-TSQCtem7cE,691
+annet-0.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+annet-0.8.dist-info/entry_points.txt,sha256=yHimujIzR2bwNIbb--MTs_GpXiAve89Egpu2LlgTEkg,119
+annet-0.8.dist-info/top_level.txt,sha256=QsoTZBsUtwp_FEcmRwuN8QITBmLOZFqjssRfKilGbP8,23
+annet-0.8.dist-info/RECORD,,

{annet-0.6.dist-info → annet-0.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

annet-0.8.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[annet.connectors]
+storage = annet.adapters.netbox.provider:NetboxProvider
+
+[console_scripts]
+annet = annet.annet:main

{annet-0.6.dist-info → annet-0.8.dist-info}/top_level.txt

@@ -1,3 +1,2 @@
 annet
 annet_generators
-annet_nbexport

annet-0.6.dist-info/entry_points.txt

@@ -1,6 +0,0 @@
-[annet.connectors]
-storage = annet_nbexport:AnnetNbExportProvder
-
-[console_scripts]
-annet = annet.annet:main
-annet_nbexport = annet_nbexport.main:main

annet_nbexport/__init__.py

@@ -1,220 +0,0 @@
-import csv
-import dataclasses
-import operator
-import os
-import os.path
-import pathlib
-from typing import List, Optional
-
-from annet.storage import Device, Storage, Query, StorageOpts, StorageProvider
-from annet.annlib.netdev.views.hardware import HardwareView
-
-
-class AnnetNbExportProvder(StorageProvider):
-    def storage(self):
-        return AnnetNbExportStorage
-
-    def opts(self):
-        return AnnetNbExportStorageOpts
-
-    def query(self):
-        return AnnetNbExportQuery
-
-
-@dataclasses.dataclass
-class AnnetNbExportQuery(Query):
-    query: List[str]
-
-    @classmethod
-    def new(cls, query, hosts_range) -> "AnnetNbExportQuery":
-        if hosts_range is not None:
-            raise ValueError("host_range is not supported")
-        return cls(query=query)
-
-    @property
-    def globs(self):
-        # We process every query host as a glob
-        return self.query
-
-
-@dataclasses.dataclass
-class AnnetNbExportStorageOpts(StorageOpts):
-    @classmethod
-    def from_cli_opts(cls, cli_opts) -> "AnnetNbExportQuery":
-        return cls()
-
-
-class DeviceNb(Device):
-    def __init__(self, storage: "Storage", dto: "NetboxDTO", region: str):
-        self.dto = dto
-        self.storage = storage
-        self.region = region
-
-    def __hash__(self):
-        return hash(self.id)
-
-    def is_pc(self):
-        return self.dto.manufacturer == "Mellanox"
-
-    @property
-    def hw(self):
-        manufacturer = self.dto.manufacturer
-        model_name = self.dto.model_name
-        # по какой-то причине модели mellanox SN в нетбоксе называются MSN
-        # чтобы использовать выгрузку as is и не править devdb.json патчим тут
-        if manufacturer == "Mellanox" and model_name.startswith("MSN"):
-            model_name = model_name.replace("MSN", "SN", 1)
-        hw = _vendor_to_hw(manufacturer + " " + model_name)
-        assert hw.vendor, "unsupported manufacturer %s" % self.dto.manufacturer
-        return hw
-
-    @property
-    def id(self):
-        return self.dto.name
-
-    @property
-    def fqdn(self):
-        return self.dto.name
-
-    @property
-    def hostname(self):
-        return self.dto.name
-
-    @property
-    def neighbours_ids(self):
-        return set()
-
-    @property
-    def breed(self):
-        if self.dto.manufacturer == "Huawei" and self.dto.model_name.startswith("CE"):
-            return "vrp85"
-        elif self.dto.manufacturer == "Huawei" and self.dto.model_name.startswith("NE"):
-            return "vrp85"
-        elif self.dto.manufacturer == "Huawei":
-            return "vrp55"
-        elif self.dto.manufacturer == "Mellanox":
-            return "cuml2"
-        elif self.dto.manufacturer == "Juniper":
-            return "jun10"
-        elif self.dto.manufacturer == "Cisco":
-            return "ios12"
-        elif self.dto.manufacturer == "Adva":
-            return "adva8"
-        elif self.dto.manufacturer == "Arista":
-            return "eos4"
-        assert False, "unknown manufacturer %s" % self.dto.manufacturer
-
-
-@dataclasses.dataclass
-class NetboxDTO:
-    name: str
-    device_role: str
-    tenant: str
-    manufacturer: str
-    model_name: str
-    platform: str
-    serial: str
-    asset_tag: str
-    status: str
-    site: str
-    rack_group: str
-    rack_name: str
-    position: str
-    face: str
-    comments: str
-
-
-class AnnetNbExportStorage(Storage):
-    def __init__(self, opts: Optional[StorageOpts] = None):
-        self._dump_dir = os.path.join(os.path.dirname(__file__))
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, _, __, ___):
-        pass
-
-    def resolve_object_ids_by_query(self, query):
-        ret = []
-        for device_data in _read_dump(self._dump_dir):
-            if _match_query(query, device_data):
-                ret.append(device_data["name"])
-        return ret
-
-    def resolve_fdnds_by_query(self, query):
-        return self.resolve_object_ids_by_query(query)
-
-    def make_devices(
-        self,
-        query,
-        preload_neighbors=False,
-        use_mesh=None,
-        preload_extra_fields=False,
-        **kwargs,
-    ):
-        ret = []
-        for file_path, device_data in _read_dump(self._dump_dir):
-            if _match_query(query, device_data):
-                ret.append(DeviceNb(self, NetboxDTO(**device_data), region=file_path.parent.name))
-        return ret
-
-    def get_device(self, obj_id, preload_neighbors=False, use_mesh=None, **kwargs) -> Device:
-        for file_path, device_data in _read_dump(self._dump_dir):
-            if device_data["name"] == obj_id:
-                return DeviceNb(self, NetboxDTO(**device_data), region=file_path.parent.name)
-
-    def flush_perf(self):
-        pass
-
-
-def _read_dump(dump_dir):
-    for (dirpath, _dirnames, filenames) in os.walk(dump_dir):
-        for filename in filenames:
-            if filename != "devices.csv":
-                continue
-            with open(os.path.join(dirpath, filename)) as fh:
-                file_path = pathlib.Path(os.path.join(dirpath, filename))
-                for device_data in csv.DictReader(fh):
-                    yield file_path, device_data
-
-
-def _match_query(query, device_data) -> bool:
-    for subquery in query.globs:
-        matches = []
-        for field_filter in subquery.split("@"):
-            if "=" in field_filter:
-                field, value = field_filter.split("=")
-                field = field.strip()
-                value = value.strip()
-                op = operator.eq
-            else:
-                field = "name"
-                value = field_filter.strip()
-                op = operator.contains
-            if field in device_data and op(device_data[field], value):
-                matches.append(True)
-            else:
-                matches.append(False)
-        if all(matches):
-            return True
-    return False
-
-
-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_nbexport/main.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import asyncio
-import os
-import typing
-
-import aiohttp
-import yarl
-
-
-async def download(url: yarl.URL, dest: typing.BinaryIO):
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url) as resp:
-            async for b in resp.content.iter_any():
-                dest.write(b)
-
-
-async def download_devices(url: yarl.URL, region: str):
-    basedir = os.path.dirname(__file__)
-    regiondir = os.path.join(basedir, "data", region)
-    os.makedirs(regiondir, exist_ok=True)
-    with open(os.path.join(regiondir, "devices.csv"), "wb") as fh:
-        await download(url.with_path("/dcim/devices/").with_query("export"), fh)
-
-
-async def amain():
-    p = argparse.ArgumentParser()
-    p.add_argument("--region-name", default=None, help="The name of the region to download cvs to")
-    p.add_argument("netbox_url", type=yarl.URL, help="The URL to access netbox API")
-    args = p.parse_args()
-
-    if args.region_name is None:
-        region_name = args.netbox_url.host
-    else:
-        region_name = args.region_name
-
-    await download_devices(args.netbox_url, region_name)
-
-
-def main():
-    asyncio.run(amain())
-
-
-if __name__ == "__main__":
-    main()