fosslight-util 1.4.48__py3-none-any.whl → 2.0.0__py3-none-any.whl

fosslight_util/compare_yaml.py

@@ -4,9 +4,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
-import os
 from fosslight_util.constant import LOGGER_NAME
-from fosslight_util.parsing_yaml import parsing_yml
 
 logger = logging.getLogger(LOGGER_NAME)
 VERSION = 'version'
@@ -14,12 +12,16 @@ LICENSE = 'license'
 NAME = 'name'
 
 
-def compare_yaml(before_file, after_file):
-    before_oss_items, _, _ = parsing_yml(before_file, os.path.dirname(before_file))
-    after_oss_items, _, _ = parsing_yml(after_file, os.path.dirname(after_file))
+def compare_yaml(before_fileitems, after_fileitems):
+    bf_raw = []
+    af_raw = []
+    for bf in before_fileitems:
+        bf_raw.extend(bf.get_print_json())
+    for af in after_fileitems:
+        af_raw.extend(af.get_print_json())
 
-    before_items = get_merged_item(before_oss_items)
-    after_items = get_merged_item(after_oss_items)
+    before_items = get_merged_item(bf_raw)
+    after_items = get_merged_item(af_raw)
 
     new_before = []
     for bi in before_items:
@@ -72,13 +74,18 @@ def compare_yaml(before_file, after_file):
 def get_merged_item(oss_items):
     item_list = []
     for oi in oss_items:
-        if oi.exclude:
+        if oi.get("exclude", None):
             continue
-        item_info = {NAME: oi.name, VERSION: oi.version, LICENSE: oi.license}
+        oi_name = oi.get("name", '')
+        oi_version = oi.get("version", '')
+        oi_license = oi.get("license", '')
+        if not (oi_name and oi_version and oi_license):
+            continue
+        item_info = {NAME: oi_name, VERSION: oi_version, LICENSE: oi_license}
 
-        filtered = next(filter(lambda oss_dict: oss_dict[NAME] == oi.name and oss_dict[VERSION] == oi.version, item_list), None)
+        filtered = next(filter(lambda oss_dict: oss_dict[NAME] == oi_name and oss_dict[VERSION] == oi_version, item_list), None)
         if filtered:
-            filtered[LICENSE].extend(oi.license)
+            filtered[LICENSE].extend(oi_license)
             filtered[LICENSE] = list(set(filtered[LICENSE]))
         else:
             item_list.append(item_info)

fosslight_util/constant.py

@@ -15,6 +15,17 @@ supported_sheet_and_scanner = {'SRC': FL_SOURCE,
                                f'BIN_{FL_BINARY}': FL_BINARY,
                                f'DEP_{FL_DEPENDENCY}': FL_DEPENDENCY}
 
+FOSSLIGHT_SCANNER = 'fosslight_scanner'
+FOSSLIGHT_SOURCE = 'fosslight_source'
+FOSSLIGHT_DEPENDENCY = 'fosslight_dependency'
+FOSSLIGHT_BINARY = 'fosslight_binary'
+
+SHEET_NAME_FOR_SCANNER = {
+    FOSSLIGHT_SOURCE: 'SRC_FL_Source',
+    FOSSLIGHT_BINARY: 'BIN_FL_Binary',
+    FOSSLIGHT_DEPENDENCY: 'DEP_FL_Dependency'
+}
+
 # Github : https://github.com/(owner)/(repo)
 # npm : https://www.npmjs.com/package/(package)/v/(version)
 # npm2 : https://www.npmjs.com/package/@(group)/(package)/v/(version)

fosslight_util/convert_excel_to_yaml.py

@@ -33,7 +33,7 @@ def find_report_file(path_to_find):
     return ""
 
 
-def convert_excel_to_yaml(oss_report_to_read, output_file, sheet_names=""):
+def convert_excel_to_yaml(oss_report_to_read: str, output_file: str, sheet_names: str = "") -> None:
     _file_extension = ".yaml"
     yaml_dict = {}
 

fosslight_util/correct.py

@@ -7,19 +7,16 @@ import logging
 import os
 import copy
 import re
