Remove unused code in python_gardenlinux_lib module

Signed-off-by: Tobias Wolf <[email protected]>

Author: NotTheEvilOne

src/gardenlinux/apt/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+from .debsource import Debsrc, DebsrcFile
+
+__all__ = ["Parser"]

src/gardenlinux/apt/parse_debsource.py src/gardenlinux/apt/debsource.pysrc/gardenlinux/apt/parse_debsource.py renamed to src/gardenlinux/apt/debsource.py

@@ -1,8 +1,12 @@
 # -*- coding: utf-8 -*-
 
 # GardenLinux "bare" feature
-BARE_FLAVOR_FEATURE_CONTENT = { "description": "Bare flavor", "type": "platform" }
-BARE_FLAVOR_LIBC_FEATURE_CONTENT = { "description": "Bare libc feature", "type": "element" }
+BARE_FLAVOR_FEATURE_CONTENT = {"description": "Bare flavor", "type": "platform"}
+
+BARE_FLAVOR_LIBC_FEATURE_CONTENT = {
+    "description": "Bare libc feature",
+    "type": "element",
+}
 
 # GardenLinux flavors schema for validation
 GL_FLAVORS_SCHEMA = {
@@ -31,15 +35,22 @@
                                 "test-platform": {"type": "boolean"},
                                 "publish": {"type": "boolean"},
                             },
-                            "required": ["features", "arch", "build", "test", "test-platform", "publish"],
+                            "required": [
+                                "features",
+                                "arch",
+                                "build",
+                                "test",
+                                "test-platform",
+                                "publish",
+                            ],
                         },
                     },
                 },
                 "required": ["name", "category", "flavors"],
             },
         },
     },
-    "required": ["targets"]
+    "required": ["targets"],
 }
 
 # It is important that this list is sorted in descending length of the entries

src/gardenlinux/constants.py

@@ -20,26 +20,38 @@
     "elements",
     "arch",
     "version",
-    "graph"
+    "graph",
 ]
 
 
 def main():
     parser = argparse.ArgumentParser()
 
-    parser.add_argument("--arch", dest = "arch")
-    parser.add_argument("--feature-dir", default = "features")
-    parser.add_argument("--features", type = lambda arg: set([f for f in arg.split(",") if f]))
-    parser.add_argument("--ignore", dest = "ignore", type = lambda arg: set([f for f in arg.split(",") if f]), default = set())
+    parser.add_argument("--arch", dest="arch")
+    parser.add_argument("--feature-dir", default="features")
     parser.add_argument("--cname")
     parser.add_argument("--default-arch")
     parser.add_argument("--default-version")
     parser.add_argument("--version", dest="version")
-    parser.add_argument("type", nargs="?", choices = _ARGS_TYPE_ALLOWED, default = "cname")
+
+    parser.add_argument(
+        "--features", type=lambda arg: set([f for f in arg.split(",") if f])
+    )
+
+    parser.add_argument(
+        "--ignore",
+        dest="ignore",
+        type=lambda arg: set([f for f in arg.split(",") if f]),
+        default=set(),
+    )
+
+    parser.add_argument("type", nargs="?", choices=_ARGS_TYPE_ALLOWED, default="cname")
 
     args = parser.parse_args()
 
-    assert bool(args.features) or bool(args.cname), "Please provide either `--features` or `--cname` argument"
+    assert bool(args.features) or bool(
+        args.cname
+    ), "Please provide either `--features` or `--cname` argument"
 
     arch = None
     cname_base = None
@@ -50,7 +62,7 @@ def main():
     if args.cname:
         re_match = re.match(
             "([a-zA-Z0-9]+([\\_\\-][a-zA-Z0-9]+)+?)(-([a-z0-9]+)(-([a-z0-9.]+)-([a-z0-9]+))*)?$",
-            args.cname
+            args.cname,
         )
 
         assert re_match, f"Not a valid GardenLinux canonical name {args.cname}"
@@ -85,14 +97,16 @@ def main():
         commit_id = re_match[3]
         version = re_match[1]
 
