fix test and linting

Author: Leon-hk

src/gardenlinux/features/reproducibility/__main__.py

@@ -14,7 +14,7 @@
 from .markdown_formatter import MarkdownFormatter
 
 
-def generate(args) -> None:
+def generate(args: argparse.Namespace) -> None:
     """
     Call Comparator
 
@@ -41,7 +41,7 @@ def generate(args) -> None:
         exit(1)
 
 
-def format(args) -> None:
+def format(args: argparse.Namespace) -> None:
     """
     Call MarkdownFormatter
 

src/gardenlinux/features/reproducibility/comparator.py

@@ -11,6 +11,7 @@
 import tempfile
 from os import PathLike
 from pathlib import Path
+from typing import Optional
 
 
 class Comparator(object):
@@ -26,7 +27,7 @@ class Comparator(object):
                  Apache License, Version 2.0
     """
 
-    _default_whitelist = []
+    _default_whitelist: list[str] = []
 
     _nightly_whitelist = [
         r"/etc/apt/sources\.list\.d/gardenlinux\.sources",
@@ -56,7 +57,7 @@ def __init__(
             self.whitelist += self._nightly_whitelist
 
     @staticmethod
-    def _unpack(file: PathLike[str]) -> tempfile.TemporaryDirectory:
+    def _unpack(file: PathLike[str]) -> tempfile.TemporaryDirectory[str]:
         """
         Unpack a .tar archive or .oci image into a temporary dictionary
 
@@ -112,8 +113,8 @@ def _unpack(file: PathLike[str]) -> tempfile.TemporaryDirectory:
         return output_dir
 
     def _diff_files(
-        self, cmp: filecmp.dircmp, left_root: PathLike[str] = None
-    ) -> list[Path]:
+        self, cmp: filecmp.dircmp[str], left_root: Optional[Path] = None
+    ) -> list[str]:
         """
         Recursively compare files
 
@@ -126,14 +127,14 @@ def _diff_files(
 
         result = []
         if not left_root:
-            left_root = cmp.left
+            left_root = Path(cmp.left)
         for name in cmp.diff_files:
-            result.append(f"/{Path(cmp.left).relative_to(left_root).joinpath(name)}")
+            result.append(f"/{left_root.relative_to(left_root).joinpath(name)}")
         for sub_cmp in cmp.subdirs.values():
             result += self._diff_files(sub_cmp, left_root=left_root)
         return result
 
-    def generate(self, a: PathLike[str], b: PathLike[str]) -> tuple[list[Path], bool]:
+    def generate(self, a: PathLike[str], b: PathLike[str]) -> tuple[list[str], bool]:
         """
         Compare two .tar/.oci images with each other
 
