feat: no entrypoint registration required in tree (#4207)

Signed-off-by: John Andersen <[email protected]>

Author: pdxjohnny

cve_bin_tool/checkers/__init__.py

@@ -6,10 +6,20 @@
 
 import collections
 import re
+import sys
 
 from cve_bin_tool.error_handler import InvalidCheckerError
 from cve_bin_tool.util import regex_find
 
+if sys.version_info >= (3, 10):
+    from importlib import metadata as importlib_metadata
+else:
+    import importlib_metadata
+if sys.version_info >= (3, 9):
+    import importlib.resources as resources
+else:
+    import importlib_resources as resources
+
 __all__ = [
     "Checker",
     "VendorProductPair",
@@ -439,3 +449,14 @@ def get_version(self, lines, filename):
             )
 
         return version_info
+
+
+BUILTIN_CHECKERS = {
+    checker_path.stem: importlib_metadata.EntryPoint(
+        checker_path.stem,
+        f'cve_bin_tool.checkers.{checker_path.stem}:{"".join(checker_path.stem.replace("_", " ").title().split())}Checker',
+        "cve_bin_tool.checkers",
+    )
+    for checker_path in resources.files("cve_bin_tool.checkers").iterdir()
+    if (checker_path.suffix == ".py" and not checker_path.name.startswith("__"))
+}

cve_bin_tool/cli.py

@@ -75,11 +75,6 @@
 from cve_bin_tool.version import VERSION
 from cve_bin_tool.version_scanner import VersionScanner
 
-if sys.version_info >= (3, 10):
-    from importlib import metadata as importlib_metadata
-else:
-    import importlib_metadata
-
 sys.excepthook = excepthook  # Always install excepthook for entrypoint module.
 
 
@@ -911,12 +906,10 @@ def main(argv=None):
         runs = args["runs"]
         skips = list(
             map(
-                lambda checker: checker.name,
+                lambda checker_name: checker_name,
                 filter(
-                    lambda checker: checker.name not in runs,
-                    importlib_metadata.entry_points().select(
-                        group="cve_bin_tool.checker"
-                    ),
+                    lambda checker_name: checker_name not in runs,
+                    VersionScanner.available_checkers(),
                 ),
             )
         )

cve_bin_tool/parsers/parse.py

@@ -2,24 +2,67 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 from __future__ import annotations
 
+import os
+import re
 import sys
 
 if sys.version_info >= (3, 10):
     from importlib import metadata as importlib_metadata
 else:
     import importlib_metadata
+if sys.version_info >= (3, 9):
+    import importlib.resources as resources
+else:
+    import importlib_resources as resources
 
 from cve_bin_tool.parsers import Parser
 
 PARSERS_ENTRYPOINT = "cve_bin_tool.parsers"
 
 
+def enumerate_builtin_parsers():
+    """Reads the files in cve_bin_tool/parsers/ to auto determine list"""
+    parsers = {}
+    for path in resources.files("cve_bin_tool.parsers").iterdir():
+        if path.suffix != ".py" or path.stem in ("__init__", "parser"):
+            continue
+        contents = path.read_text()
+        for re_match in re.finditer(r"^class (\w+)", contents, re.MULTILINE):
+            parser_cls_name = re_match[1]
+            parsers[".".join([path.stem, parser_cls_name])] = ":".join(
+                [
+                    str(path.relative_to(path.parents[2]).with_suffix("")).replace(
+                        os.path.sep, "."
+                    ),
+                    parser_cls_name,
+                ],
+            )
+    return parsers
+
+
+BUILTIN_PARSERS = {
+    parser_entry_point_name: importlib_metadata.EntryPoint(
+        parser_entry_point_name,
+        entry_point_path,
+        "cve_bin_tool.parsers",
+    )
+    for (
+        parser_entry_point_name,
+        entry_point_path,
+    ) in enumerate_builtin_parsers().items()
+}
+
+
 def load_valid_files() -> dict[str, list[type[Parser]]]:
     """Loads file parsers"""
     valid_files: dict[str, list[type[Parser]]] = {}
-    for entrypoint in importlib_metadata.entry_points().select(
-        group=PARSERS_ENTRYPOINT
-    ):
+
+    for entrypoint in [
+        *BUILTIN_PARSERS.values(),
+        *importlib_metadata.entry_points().select(
+            group=PARSERS_ENTRYPOINT,
+        ),
+    ]:
         parser_cls = entrypoint.load()
         for match_filename in getattr(parser_cls, "PARSER_MATCH_FILENAMES", []):
             valid_files.setdefault(match_filename, [])

cve_bin_tool/version_scanner.py

@@ -9,7 +9,7 @@
 from pathlib import Path
 from typing import Iterator
 
-from cve_bin_tool.checkers import Checker
+from cve_bin_tool.checkers import BUILTIN_CHECKERS, Checker
 from cve_bin_tool.cvedb import CVEDB
 from cve_bin_tool.egg_updater import IS_DEVELOP, update_egg
 from cve_bin_tool.error_handler import ErrorMode
@@ -82,22 +82,32 @@ def __init__(
     @classmethod
     def load_checkers(cls) -> dict[str, type[Checker]]:
         """Loads CVE checkers"""
-        checkers = dict(
-            map(
-                lambda checker: (checker.name, checker.load()),
-                importlib_metadata.entry_points().select(group=cls.CHECKER_ENTRYPOINT),
+        entrypoint_checkers = {
+            checker.name: checker.load()
+            for checker in importlib_metadata.entry_points().select(
+                group=cls.CHECKER_ENTRYPOINT
             )
-        )
-        return checkers
+        }
+        builtin_checkers = {
+            checker.name: checker.load() for checker in BUILTIN_CHECKERS.values()
+        }
+        all_checkers = {
+            **builtin_checkers,
+            **entrypoint_checkers,
+        }
+        return all_checkers
 
     @classmethod
     def available_checkers(cls) -> list[str]:
         """Discover and list available checker by inspecting the entry points"""
-        checkers = importlib_metadata.entry_points().select(
-            group=cls.CHECKER_ENTRYPOINT
-        )
-        checker_list = [item.name for item in checkers]
-        return checker_list
+        entrypoint_checker_names = [
+            checker.name
+            for checker in importlib_metadata.entry_points().select(
+                group=cls.CHECKER_ENTRYPOINT
+            )
+        ]
+        all_checker_names = list(BUILTIN_CHECKERS.keys()) + entrypoint_checker_names
+        return all_checker_names
 
     def remove_skiplist(self, skips: list[str]) -> None:
         """Remove specific checkers If a checker is in the skip list, it will be removed from this dictionary. If it's not found or is not a valid checker name, it logs error messages."""

example/oot-checker/oot_checker/checker_name.py

@@ -18,4 +18,4 @@ class CurlChecker(Checker):
     CONTAINS_PATTERNS = [r"curl ([678]+\.[0-9]+\.[0-9]+)"]
     FILENAME_PATTERNS = [r"curl"]
     VERSION_PATTERNS = [r"curl ([678]+\.[0-9]+\.[0-9]+)"]
-    VENDOR_PACKAGE = [("haxx", "curl")]
+    VENDOR_PRODUCT = [("haxx", "curl")]

setup.py

@@ -4,7 +4,6 @@
 import ast
 import os
 import pathlib
-import re
 
 from setuptools import find_packages, setup
 
@@ -23,29 +22,6 @@
             break
 
 
-def enumerate_entry_points_parsers():
-    """Reads the files in cve_bin_tool/parsers/to auto determine list"""
-    parsers = {}
-    for path in PACKAGE_ROOT_PATH.joinpath(
-        "cve_bin_tool",
-        "parsers",
-    ).glob("*.py"):
-        if "__init__" == path.stem:
-            continue
-        contents = path.read_text()
-        for re_match in re.finditer(r"^class (\w+)", contents, re.MULTILINE):
-            parser_cls_name = re_match[1]
-            parsers[".".join([path.stem, parser_cls_name])] = ":".join(
-                [
-                    str(path.relative_to(PACKAGE_ROOT_PATH).with_suffix("")).replace(
-                        os.path.sep, "."
-                    ),
-                    parser_cls_name,
-                ],
-            )
-    return parsers
-
-
 setup_kwargs = dict(
     name="cve-bin-tool",
     version=VERSION,
@@ -97,36 +73,6 @@ def enumerate_entry_points_parsers():
             "cve-bin-tool = cve_bin_tool.cli:main",
             "csv2cve = cve_bin_tool.csv2cve:main",
         ],
-        "cve_bin_tool.checker": [
-            "{} = cve_bin_tool.checkers.{}:{}".format(
-                filename.replace(".py", ""),
-                filename.replace(".py", ""),
-                "".join(
-                    (filename.replace(".py", "") + " checker")
-                    .replace("_", " ")
-                    .title()
-                    .split()
-                ),
-            )
-            for filename in os.listdir(
-                os.path.join(
-                    os.path.abspath(os.path.dirname(__file__)),
-                    "cve_bin_tool",
-                    "checkers",
-                )
-            )
-            if filename.endswith(".py") and "__init__" not in filename
-        ],
-        "cve_bin_tool.parsers": [
-            "{} = {}".format(
-                parser_entry_point_name,
-                entry_point_path,
-            )
-            for (
-                parser_entry_point_name,
-                entry_point_path,
-            ) in enumerate_entry_points_parsers().items()
-        ],
     },
 )
 

test/test_checkers.py

@@ -4,19 +4,13 @@
 from __future__ import annotations
 
 import re
-import sys
 
 import pytest
 
-from cve_bin_tool.checkers import Checker, VendorProductPair
+from cve_bin_tool.checkers import BUILTIN_CHECKERS, Checker, VendorProductPair
 from cve_bin_tool.egg_updater import IS_DEVELOP, update_egg
 from cve_bin_tool.log import LOGGER
 
-if sys.version_info >= (3, 10):
-    from importlib import metadata as importlib_metadata
-else:
-    import importlib_metadata
-
 Pattern = type(re.compile("", 0))
 
 
@@ -136,10 +130,7 @@ def setup_class(cls):
     )
     def test_filename_is(self, checker_name, file_name, expected_results):
         """Test a checker's filename detection"""
-        checkers = importlib_metadata.entry_points().select(
-            group="cve_bin_tool.checker"
-        )
-        for checker in checkers:
+        for checker in BUILTIN_CHECKERS.values():
             if checker.name == checker_name:
                 Checker = checker.load()
                 checker = Checker()