-    if arch is None or arch == "" and (args.type in ( "cname", "arch" )):
-        assert args.default_arch, "Architecture could not be determined and no default architecture set"
+    if arch is None or arch == "" and (args.type in ("cname", "arch")):
+        assert (
+            args.default_arch
+        ), "Architecture could not be determined and no default architecture set"
         arch = args.default_arch
 
     if not commit_id or not version:
         version, commit_id = get_version_and_commit_id_from_files(gardenlinux_root)
 
-    if not version and (args.type in ("cname", "version" )):
+    if not version and (args.type in ("cname", "version")):
         assert args.default_version, "version not specified and no default version set"
         version = args.default_version
 
@@ -108,15 +122,15 @@ def main():
 
     if args.type == "arch":
         print(arch)
-    elif args.type in ( "cname_base", "cname", "graph" ):
-        graph = Parser(gardenlinux_root, feature_dir_name).filter(cname_base, additional_filter_func = additional_filter_func)
+    elif args.type in ("cname_base", "cname", "graph"):
+        graph = Parser(gardenlinux_root, feature_dir_name).filter(
+            cname_base, additional_filter_func=additional_filter_func
+        )
 
         sorted_features = Parser.sort_graph_nodes(graph)
         minimal_feature_set = get_minimal_feature_set(graph)
 
-        sorted_minimal_features = sort_subset(
-            minimal_feature_set, sorted_features
-        )
+        sorted_minimal_features = sort_subset(minimal_feature_set, sorted_features)
 
         cname_base = get_cname_base(sorted_minimal_features)
 
@@ -135,9 +149,15 @@ def main():
         elif args.type == "graph":
             print(graph_as_mermaid_markup(cname_base, graph))
     elif args.type == "features":
-	    print(Parser(gardenlinux_root, feature_dir_name).filter_as_string(cname_base, additional_filter_func = additional_filter_func))
-    elif args.type in ( "flags", "elements", "platforms" ):
-        features_by_type = Parser(gardenlinux_root, feature_dir_name).filter_as_dict(cname_base, additional_filter_func = additional_filter_func)
+        print(
+            Parser(gardenlinux_root, feature_dir_name).filter_as_string(
+                cname_base, additional_filter_func=additional_filter_func
+            )
+        )
+    elif args.type in ("flags", "elements", "platforms"):
+        features_by_type = Parser(gardenlinux_root, feature_dir_name).filter_as_dict(
+            cname_base, additional_filter_func=additional_filter_func
+        )
 
         if args.type == "platforms":
             print(",".join(features_by_type["platform"]))
@@ -151,9 +171,10 @@ def main():
 
 def get_cname_base(sorted_features):
     return reduce(
-        lambda a, b : a + ("-" if not b.startswith("_") else "") + b, sorted_features
+        lambda a, b: a + ("-" if not b.startswith("_") else "") + b, sorted_features
     )
 
+
 def get_version_and_commit_id_from_files(gardenlinux_root):
     commit_id = None
     version = None
@@ -168,21 +189,24 @@ def get_version_and_commit_id_from_files(gardenlinux_root):
 
     return (version, commit_id)
 
+
 def get_minimal_feature_set(graph):
     return set([node for (node, degree) in graph.in_degree() if degree == 0])
 
+
 def graph_as_mermaid_markup(cname_base, graph):
-	"""
-	Generates a mermaid.js representation of the graph.
-	This is helpful to identify dependencies between features.
-
-	Syntax docs:
-	https://mermaid.js.org/syntax/flowchart.html?id=flowcharts-basic-syntax
-	"""
-	markup = f"---\ntitle: Dependency Graph for Feature {cname_base}\n---\ngraph TD;\n"
-	for u,v in graph.edges:
-		markup += f"    {u}-->{v};\n"
-	return markup
+    """
+    Generates a mermaid.js representation of the graph.
+    This is helpful to identify dependencies between features.
+
+    Syntax docs:
+    https://mermaid.js.org/syntax/flowchart.html?id=flowcharts-basic-syntax
+    """
+    markup = f"---\ntitle: Dependency Graph for Feature {cname_base}\n---\ngraph TD;\n"
+    for u, v in graph.edges:
+        markup += f"    {u}-->{v};\n"
+    return markup
+
 
 def sort_subset(input_set, order_list):
     return [item for item in order_list if item in input_set]