@@ -144,7 +145,7 @@ def generate(self, a: PathLike[str], b: PathLike[str]) -> tuple[list[Path], bool
         :since: 1.0.0
         """
 
-        if filecmp.cmp(a, b):
+        if filecmp.cmp(a, b, shallow=False):
             return [], False
 
         with self._unpack(a) as unpacked_a, self._unpack(b) as unpacked_b:

src/gardenlinux/features/reproducibility/diff_parser.py

@@ -9,7 +9,7 @@
 import re
 from os import PathLike
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any, Dict, Optional
 
 import networkx as nx
 
@@ -56,30 +56,30 @@ def __init__(
         self._parser = Parser(gardenlinux_root, feature_dir_name, logger)
         self._feature_dir_name = Path(self._gardenlinux_root).joinpath(feature_dir_name)
 
-        self.all = set()
-        self.successful = []
-        self.whitelist = []
-        self.expected_falvors = set()
-        self.missing_flavors = set()
-        self.unexpected_falvors = set()
+        self.all: set[str] = set()
+        self.successful: set[str] = set()
+        self.whitelist: set[str] = set()
+        self.expected_falvors: set[str] = set()
+        self.missing_flavors: set[str] = set()
+        self.unexpected_falvors: set[str] = set()
 
-    def read_feature_info(self, feature: str) -> dict[str, Any]:
+    def read_feature_info(self, feature: str) -> Any:
         """
         Read the content of the feature info.yaml
 
         :param feature:                 The queried feature
 
-        :return: dict[str, Any]         Parsed content of the features' info.yaml file
+        :return: Dict[str, Any]         Parsed content of the features' info.yaml file
         :since: 1.0.0
         """
         return self._parser.read_feature_yaml(
-            self._feature_dir_name.joinpath(f"{feature}/info.yaml")
+            str(self._feature_dir_name.joinpath(f"{feature}/info.yaml"))
         )["content"]
 
     def parse(
         self,
-        flavors_matrix: dict[str, list[dict[str, str]]],
-        bare_flavors_matrix: dict[str, list[dict[str, str]]],
+        flavors_matrix: Dict[str, list[Dict[str, str]]],
+        bare_flavors_matrix: Dict[str, list[Dict[str, str]]],
         diff_dir: PathLike[str] = Path("diffs"),
     ) -> None:
         """
@@ -93,20 +93,16 @@ def parse(
         """
 
         self.all = set()
-        self.successful = []
-        self.whitelist = []
+        self.successful = set()
+        self.whitelist = set()
         failed = {}  # {flavor: [files...]}
 
         diff_dir = Path(self._gardenlinux_root).joinpath(diff_dir)
 
-        self.expected_falvors = set(
-            [
-                f"{variant['flavor']}-{variant['arch']}"
-                for variant in (
-                    flavors_matrix["include"] + bare_flavors_matrix["include"]
-                )
-            ]
-        )
+        self.expected_falvors = {
+            f"{variant['flavor']}-{variant['arch']}"
+            for variant in (flavors_matrix["include"] + bare_flavors_matrix["include"])
+        }
 
         for flavor in os.listdir(diff_dir):
             if flavor.endswith(self._SUFFIX):
@@ -116,38 +112,38 @@ def parse(
                 flavor = flavor.rstrip(self._SUFFIX)
                 self.all.add(flavor)
                 if content == "":
-                    self.successful.append(flavor)
+                    self.successful.add(flavor)
                 elif content == "whitelist\n":
-                    self.successful.append(flavor)
-                    self.whitelist.append(flavor)
+                    self.successful.add(flavor)
+                    self.whitelist.add(flavor)
                 else:
                     failed[flavor] = content.split("\n")[:-1]
 
         self.missing_flavors = self.expected_falvors - self.all
         self.unexpected_falvors = self.all - self.expected_falvors
 
         # Map files to flavors
-        affected: dict[str, set[str]] = {}  # {file: {flavors...}}
+        affected: Dict[str, set[str]] = {}  # {file: {flavors...}}
         for flavor in failed:
             for file in failed[flavor]:
                 if file not in affected:
                     affected[file] = set()
                 affected[file].add(flavor)
 
         # Merge files affected by the same flavors by mapping flavor sets to files
-        self._bundled: dict[frozenset[str], set[str]] = {}  # {{flavors...}: {files...}}
+        self._bundled: Dict[frozenset[str], set[str]] = {}  # {{flavors...}: {files...}}
         for file in affected:
             if frozenset(affected[file]) not in self._bundled:
                 self._bundled[frozenset(affected[file])] = set()
             self._bundled[frozenset(affected[file])].add(file)
 
     def intersectionTrees(
         self,
-    ) -> dict[frozenset[str], tuple[frozenset[str], nx.DiGraph]]:
+    ) -> Dict[frozenset[str], tuple[frozenset[str], nx.DiGraph]]:
         """
         Intersects all features of the affected flavors and removes all features from unaffected flavors to identify features causing the issue
 
-        :return: (dict[frozenset[str], tuple[frozenset[str], nx.DiGraph]]) Dict in the form of {{files...}: ({flavors..., intersectionTree})}
+        :return: (Dict[frozenset[str], tuple[frozenset[str], nx.DiGraph]]) Dict in the form of {{files...}: ({flavors..., intersectionTree})}
         :since:  1.0.0
         """