-from fosslight_util.constant import LOGGER_NAME
+from fosslight_util.constant import LOGGER_NAME, FOSSLIGHT_SOURCE
 from fosslight_util.parsing_yaml import parsing_yml
-import fosslight_util.constant as constant
-from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(LOGGER_NAME)
 SBOM_INFO_YAML = r"sbom(-|_)info[\s\S]*.ya?ml"
 
 
-def correct_with_yaml(correct_filepath, path_to_scan, scanner_oss_list):
+def correct_with_yaml(correct_filepath, path_to_scan, scan_item):
     success = True
     msg = ""
-    correct_list = {}
     correct_yaml = ""
     if correct_filepath == "":
         correct_filepath = path_to_scan
@@ -33,101 +30,60 @@ def correct_with_yaml(correct_filepath, path_to_scan, scanner_oss_list):
     if not correct_yaml:
         msg = f"Cannot find sbom-info.yaml in {correct_filepath}."
         success = False
-        return success, msg, correct_list
+        return success, msg, scan_item
 
     rel_path = os.path.relpath(path_to_scan, correct_filepath)
 
-    yaml_oss_list, _, err_msg = parsing_yml(correct_yaml, os.path.dirname(correct_yaml), print_log=True)
-
+    yaml_file_list, _, err_msg = parsing_yml(correct_yaml, os.path.dirname(correct_yaml), print_log=True)
     find_match = False
-    matched_yaml = []
-    for yitem in yaml_oss_list:
-        matched_yaml.append([0]*len(yitem.source_name_or_path))
-
-    for sheet_name, sheet_contents in scanner_oss_list.items():
-        if sheet_name not in constant.supported_sheet_and_scanner.keys():
-            continue
-        correct_contents = copy.deepcopy(sheet_contents)
-        scanner_name = constant.supported_sheet_and_scanner[sheet_name]
-        matched_source_path_with_sbom = []
-        for idx, oss_raw_item in enumerate(sheet_contents):
-            if len(oss_raw_item) < 9:
-                logger.warning(f"sheet list is too short ({len(oss_raw_item)}): {oss_raw_item}")
+    for scanner_name, _ in scan_item.file_items.items():
+        correct_fileitems = []
+        exclude_fileitems = []
+        for yaml_file_item in yaml_file_list:
+            yaml_path_exists = False
+            if yaml_file_item.source_name_or_path == '':
+                if scanner_name == FOSSLIGHT_SOURCE:
+                    correct_item = copy.deepcopy(yaml_file_item)
+                    correct_item.comment = 'Added by sbom-info.yaml'
+                    correct_fileitems.append(correct_item)
                 continue
-            oss_item = OssItem('')
-            oss_item.set_sheet_item(oss_raw_item, scanner_name)
+            for idx, scan_file_item in enumerate(scan_item.file_items[scanner_name]):
+                oss_rel_path = os.path.normpath(os.path.join(rel_path, scan_file_item.source_name_or_path))
+                yi_path = yaml_file_item.source_name_or_path
+                if ((os.path.normpath(yi_path) == os.path.normpath(oss_rel_path)) or
+                   ((os.path.normpath(oss_rel_path).startswith(os.path.normpath(yi_path.rstrip('*')))))):
+                    correct_item = copy.deepcopy(scan_file_item)
+                    correct_item.exclude = yaml_file_item.exclude
+                    correct_item.oss_items = copy.deepcopy(yaml_file_item.oss_items)
+                    correct_item.comment = ''
+                    correct_item.comment = 'Loaded from sbom-info.yaml'
+                    correct_fileitems.append(correct_item)
 