src/gardenlinux/features/__main__.py

@@ -6,7 +6,12 @@
 import argparse
 import re
 
-from .__main__ import get_cname_base, get_minimal_feature_set, get_version_and_commit_id_from_files, sort_subset
+from .__main__ import (
+    get_cname_base,
+    get_minimal_feature_set,
+    get_version_and_commit_id_from_files,
+    sort_subset,
+)
 from .parser import Parser
 
 
@@ -22,7 +27,7 @@ def main():
 
     re_match = re.match(
         "([a-zA-Z0-9]+([\\_\\-][a-zA-Z0-9]+)+?)(-([a-z0-9]+)(-([a-z0-9.]+)-([a-z0-9]+))*)?$",
-        args.cname
+        args.cname,
     )
 
     assert re_match, f"Not a valid GardenLinux canonical name {args.cname}"
@@ -73,9 +78,7 @@ def main():
     sorted_features = Parser.sort_graph_nodes(graph)
     minimal_feature_set = get_minimal_feature_set(graph)
 
-    sorted_minimal_features = sort_subset(
-        minimal_feature_set, sorted_features
-    )
+    sorted_minimal_features = sort_subset(minimal_feature_set, sorted_features)
 
     cname = get_cname_base(sorted_minimal_features)
 

src/gardenlinux/features/cname_main.py

@@ -14,11 +14,18 @@
 
 
 class Parser(object):
-    def __init__(self, gardenlinux_root: str = ".", feature_dir_name: str = "features", logger: Optional[logging.Logger] = None):
+    def __init__(
+        self,
+        gardenlinux_root: str = ".",
+        feature_dir_name: str = "features",
+        logger: Optional[logging.Logger] = None,
+    ):
         feature_base_dir = os.path.join(gardenlinux_root, feature_dir_name)
 
         if not os.access(feature_base_dir, os.R_OK):
-            raise ValueError("Feature directory given is invalid: {0}".format(feature_base_dir))
+            raise ValueError(
+                "Feature directory given is invalid: {0}".format(feature_base_dir)
+            )
 
         if logger is None or not logger.hasHandlers():
             logger = LoggerSetup.get_logger("gardenlinux.features")
@@ -28,7 +35,9 @@ def __init__(self, gardenlinux_root: str = ".", feature_dir_name: str = "feature
         self._graph = None
         self._logger = logger
 
-        self._logger.debug("features.Parser initialized for directory: {0}".format(feature_base_dir))
+        self._logger.debug(
+            "features.Parser initialized for directory: {0}".format(feature_base_dir)
+        )
 
     @property
     def graph(self) -> networkx.Graph:
@@ -49,7 +58,9 @@ def graph(self) -> networkx.Graph:
                         continue
 
                     for ref in node_features[attr]:
-                        if not os.path.isfile("{0}/{1}/info.yaml".format(self._feature_base_dir, ref)):
+                        if not os.path.isfile(
+                            "{0}/{1}/info.yaml".format(self._feature_base_dir, ref)
+                        ):
                             raise ValueError(
                                 f"feature {node} references feature {ref}, but {feature_dir}/{ref}/info.yaml does not exist"
                             )
@@ -67,7 +78,7 @@ def filter(
         self,
         cname: str,
         ignore_excludes: bool = False,
-        additional_filter_func: Optional[Callable[(str,), bool]] = None
+        additional_filter_func: Optional[Callable[(str,), bool]] = None,
     ) -> networkx.Graph:
         input_features = Parser.get_cname_as_feature_set(cname)
         filter_set = input_features.copy()
@@ -80,9 +91,18 @@ def filter(
                 self.graph.add_node("libc", content=BARE_FLAVOR_LIBC_FEATURE_CONTENT)
 
         for feature in input_features:
-            filter_set.update(networkx.descendants(Parser._get_graph_view_for_attr(self.graph, "include"), feature))
+            filter_set.update(
+                networkx.descendants(
+                    Parser._get_graph_view_for_attr(self.graph, "include"), feature
+                )
+            )
 
-        graph = networkx.subgraph_view(self.graph, filter_node = self._get_filter_set_callable(filter_set, additional_filter_func))
+        graph = networkx.subgraph_view(
+            self.graph,
+            filter_node=self._get_filter_set_callable(
+                filter_set, additional_filter_func
+            ),
+        )
 
         if not ignore_excludes:
             Parser._exclude_from_filter_set(graph, input_features, filter_set)
@@ -93,13 +113,13 @@ def filter_as_dict(
         self,
         cname: str,
         ignore_excludes: bool = False,
-        additional_filter_func: Optional[Callable[(str,), bool]] = None
+        additional_filter_func: Optional[Callable[(str,), bool]] = None,
     ) -> dict:
         """
-:param str cname: the target cname to get the feature dict for
-:param str gardenlinux_root: path of garden linux src root
+        :param str cname: the target cname to get the feature dict for
+        :param str gardenlinux_root: path of garden linux src root
 
-:return: dict with list of features for a given cname, split into platform, element and flag
+        :return: dict with list of features for a given cname, split into platform, element and flag
         """
 
         graph = self.filter(cname, ignore_excludes, additional_filter_func)
@@ -121,13 +141,13 @@ def filter_as_list(
         self,
         cname: str,
         ignore_excludes: bool = False,
-        additional_filter_func: Optional[Callable[(str,), bool]] = None
+        additional_filter_func: Optional[Callable[(str,), bool]] = None,
     ) -> list:
         """
-:param str cname: the target cname to get the feature dict for
-:param str gardenlinux_root: path of garden linux src root
+        :param str cname: the target cname to get the feature dict for
+        :param str gardenlinux_root: path of garden linux src root
 
-:return: list of features for a given cname
+        :return: list of features for a given cname
         """
 
         graph = self.filter(cname, ignore_excludes, additional_filter_func)
@@ -137,13 +157,13 @@ def filter_as_string(
         self,
         cname: str,
         ignore_excludes: bool = False,
-        additional_filter_func: Optional[Callable[(str,), bool]] = None
+        additional_filter_func: Optional[Callable[(str,), bool]] = None,
     ) -> str:
         """
-:param str cname: the target cname to get the feature set for
-:param str gardenlinux_root: path of garden linux src root
+        :param str cname: the target cname to get the feature set for
+        :param str gardenlinux_root: path of garden linux src root
 
-:return: a comma separated string with the expanded feature set for the cname
+        :return: a comma separated string with the expanded feature set for the cname
         """
 
         graph = self.filter(cname, ignore_excludes, additional_filter_func)
@@ -200,15 +220,17 @@ def get_cname_as_feature_set(cname):
     @staticmethod
     def _get_filter_set_callable(filter_set, additional_filter_func):
         def filter_func(node):
-            additional_filter_result = True if additional_filter_func is None else additional_filter_func(node)
-            return (node in filter_set and additional_filter_result)
+            additional_filter_result = (
+                True if additional_filter_func is None else additional_filter_func(node)
+            )
+            return node in filter_set and additional_filter_result
 
         return filter_func
 
     @staticmethod
     def _get_graph_view_for_attr(graph, attr):
         return networkx.subgraph_view(
-            graph, filter_edge = Parser._get_graph_view_for_attr_callable(graph, attr)
+            graph, filter_edge=Parser._get_graph_view_for_attr_callable(graph, attr)
         )
 
     @staticmethod
@@ -231,7 +253,7 @@ def key_function(node):
 
             return f"{prefix}-{node}"
 
-        return list(networkx.lexicographical_topological_sort(graph, key = key_function))
+        return list(networkx.lexicographical_topological_sort(graph, key=key_function))
 
     @staticmethod
     def sort_reversed_graph_nodes(graph):