-            matched_yi = []
-            if not oss_item.source_name_or_path[0] in matched_source_path_with_sbom:
-                oss_rel_path = os.path.normpath(os.path.join(rel_path, oss_item.source_name_or_path[0]))
-                for y_idx, yi in enumerate(yaml_oss_list):
-                    if not yi.source_name_or_path:
-                        continue
-                    for ys_idx, yi_path in enumerate(yi.source_name_or_path):
-                        yi_item = copy.deepcopy(yi)
-                        if ((os.path.normpath(yi_path) == os.path.normpath(oss_rel_path)) or
-                                ((os.path.normpath(oss_rel_path).startswith(os.path.normpath(yi_path.rstrip('*')))))):
-                            find_match = True
-                            yi_item.source_name_or_path = []
-                            yi_item.source_name_or_path = oss_item.source_name_or_path[0]
-                            matched_source_path_with_sbom.append(oss_item.source_name_or_path[0])
-                            matched_yi.append(yi_item)
-                            matched_yaml[y_idx][ys_idx] = 1
-                if len(matched_yi) > 0:
-                    for matched_yi_item in matched_yi:
-                        matched_oss_item = copy.deepcopy(matched_yi_item)
-                        if matched_oss_item.comment:
-                            matched_oss_item.comment += '/'
-                        matched_oss_item.comment += 'Loaded from sbom-info.yaml'
-                        if sheet_name == 'BIN_FL_Binary':
-                            matched_oss_item.bin_vulnerability = oss_item.bin_vulnerability
-                            matched_oss_item.bin_tlsh = oss_item.bin_tlsh
-                            matched_oss_item.bin_sha1 = oss_item.bin_sha1
-                        matched_oss_array = matched_oss_item.get_print_array(scanner_name)[0]
-                        correct_contents.append(matched_oss_array)
-                    oss_item.exclude = True
-                    if oss_item.comment:
-                        oss_item.comment += '/'
-                    oss_item.comment += 'Excluded by sbom-info.yaml'
-                    correct_contents[idx] = oss_item.get_print_array(scanner_name)[0]
-            else:
-                oss_item.exclude = True
-                if oss_item.comment:
-                    oss_item.comment += '/'
-                oss_item.comment += 'Excluded by sbom-info.yaml'
-                correct_contents[idx] = oss_item.get_print_array(scanner_name)[0]
+                    yaml_path_exists = True
+                    exclude_fileitems.append(idx)
 
-        if sheet_name == 'SRC_FL_Source':
-            for n_idx, ni in enumerate(matched_yaml):
-                y_item = copy.deepcopy(yaml_oss_list[n_idx])
-                all_matched = False
-                if sum(ni) != 0:
-                    not_matched_path = []
-                    for idx, id in enumerate(ni):
-                        if not id:
-                            not_matched_path.append(y_item.source_name_or_path[idx])
-                    y_item.source_name_or_path = []
-                    y_item.source_name_or_path = not_matched_path
-                    if len(not_matched_path) == 0:
-                        all_matched = True
-                if y_item.comment:
-                    y_item.comment += '/'
-                y_item.comment += 'Added by sbom-info.yaml'
-                if not (y_item.source_name_or_path or all_matched):
-                    correct_contents.append(y_item.get_print_array()[0])
-                    continue
-                for y_path in y_item.source_name_or_path:
-                    y_item_i = copy.deepcopy(y_item)
-                    if not os.path.exists(os.path.normpath(os.path.join(correct_filepath, y_path))):
-                        y_item_i.exclude = True
-                    y_item_i.source_name_or_path = []
-                    y_item_i.source_name_or_path = y_path
-                    correct_contents.append(y_item_i.get_print_array()[0])
-        correct_list[sheet_name] = correct_contents
+            if not yaml_path_exists:
+                correct_item = copy.deepcopy(yaml_file_item)
+                if os.path.exists(os.path.normpath(yaml_file_item.source_name_or_path)):
+                    correct_item.comment = 'Loaded from sbom-info.yaml'
+                    correct_fileitems.append(correct_item)
+                else:
+                    if scanner_name == FOSSLIGHT_SOURCE:
+                        correct_item.exclude = True
+                        correct_item.comment = 'Added by sbom-info.yaml'
+                        correct_fileitems.append(correct_item)
+        if correct_fileitems:
+            scan_item.append_file_items(correct_fileitems, scanner_name)
+            find_match = True
+        if exclude_fileitems:
+            exclude_fileitems = list(set(exclude_fileitems))
+            for e_idx in exclude_fileitems:
+                scan_item.file_items[scanner_name][e_idx].exclude = True
+                scan_item.file_items[scanner_name][e_idx].comment = 'Excluded by sbom-info.yaml'
 
     if not find_match:
         success = False
         err_msg = 'No match items in sbom-info.yaml'
-        return success, err_msg, yaml_oss_list
+        return success, err_msg, scan_item
 
-    return success, msg, correct_list
+    return success, msg, scan_item

fosslight_util/help.py

@@ -35,12 +35,11 @@ _HELP_MESSAGE_DOWNLOAD = """
 
 
 class PrintHelpMsg():
-    message_suffix = ""
 
-    def __init__(self, value):
+    def __init__(self, value: str = ""):
         self.message_suffix = value
 
-    def print_help_msg(self, exitopt):
+    def print_help_msg(self, exitopt: bool) -> None:
         print(_HELP_MESSAGE_COMMON)
         print(self.message_suffix)
 
@@ -48,7 +47,7 @@ class PrintHelpMsg():
             sys.exit()
 
 
-def print_package_version(pkg_name, msg="", exitopt=True):
+def print_package_version(pkg_name: str, msg: str = "", exitopt: bool = True) -> str:
     if msg == "":
         msg = f"{pkg_name} Version:"
     cur_version = pkg_resources.get_distribution(pkg_name).version

fosslight_util/oss_item.py

@@ -5,46 +5,41 @@
 
 import logging
 import os
-from fosslight_util.constant import LOGGER_NAME, FL_DEPENDENCY, FL_BINARY
+from fosslight_util.constant import LOGGER_NAME, FOSSLIGHT_SCANNER
+from fosslight_util.cover import CoverItem
+from typing import List, Dict
 
 _logger = logging.getLogger(LOGGER_NAME)
 
 
 class OssItem:
-    def __init__(self, value):
-        self._name = ""
-        self._version = ""
+
+    def __init__(self, name="", version="", license="", dl_url=""):
+        self.name = name
+        self.version = version
         self._license = []
-        self._copyright = ""
+        self.license = license
+        self.download_location = dl_url
+        self.exclude = False
         self.comment = ""
-        self._exclude = False
         self.homepage = ""
-        self.relative_path = value
-        self._source_name_or_path = []
-        self.download_location = ""
-        self._yocto_recipe = []
-        self._yocto_package = []
-        self.is_binary = False
-        self._depends_on = []
-        self.purl = ""
-        self.bin_vulnerability = ""
-        self.bin_tlsh = ""
-        self.bin_sha1 = ""
+        self._copyright = ""
 
     def __del__(self):
         pass
 
     @property
-    def copyright(self):
-        return self._copyright
+    def license(self):
+        return self._license
 
-    @copyright.setter
-    def copyright(self, value):
+    @license.setter
+    def license(self, value):
         if value != "":
-            if isinstance(value, list):
-                value = "\n".join(value)
-            value = value.strip()
-        self._copyright = value
+            if not isinstance(value, list):
+                value = value.split(",")
+            self._license.extend(value)
+        self._license = [item.strip() for item in self._license]
+        self._license = list(set(self._license))
 
     @property
     def exclude(self):
@@ -58,13 +53,16 @@ class OssItem:
             self._exclude = False
 
     @property
-    def name(self):
-        return self._name
+    def copyright(self):
+        return self._copyright
 
-    @name.setter
-    def name(self, value):
+    @copyright.setter
+    def copyright(self, value):
         if value != "":
-            self._name = value
+            if isinstance(value, list):
+                value = "\n".join(value)
+            value = value.strip()
+        self._copyright = value
 
     @property
     def version(self):
@@ -78,149 +76,144 @@ class OssItem:
             self._version = ""
 
     @property
-    def license(self):
-        return self._license
-
-    @license.setter
-    def license(self, value):
-        if not isinstance(value, list):
-            value = value.split(",")
-        self._license.extend(value)
-        self._license = [item.strip() for item in self._license]
-        self._license = list(set(self._license))
-
-    @property
-    def source_name_or_path(self):
-        return self._source_name_or_path
+    def comment(self):
+        return self._comment
 
-    @source_name_or_path.setter
-    def source_name_or_path(self, value):
+    @comment.setter
+    def comment(self, value):
         if not value:
-            self._source_name_or_path = []
+            self._comment = ""
         else:
-            if not isinstance(value, list):
-                value = value.split(",")
-            self._source_name_or_path.extend(value)
-            self._source_name_or_path = [item.strip() for item in self._source_name_or_path]
-            self._source_name_or_path = list(set(self._source_name_or_path))
+            if self._comment:
+                self._comment = f"{self._comment} / {value}"
+            else:
+                self._comment = value
 
-    @property
-    def yocto_recipe(self):
-        return self._yocto_recipe
 
-    @yocto_recipe.setter
-    def yocto_recipe(self, value):
-        if not isinstance(value, list):
-            value = value.split(",")
-        self._yocto_recipe.extend(value)
-        self._yocto_recipe = [item.strip() for item in self._yocto_recipe]
-        self._yocto_recipe = list(set(self._yocto_recipe))
+class FileItem:
+    def __init__(self, value):
+        self.relative_path = value
+        self.source_name_or_path = ""
+        self._exclude = False
+        self._comment = ""
+        self.is_binary = False
+        self.oss_items: List[OssItem] = []
+
+    def __del__(self):
+        pass
 
     @property
-    def yocto_package(self):
-        return self._yocto_package
+    def exclude(self):
+        return self._exclude
 
-    @yocto_package.setter
-    def yocto_package(self, value):
-        if not isinstance(value, list):
-            value = value.split(",")
-        self._yocto_package.extend(value)
-        self._yocto_package = [item.strip() for item in self._yocto_package]
-        self._yocto_package = list(set(self._yocto_package))
+    @exclude.setter
+    def exclude(self, value):
+        if value:
+            self._exclude = True
+        else:
+            self._exclude = False
+        for oss in self.oss_items:
+            oss.exclude = value
 
     @property
-    def depends_on(self):
-        return self._depends_on
+    def comment(self):
+        return self._comment
 
-    @depends_on.setter
-    def depends_on(self, value):
+    @comment.setter
+    def comment(self, value):
         if not value:
-            self._depends_on = []
-        else:
-            if not isinstance(value, list):
-                value = value.split(",")
-            self._depends_on.extend(value)
-            self._depends_on = [item.strip() for item in self._depends_on]
-            self._depends_on = list(set(self._depends_on))
-
-    def set_sheet_item(self, item, scanner_name=''):
-        if len(item) < 9:
-            _logger.warning(f"sheet list is too short ({len(item)}): {item}")
-            return
-        if scanner_name == FL_DEPENDENCY:
-            self.purl = item[0]
+            self._comment = ""
         else:
-            self.source_name_or_path = item[0]
-        self.name = item[1]
-        self.version = item[2]
-        self.license = item[3]
-        self.download_location = item[4]
-        self.homepage = item[5]
-        self.copyright = item[6]
-        self.exclude = item[7]
-        self.comment = item[8]
-
-        if len(item) >= 10 and scanner_name == FL_DEPENDENCY:
-            self.depends_on = item[9]
-        if len(item) >= 10 and scanner_name == FL_BINARY:
-            self.bin_vulnerability = item[9]
-            if len(item) >= 12:
-                self.bin_tlsh = item[10]
-                self.bin_sha1 = item[11]
-
-    def get_print_array(self, scanner_name=''):
+            if self._comment:
+                self._comment = f"{self._comment} / {value}"
+            else:
+                self._comment = value
+            for oss in self.oss_items:
+                oss.comment = value
+
+    def get_print_array(self):
         items = []
-        if scanner_name != FL_DEPENDENCY:
-            if len(self.source_name_or_path) == 0:
-                self.source_name_or_path.append("")
-        if len(self.license) == 0:
-            self.license.append("")
-
-        exclude = "Exclude" if self.exclude else ""
-        lic = ",".join(self.license)
-        if scanner_name == FL_DEPENDENCY:
-            items = [self.purl, self.name, self.version, lic,
-                     self.download_location, self.homepage, self.copyright, exclude, self.comment]
-            if len(self.depends_on) > 0:
-                items.append(",".join(self.depends_on))
-        else:
-            for source_name_or_path in self.source_name_or_path:
-                if scanner_name == FL_BINARY:
-                    oss_item = [os.path.join(self.relative_path, source_name_or_path), self.name, self.version, lic,
-                                self.download_location, self.homepage, self.copyright, exclude, self.comment,
-                                self.bin_vulnerability, self.bin_tlsh, self.bin_sha1]
-                else:
-                    oss_item = [os.path.join(self.relative_path, source_name_or_path), self.name, self.version, lic,
-                                self.download_location, self.homepage, self.copyright, exclude, self.comment]
-                items.append(oss_item)
+
+        for oss in self.oss_items:
+            exclude = "Exclude" if self.exclude or oss.exclude else ""
+            lic = ",".join(oss.license)
+
+            oss_item = [os.path.join(self.relative_path, self.source_name_or_path), oss.name, oss.version, lic,
+                        oss.download_location, oss.homepage, oss.copyright, exclude, oss.comment]
+            items.append(oss_item)
         return items
 
     def get_print_json(self):
-        json_item = {}
-        json_item["name"] = self.name
-
-        json_item["version"] = self.version
-        if len(self.source_name_or_path) > 0:
-            json_item["source path"] = self.source_name_or_path
-        if len(self.license) > 0:
-            json_item["license"] = self.license
-        if self.download_location != "":
-            json_item["download location"] = self.download_location
-        if self.homepage != "":
-            json_item["homepage"] = self.homepage
-        if self.copyright != "":
-            json_item["copyright text"] = self.copyright
-        if self.exclude:
-            json_item["exclude"] = self.exclude
-        if self.comment != "":
-            json_item["comment"] = self.comment
-        if len(self.depends_on) > 0:
-            json_item["depends on"] = self.depends_on
-        if self.purl != "":
-            json_item["package url"] = self.purl
-
-        return json_item
+        items = []
+
+        for oss in self.oss_items:
+            json_item = {}
+            json_item["name"] = oss.name
+            json_item["version"] = oss.version
+
+            if self.source_name_or_path != "":
+                json_item["source path"] = self.source_name_or_path
+            if len(oss.license) > 0:
+                json_item["license"] = oss.license
+            if oss.download_location != "":
+                json_item["download location"] = oss.download_location
+            if oss.homepage != "":
+                json_item["homepage"] = oss.homepage
+            if oss.copyright != "":
+                json_item["copyright text"] = oss.copyright
+            if self.exclude or oss.exclude:
+                json_item["exclude"] = True
+            if oss.comment != "":
+                json_item["comment"] = oss.comment
+            items.append(json_item)
+        return items
 
 
 def invalid(cmd):
     _logger.info('[{}] is invalid'.format(cmd))
+
+
+class ScannerItem:
+    def __init__(self, pkg_name, start_time=""):
+        self.cover = CoverItem(tool_name=pkg_name, start_time=start_time)
+        self.file_items: Dict[str, List[FileItem]] = {pkg_name: []} if pkg_name != FOSSLIGHT_SCANNER else {}
+        self.external_sheets: Dict[str, List[List[str]]] = {}
+
+    def set_cover_pathinfo(self, input_dir, path_to_exclude):
+        self.cover.input_path = input_dir
+        self.cover.exclude_path = ", ".join(path_to_exclude)
+
+    def set_cover_comment(self, value):
+        if value:
+            if self.cover.comment:
+                self.cover.comment = f"{self.cover.comment} / {value}"
+            else:
+                self.cover.comment = value
+
+    def get_cover_comment(self):
+        return [item.strip() for item in self.cover.comment.split(" / ")]
+
+    def append_file_items(self, file_item: List[FileItem], pkg_name=""):
+        if pkg_name == "":
+            if len(self.file_items.keys()) != 1:
+                _logger.error("Package name is not set. Cannot append file_item into ScannerItem.")
+            else:
+                pkg_name = list(self.file_items.keys())[0]
+        if pkg_name not in self.file_items:
+            self.file_items[pkg_name] = []
+        self.file_items[pkg_name].extend(file_item)
+
+    def get_print_array(self, scanner_name):
+        items = []
+        for file_item in self.file_items[scanner_name]:
+            items.extend(file_item.get_print_array())
+        return items
+
+    def get_print_json(self, scanner_name):
+        items = []
+        for file_item in self.file_items[scanner_name]:
+            items.extend(file_item.get_print_json())
+        return items
+
+    def __del__(self):
+        pass