fosslight-source 1.7.16__py3-none-any.whl → 2.1.0__py3-none-any.whl

fosslight_source/_help.py

@@ -30,10 +30,10 @@ _HELP_MESSAGE_SOURCE_SCANNER = """
             --correct_fpath <path> Path to the sbom-info.yaml file"""
 
 
-def print_version(pkg_name):
+def print_version(pkg_name: str) -> None:
     print_package_version(pkg_name, "FOSSLight Source Scanner Version:")
 
 
-def print_help_msg_source_scanner():
+def print_help_msg_source_scanner() -> None:
     helpMsg = PrintHelpMsg(_HELP_MESSAGE_SOURCE_SCANNER)
     helpMsg.print_help_msg(True)

fosslight_source/_license_matched.py

@@ -20,33 +20,33 @@ class MatchedLicense:
     matched_text = ""
     priority = 0
 
-    def __init__(self, lic, category, text, file):
+    def __init__(self, lic: str, category: str, text: str, file: str) -> None:
         self.files = [file]
         self.license = lic
         self.matched_text = text
         self.set_category(category)
 
-    def __del__(self):
+    def __del__(self) -> None:
         pass
 
-    def set_license(self, value):
+    def set_license(self, value: str) -> None:
         self.license = value
 
-    def set_files(self, value):
+    def set_files(self, value: str) -> None:
         if value not in self.files:
             self.files.append(value)
 
-    def set_category(self, value):
+    def set_category(self, value: str) -> None:
         self.category = value
         if value in LOW_PRIORITY:
             self.priority = 1
         else:
             self.priority = 0
 
-    def set_matched_text(self, value):
+    def set_matched_text(self, value: str) -> None:
         self.matched_text = value
 
-    def get_row_to_print(self, result_for_32_earlier=True):
+    def get_row_to_print(self, result_for_32_earlier: bool = True) -> list:
         if result_for_32_earlier:
             print_rows = [self.category, self.license, self.matched_text, str(len(self.files)), ','.join(self.files)]
         else:
@@ -54,7 +54,7 @@ class MatchedLicense:
         return print_rows
 
 
-def get_license_list_to_print(license_list):
+def get_license_list_to_print(license_list: dict) -> list:
     result_for_32_earlier = any([value.category for key, value in license_list.items()])
     license_items = license_list.values()
     license_items = sorted(license_items, key=lambda row: (row.priority, row.category, row.license))

fosslight_source/_parsing_scancode_file_item.py

@@ -8,11 +8,12 @@ import logging
 import re
 import fosslight_util.constant as constant
 from ._license_matched import MatchedLicense
-from ._scan_item import ScanItem
+from ._scan_item import SourceItem
 from ._scan_item import is_exclude_dir
 from ._scan_item import is_exclude_file
 from ._scan_item import replace_word
 from ._scan_item import is_notice_file
+from typing import Tuple
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 _exclude_directory = ["test", "tests", "doc", "docs"]
@@ -30,7 +31,7 @@ KEY_AND = r"(?<=\s)and(?=\s)"
 KEY_OR = r"(?<=\s)or(?=\s)"
 
 
-def get_error_from_header(header_item):
+def get_error_from_header(header_item: list) -> Tuple[bool, str]:
     has_error = False
     str_error = ""
     key_error = "errors"
@@ -49,7 +50,7 @@ def get_error_from_header(header_item):
     return has_error, str_error
 
 
-def parsing_scancode_32_earlier(scancode_file_list, has_error=False):
+def parsing_scancode_32_earlier(scancode_file_list: list, has_error: bool = False) -> Tuple[bool, list, list, dict]:
     rc = True
     msg = []
     scancode_file_item = []
@@ -75,7 +76,7 @@ def parsing_scancode_32_earlier(scancode_file_list, has_error=False):
                     licenses = file.get("licenses", [])
                     copyright_list = file.get("copyrights", [])
 
-                    result_item = ScanItem(file_path)
+                    result_item = SourceItem(file_path)
 
                     if has_error and "scan_errors" in file:
                         error_msg = file.get("scan_errors", [])
@@ -178,7 +179,7 @@ def parsing_scancode_32_earlier(scancode_file_list, has_error=False):
     return rc, scancode_file_item, msg, license_list
 
 
-def split_spdx_expression(spdx_string):
+def split_spdx_expression(spdx_string: str) -> list:
     license = []
     for replace in SPDX_REPLACE_WORDS:
         spdx_string = spdx_string.replace(replace, "")
@@ -186,7 +187,9 @@ def split_spdx_expression(spdx_string):
     return license
 
 
-def parsing_scancode_32_later(scancode_file_list, has_error=False):
+def parsing_scancode_32_later(
+    scancode_file_list: list, has_error: bool = False
+) -> Tuple[bool, list, list, dict]:
     rc = True
     msg = []
     scancode_file_item = []
@@ -201,7 +204,7 @@ def parsing_scancode_32_later(scancode_file_list, has_error=False):
                 if (not file_path) or is_binary or is_dir:
                     continue
 
-                result_item = ScanItem(file_path)
+                result_item = SourceItem(file_path)
 
                 if has_error:
                     error_msg = file.get("scan_errors", [])
@@ -274,7 +277,9 @@ def parsing_scancode_32_later(scancode_file_list, has_error=False):
     return rc, scancode_file_item, msg, license_list
 
 
-def parsing_file_item(scancode_file_list, has_error, need_matched_license=False):
+def parsing_file_item(
+    scancode_file_list: list, has_error: bool, need_matched_license: bool = False
+) -> Tuple[bool, list, list, dict]:
 
     rc = True
     msg = []

fosslight_source/_parsing_scanoss_file.py

@@ -6,9 +6,10 @@
 import os
 import logging
 import fosslight_util.constant as constant
-from ._scan_item import ScanItem
+from ._scan_item import SourceItem
 from ._scan_item import is_exclude_file
 from ._scan_item import replace_word
+from typing import Tuple
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 SCANOSS_INFO_HEADER = ['No', 'Source Path', 'Component Declared', 'SPDX Tag',
@@ -16,26 +17,26 @@ SCANOSS_INFO_HEADER = ['No', 'Source Path', 'Component Declared', 'SPDX Tag',
                        'Matched Rate (line number)', 'scanoss_fileURL']
 
 
-def parsing_extraInfo(scanned_result):
+def parsing_extraInfo(scanned_result: dict) -> list:
     scanoss_extra_info = []
     for scan_item in scanned_result:
         license_w_source = scan_item.scanoss_reference
         if scan_item.matched_lines:
             if license_w_source:
-                extra_item = [scan_item.file, ','.join(license_w_source['component_declared']),
+                extra_item = [scan_item.source_name_or_path, ','.join(license_w_source['component_declared']),
                               ','.join(license_w_source['file_spdx_tag']),
                               ','.join(license_w_source['file_header']),
                               ','.join(license_w_source['license_file']),
                               ','.join(license_w_source['scancode']),
                               scan_item.matched_lines, scan_item.fileURL]
             else:
-                extra_item = [scan_item.file, '', '', '', '', '', scan_item.matched_lines, scan_item.fileURL]
+                extra_item = [scan_item.source_name_or_path, '', '', '', '', '', scan_item.matched_lines, scan_item.fileURL]
             scanoss_extra_info.append(extra_item)
     scanoss_extra_info.insert(0, SCANOSS_INFO_HEADER)
     return scanoss_extra_info
 
 
-def parsing_scanResult(scanoss_report, path_to_scan="", path_to_exclude=[]):
+def parsing_scanResult(scanoss_report: dict, path_to_scan: str = "", path_to_exclude: list = []) -> Tuple[bool, list]:
     scanoss_file_item = []
     abs_path_to_exclude = [os.path.abspath(os.path.join(path_to_scan, path)) for path in path_to_exclude]
 
@@ -43,7 +44,8 @@ def parsing_scanResult(scanoss_report, path_to_scan="", path_to_exclude=[]):
         abs_file_path = os.path.abspath(os.path.join(path_to_scan, file_path))
         if any(os.path.commonpath([abs_file_path, exclude_path]) == exclude_path for exclude_path in abs_path_to_exclude):
             continue
-        result_item = ScanItem(file_path)
+        result_item = SourceItem(file_path)
+
         if 'id' in findings[0]:
             if "none" == findings[0]['id']:
                 continue

fosslight_source/_scan_item.py

@@ -7,6 +7,7 @@ import os
 import logging
 import re
 import fosslight_util.constant as constant
+from fosslight_util.oss_item import FileItem, OssItem, get_checksum_sha1
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 replace_word = ["-only", "-old-style", "-or-later", "licenseref-scancode-", "licenseref-"]
@@ -25,49 +26,36 @@ MAX_LICENSE_TOTAL_LENGTH = 600
 SUBSTRING_LICENSE_COMMENT = "Maximum character limit (License)"
 
 
-class ScanItem:
-    file = ""
-    scanoss_reference = {}
-    exclude = False
-    is_license_text = False
-    oss_name = ""
-    oss_version = ""
-    download_location = []
-    matched_lines = ""  # Only for SCANOSS results
-    fileURL = ""  # Only for SCANOSS results
-    license_reference = ""
-
-    def __init__(self, value):
-        self.file = value
-        self._copyright = []
-        self._licenses = []
-        self.download_location = []
-        self.comment = ""
-        self.exclude = False
+class SourceItem(FileItem):
+
+    def __init__(self, value: str) -> None:
+        super().__init__("")
+        self.source_name_or_path = value
         self.is_license_text = False
+        self.license_reference = ""
+        self.scanoss_reference = {}
+        self.matched_lines = ""  # Only for SCANOSS results
+        self.fileURL = ""  # Only for SCANOSS results
+        self.download_location = []
+        self.copyright = []
+        self._licenses = []
+        self.oss_name = ""
+        self.oss_version = ""
+
+        self.checksum = get_checksum_sha1(value)
 
-    def __del__(self):
+    def __del__(self) -> None:
         pass
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.file)
 
     @property
-    def copyright(self):
-        return self._copyright
-
-    @copyright.setter
-    def copyright(self, value):
-        self._copyright.extend(value)
-        if len(self._copyright) > 0:
-            self._copyright = list(set(self._copyright))
-
-    @property
-    def licenses(self):
+    def licenses(self) -> list:
         return self._licenses
 
     @licenses.setter
-    def licenses(self, value):
+    def licenses(self, value: list) -> None:
         if value:
             max_length_exceed = False
             for new_lic in value:
@@ -84,30 +72,37 @@ class ScanItem:
             if max_length_exceed and (SUBSTRING_LICENSE_COMMENT not in self.comment):
                 self.comment = f"{self.comment}/ {SUBSTRING_LICENSE_COMMENT}" if self.comment else SUBSTRING_LICENSE_COMMENT
 
-    def get_file(self):
-        return self.file
+    def set_oss_item(self) -> None:
+        self.oss_items = []
+        if self.download_location:
+            for url in self.download_location:
+                item = OssItem(self.oss_name, self.oss_version, self.licenses, url)
+                item.copyright = "\n".join(self.copyright)
+                item.comment = self.comment
+                self.oss_items.append(item)
+        else:
+            item = OssItem(self.oss_name, self.oss_version, self.licenses)
+            item.copyright = "\n".join(self.copyright)
+            item.comment = self.comment
+            self.oss_items.append(item)
 
-    def get_row_to_print(self):
+    def get_print_array(self) -> list:
         print_rows = []
-        if not self.download_location:
-            print_rows.append([self.file, self.oss_name, self.oss_version, ",".join(self.licenses), "", "",
-                               "\n".join(self.copyright), "Exclude" if self.exclude else "", self.comment,
+        for item in self.oss_items:
+            print_rows.append([self.source_name_or_path, item.name, item.version, ",".join(item.license),
+                               item.download_location, "",
+                               item.copyright, "Exclude" if self.exclude else "", item.comment,
                                self.license_reference])
-        else:
-            for url in self.download_location:
-                print_rows.append([self.file, self.oss_name, self.oss_version, ",".join(self.licenses), url, "",
-                                   "\n".join(self.copyright), "Exclude" if self.exclude else "", self.comment,
-                                   self.license_reference])
         return print_rows
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if type(other) == str:
-            return self.file == other
+            return self.source_name_or_path == other
         else:
-            return self.file == other.file
+            return self.source_name_or_path == other.source_name_or_path
 
 
-def is_exclude_dir(dir_path):
+def is_exclude_dir(dir_path: str) -> bool:
     if dir_path != "":
         dir_path = dir_path.lower()
         dir_path = dir_path if dir_path.endswith(
@@ -118,7 +113,7 @@ def is_exclude_dir(dir_path):
     return False
 
 
-def is_exclude_file(file_path, prev_dir=None, prev_dir_exclude_value=None):
+def is_exclude_file(file_path: str, prev_dir: str = None, prev_dir_exclude_value: bool = None) -> bool:
     file_path = file_path.lower()
     filename = os.path.basename(file_path)
     if os.path.splitext(filename)[1] in _exclude_extension:
@@ -140,7 +135,7 @@ def is_exclude_file(file_path, prev_dir=None, prev_dir_exclude_value=None):
     return False
 
 
-def is_notice_file(file_path):
+def is_notice_file(file_path: str) -> bool:
     pattern = r"({})(?<!w)".format("|".join(_notice_filename))
     file_path = file_path.lower()
     filename = os.path.basename(file_path)

fosslight_source/cli.py

@@ -5,6 +5,7 @@
 
 import sys
 import os
+import platform
 import warnings
 import logging
 from datetime import datetime
@@ -13,7 +14,7 @@ from fosslight_util.set_log import init_log
 from fosslight_util.timer_thread import TimerThread
 from ._help import print_version, print_help_msg_source_scanner
 from ._license_matched import get_license_list_to_print
-from fosslight_util.output_format import check_output_formats, write_output_file
+from fosslight_util.output_format import check_output_formats_v2, write_output_file
 from fosslight_util.correct import correct_with_yaml
 from .run_scancode import run_scan
 from .run_scanoss import run_scanoss_py
@@ -21,8 +22,9 @@ from .run_scanoss import get_scanoss_extra_info
 import yaml
 import argparse
 from .run_spdx_extractor import get_spdx_downloads
-from ._scan_item import ScanItem
-from fosslight_util.cover import CoverItem
+from ._scan_item import SourceItem
+from fosslight_util.oss_item import ScannerItem
+from typing import Tuple
 
 SRC_SHEET_NAME = 'SRC_FL_Source'
 SCANOSS_HEADER = {SRC_SHEET_NAME: ['ID', 'Source Path', 'OSS Name',
@@ -35,11 +37,11 @@ SCANNER_TYPE = ['scancode', 'scanoss', 'all', '']
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 warnings.filterwarnings("ignore", category=FutureWarning)
-_PKG_NAME = "fosslight_source"
+PKG_NAME = "fosslight_source"
 RESULT_KEY = "Scan Result"
 
 
-def main():
+def main() -> None:
     global logger
     _result_log = {}
 
@@ -48,7 +50,7 @@ def main():
     write_json_file = False
     output_file_name = ""
     print_matched_text = False
-    formats = ""
+    formats = []
     selected_scanner = ""
     correct_mode = True
 
@@ -75,7 +77,7 @@ def main():
     if args.help:
         print_help_msg_source_scanner()
     if args.version:
-        print_version(_PKG_NAME)
+        print_version(PKG_NAME)
     if not args.path:
         path_to_scan = os.getcwd()
     else:
@@ -121,7 +123,7 @@ def main():
         sys.exit(1)
 
 
-def count_files(path_to_scan, path_to_exclude):
+def count_files(path_to_scan: str, path_to_exclude: list) -> Tuple[int, int]:
     total_files = 0
     excluded_files = 0
     abs_path_to_exclude = [os.path.abspath(os.path.join(path_to_scan, path)) for path in path_to_exclude]
@@ -138,9 +140,15 @@ def count_files(path_to_scan, path_to_exclude):
     return total_files, excluded_files
 
 
-def create_report_file(_start_time, merged_result, license_list, scanoss_result, selected_scanner, need_license=False,
-                       output_path="", output_files=[], output_extensions=[], correct_mode=True, correct_filepath="",
-                       path_to_scan="", path_to_exclude=[]):
+def create_report_file(
+    _start_time: str, merged_result: list,
+    license_list: list, scanoss_result: list,
+    selected_scanner: str, need_license: bool = False,
+    output_path: str = "", output_files: list = [],
+    output_extensions: list = [], correct_mode: bool = True,
+    correct_filepath: str = "", path_to_scan: str = "", path_to_exclude: list = [],
+    formats: list = []
+) -> 'ScannerItem':
     """
     Create report files for given scanned result.
 
@@ -162,33 +170,51 @@ def create_report_file(_start_time, merged_result, license_list, scanoss_result,
         # If -o does not contains file name, set default name
         while len(output_files) < len(output_extensions):
             output_files.append(None)
+        to_remove = []  # elements of spdx format on windows that should be removed
         for i, output_extension in enumerate(output_extensions):
             if output_files[i] is None or output_files[i] == "":
-                if output_extension == _json_ext:
-                    output_files[i] = f"fosslight_opossum_src_{_start_time}"
+                if formats:
+                    if formats[i].startswith('spdx'):
+                        if platform.system() != 'Windows':
+                            output_files[i] = f"fosslight_spdx_src_{_start_time}"
+                        else:
+                            logger.warning('spdx format is not supported on Windows. Please remove spdx from format.')
+                            to_remove.append(i)
+                    else:
+                        if output_extension == _json_ext:
+                            output_files[i] = f"fosslight_opossum_src_{_start_time}"
+                        else:
+                            output_files[i] = f"fosslight_report_src_{_start_time}"
                 else:
-                    output_files[i] = f"fosslight_report_src_{_start_time}"
+                    if output_extension == _json_ext:
+                        output_files[i] = f"fosslight_opossum_src_{_start_time}"
+                    else:
+                        output_files[i] = f"fosslight_report_src_{_start_time}"
+        for index in sorted(to_remove, reverse=True):
+            # remove elements of spdx format on windows
+            del output_files[index]
+            del output_extensions[index]
+            del formats[index]
+        if len(output_extensions) < 1:
+            sys.exit(0)
 
     if not correct_filepath:
         correct_filepath = path_to_scan
-    cover = CoverItem(tool_name=_PKG_NAME,
-                      start_time=_start_time,
-                      input_path=path_to_scan,
-                      exclude_path=path_to_exclude)
+
+    scan_item = ScannerItem(PKG_NAME, _start_time)
+    scan_item.set_cover_pathinfo(path_to_scan, path_to_exclude)
     files_count, removed_files_count = count_files(path_to_scan, path_to_exclude)
-    cover.comment = f"Total number of files / removed files: {files_count} / {removed_files_count}"
+    scan_item.set_cover_comment(f"Total number of files / removed files: {files_count} / {removed_files_count}")
 
-    if len(merged_result) == 0:
+    if not merged_result:
         if files_count < 1:
-            cover.comment += "(No file detected.)"
+            scan_item.set_cover_comment("(No file detected.)")
         else:
-            cover.comment += "(No OSS detected.)"
+            scan_item.set_cover_comment("(No OSS detected.)")
 
-    sheet_list[SRC_SHEET_NAME] = []
     if merged_result:
-        for scan_item in merged_result:
-            for row in scan_item.get_row_to_print():
-                sheet_list[SRC_SHEET_NAME].append(row)
+        sheet_list = {}
+        scan_item.append_file_items(merged_result, PKG_NAME)
 
         if selected_scanner == 'scanoss':
             extended_header = SCANOSS_HEADER
@@ -203,37 +229,40 @@ def create_report_file(_start_time, merged_result, license_list, scanoss_result,
             else:
                 sheet_list["scancode_reference"] = get_license_list_to_print(license_list)
                 sheet_list["scanoss_reference"] = get_scanoss_extra_info(scanoss_result)
+            if sheet_list:
+                scan_item.external_sheets = sheet_list
 
     if correct_mode:
-        success, msg_correct, correct_list = correct_with_yaml(correct_filepath, path_to_scan, sheet_list)
+        success, msg_correct, correct_item = correct_with_yaml(correct_filepath, path_to_scan, scan_item)
         if not success:
             logger.info(f"No correction with yaml: {msg_correct}")
         else:
-            sheet_list = correct_list
+            scan_item = correct_item
             logger.info("Success to correct with yaml.")
 
     combined_paths_and_files = [os.path.join(output_path, file) for file in output_files]
     results = []
-    for combined_path_and_file, output_extension in zip(combined_paths_and_files, output_extensions):
-        if need_license and output_extension == _json_ext and "scanoss_reference" in sheet_list:
-            del sheet_list["scanoss_reference"]
-        results.append(write_output_file(combined_path_and_file, output_extension, sheet_list, extended_header, "", cover))
+    for combined_path_and_file, output_extension, output_format in zip(combined_paths_and_files, output_extensions, formats):
+        # if need_license and output_extension == _json_ext and "scanoss_reference" in sheet_list:
+        #     del sheet_list["scanoss_reference"]
+        results.append(write_output_file(combined_path_and_file, output_extension, scan_item, extended_header, "", output_format))
     for success, msg, result_file in results:
         if success:
             logger.info(f"Output file: {result_file}")
-            if cover:
-                logger.info(f'{cover.comment}')
+            for row in scan_item.get_cover_comment():
+                logger.info(row)
         else:
             logger.error(f"Fail to generate result file {result_file}. msg:({msg})")
+    return scan_item
 
 
-def merge_results(scancode_result=[], scanoss_result=[], spdx_downloads={}):
+def merge_results(scancode_result: list = [], scanoss_result: list = [], spdx_downloads: dict = {}) -> list:
     """
     Merge scanner results and spdx parsing result.
-    :param scancode_result: list of scancode results in ScanItem.
-    :param scanoss_result: list of scanoss results in ScanItem.
+    :param scancode_result: list of scancode results in SourceItem.
+    :param scanoss_result: list of scanoss results in SourceItem.
     :param spdx_downloads: dictionary of spdx parsed results.
-    :return merged_result: list of merged result in ScanItem.
+    :return merged_result: list of merged result in SourceItem.
     """
 
     # If anything that is found at SCANOSS only exist, add it to result.
@@ -247,15 +276,24 @@ def merge_results(scancode_result=[], scanoss_result=[], spdx_downloads={}):
                 merged_result_item = scancode_result[scancode_result.index(file_name)]
                 merged_result_item.download_location = download_location
             else:
-                new_result_item = ScanItem(file_name)
+                new_result_item = SourceItem(file_name)
                 new_result_item.download_location = download_location
                 scancode_result.append(new_result_item)
+
+    for item in scancode_result:
+        item.set_oss_item()
+
     return scancode_result
 
 
-def run_scanners(path_to_scan, output_file_name="", write_json_file=False, num_cores=-1, called_by_cli=True,
-                 print_matched_text=False, formats=[], time_out=120, correct_mode=True, correct_filepath="",
-                 selected_scanner='all', path_to_exclude=[]):
+def run_scanners(
+    path_to_scan: str, output_file_name: str = "",
+    write_json_file: bool = False, num_cores: int = -1,
+    called_by_cli: bool = True, print_matched_text: bool = False,
+    formats: list = [], time_out: int = 120,
+    correct_mode: bool = True, correct_filepath: str = "",
+    selected_scanner: str = 'all', path_to_exclude: list = []
+) -> Tuple[bool, str, 'ScannerItem', list, list]:
     """
     Run Scancode and scanoss.py for the given path.
 
@@ -280,11 +318,12 @@ def run_scanners(path_to_scan, output_file_name="", write_json_file=False, num_c
     license_list = []
     spdx_downloads = {}
     result_log = {}
+    scan_item = []
 
-    success, msg, output_path, output_files, output_extensions = check_output_formats(output_file_name, formats)
+    success, msg, output_path, output_files, output_extensions, formats = check_output_formats_v2(output_file_name, formats)
 
     logger, result_log = init_log(os.path.join(output_path, f"fosslight_log_src_{start_time}.txt"),
-                                  True, logging.INFO, logging.DEBUG, _PKG_NAME, path_to_scan, path_to_exclude)
+                                  True, logging.INFO, logging.DEBUG, PKG_NAME, path_to_scan, path_to_exclude)
 
     if '.xlsx' not in output_extensions and print_matched_text:
         logger.warning("-m option is only available for excel.")
@@ -302,9 +341,9 @@ def run_scanners(path_to_scan, output_file_name="", write_json_file=False, num_c
         if selected_scanner in SCANNER_TYPE:
             spdx_downloads = get_spdx_downloads(path_to_scan, path_to_exclude)
             merged_result = merge_results(scancode_result, scanoss_result, spdx_downloads)
-            create_report_file(start_time, merged_result, license_list, scanoss_result, selected_scanner,
-                               print_matched_text, output_path, output_files, output_extensions, correct_mode,
-                               correct_filepath, path_to_scan, path_to_exclude)
+            scan_item = create_report_file(start_time, merged_result, license_list, scanoss_result, selected_scanner,
+                                           print_matched_text, output_path, output_files, output_extensions, correct_mode,
+                                           correct_filepath, path_to_scan, path_to_exclude, formats)
         else:
             print_help_msg_source_scanner()
             result_log[RESULT_KEY] = "Unsupported scanner"
@@ -312,7 +351,7 @@ def run_scanners(path_to_scan, output_file_name="", write_json_file=False, num_c
     else:
         result_log[RESULT_KEY] = f"Format error. {msg}"
         success = False
-    return success, result_log.get(RESULT_KEY, ""), merged_result, license_list, scanoss_result
+    return success, result_log.get(RESULT_KEY, ""), scan_item, license_list, scanoss_result
 
 
 if __name__ == '__main__':

fosslight_source/run_scancode.py

@@ -14,18 +14,23 @@ import fosslight_util.constant as constant
 from fosslight_util.set_log import init_log
 from ._parsing_scancode_file_item import parsing_file_item
 from ._parsing_scancode_file_item import get_error_from_header
-from ._license_matched import get_license_list_to_print
-from fosslight_util.output_format import check_output_formats
+from fosslight_util.output_format import check_output_formats_v2
 from fosslight_binary.binary_analysis import check_binary
+from typing import Tuple
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 warnings.filterwarnings("ignore", category=FutureWarning)
 _PKG_NAME = "fosslight_source"
 
 
-def run_scan(path_to_scan, output_file_name="",
-             _write_json_file=False, num_cores=-1, return_results=False, need_license=False, formats=[],
-             called_by_cli=False, time_out=120, correct_mode=True, correct_filepath="", path_to_exclude=[]):
+def run_scan(
+    path_to_scan: str, output_file_name: str = "",
+    _write_json_file: bool = False, num_cores: int = -1,
+    return_results: bool = False, need_license: bool = False,
+    formats: list = [], called_by_cli: bool = False,
+    time_out: int = 120, correct_mode: bool = True,
+    correct_filepath: str = "", path_to_exclude: list = []
+) -> Tuple[bool, str, list, list]:
     if not called_by_cli:
         global logger
 
@@ -41,7 +46,7 @@ def run_scan(path_to_scan, output_file_name="",
     if not correct_filepath:
         correct_filepath = path_to_scan
 
-    success, msg, output_path, output_files, output_extensions = check_output_formats(output_file_name, formats)
+    success, msg, output_path, output_files, output_extensions, formats = check_output_formats_v2(output_file_name, formats)
     if success:
         if output_path == "":  # if json output with _write_json_file not used, output_path won't be needed.
             output_path = os.getcwd()
@@ -100,13 +105,10 @@ def run_scan(path_to_scan, output_file_name="",
                                            output_json_pp=output_json_file, only_findings=True,
                                            license_text=True, url=True, timeout=time_out,
                                            include=(), ignore=tuple(total_files_to_excluded))
-
                 if not rc:
                     msg = "Source code analysis failed."
                     success = False
-
                 if results:
-                    sheet_list = {}
                     has_error = False
                     if "headers" in results:
                         has_error, error_msg = get_error_from_header(results["headers"])
@@ -125,13 +127,8 @@ def run_scan(path_to_scan, output_file_name="",
                                 result_list, key=lambda row: (''.join(row.licenses)))
 
                             for scan_item in result_list:
-                                if check_binary(os.path.join(path_to_scan, scan_item.file)):
+                                if check_binary(os.path.join(path_to_scan, scan_item.source_name_or_path)):
                                     scan_item.exclude = True
-
-                            sheet_list["SRC_FL_Source"] = [scan_item.get_row_to_print() for scan_item in result_list]
-                            if need_license:
-                                sheet_list["matched_text"] = get_license_list_to_print(license_list)
-
             except Exception as ex:
                 success = False
                 msg = str(ex)

fosslight_source/run_scanoss.py

@@ -11,7 +11,7 @@ import json
 from datetime import datetime
 import fosslight_util.constant as constant
 from fosslight_util.set_log import init_log
-from fosslight_util.output_format import check_output_formats  # , write_output_file
+from fosslight_util.output_format import check_output_formats_v2  # , write_output_file
 from ._parsing_scanoss_file import parsing_scanResult  # scanoss
 from ._parsing_scanoss_file import parsing_extraInfo  # scanoss
 import shutil
@@ -25,12 +25,12 @@ SCANOSS_RESULT_FILE = "scanner_output.wfp"
 SCANOSS_OUTPUT_FILE = "scanoss_raw_result.json"
 
 
-def get_scanoss_extra_info(scanned_result):
+def get_scanoss_extra_info(scanned_result: dict) -> list:
     return parsing_extraInfo(scanned_result)
 
 
-def run_scanoss_py(path_to_scan, output_file_name="", format="", called_by_cli=False,
-                   write_json_file=False, num_threads=-1, path_to_exclude=[]):
+def run_scanoss_py(path_to_scan: str, output_file_name: str = "", format: list = [], called_by_cli: bool = False,
+                   write_json_file: bool = False, num_threads: int = -1, path_to_exclude: list = []) -> list:
     """
     Run scanoss.py for the given path.
 
@@ -41,7 +41,7 @@ def run_scanoss_py(path_to_scan, output_file_name="", format="", called_by_cli=F
     :param write_json_file: if requested, keep the raw files.
     :return scanoss_file_list: list of ScanItem (scanned result by files).
     """
-    success, msg, output_path, output_files, output_extensions = check_output_formats(output_file_name, format)
+    success, msg, output_path, output_files, output_extensions, formats = check_output_formats_v2(output_file_name, format)
 
     if not called_by_cli:
         global logger

fosslight_source/run_spdx_extractor.py

@@ -12,7 +12,7 @@ import mmap
 logger = logging.getLogger(constant.LOGGER_NAME)
 
 
-def get_file_list(path_to_scan, path_to_exclude=[]):
+def get_file_list(path_to_scan: str, path_to_exclude: list = []) -> list:
     file_list = []
     abs_path_to_exclude = [os.path.abspath(os.path.join(path_to_scan, path)) for path in path_to_exclude]
     for root, dirs, files in os.walk(path_to_scan):
@@ -26,7 +26,7 @@ def get_file_list(path_to_scan, path_to_exclude=[]):
     return file_list
 
 
-def get_spdx_downloads(path_to_scan, path_to_exclude=[]):
+def get_spdx_downloads(path_to_scan: str, path_to_exclude: list = []) -> dict:
     download_dict = {}
     find_word = re.compile(rb"SPDX-PackageDownloadLocation\s*:\s*(\S+)", re.IGNORECASE)
 

{fosslight_source-1.7.16.dist-info → fosslight_source-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fosslight-source
-Version: 1.7.16
+Version: 2.1.0
 Summary: FOSSLight Source Scanner
 Home-page: https://github.com/fosslight/fosslight_source_scanner
 Author: LG Electronics
@@ -16,14 +16,14 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Requires-Dist: pyparsing
-Requires-Dist: scancode-toolkit==32.0.*,>=32.0.2
+Requires-Dist: scancode-toolkit>=32.2.0
 Requires-Dist: scanoss
 Requires-Dist: XlsxWriter
-Requires-Dist: fosslight-util~=1.4.47
+Requires-Dist: fosslight-util>=2.1.0
 Requires-Dist: PyYAML
 Requires-Dist: wheel>=0.38.1
 Requires-Dist: intbitset
-Requires-Dist: fosslight-binary
+Requires-Dist: fosslight-binary>=5.0.0
 Requires-Dist: typecode-libmagic; sys_platform != "darwin"
 
 <!--

fosslight_source-2.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+fosslight_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fosslight_source/_help.py,sha256=q3eKABhBrz8hvWSvmLVszStNpL18TCYLnUuefaU4V-M,2013
+fosslight_source/_license_matched.py,sha256=-3H881XQjFDafRttBsuboS3VbCPYEvPH1pwWXptknE4,2164
+fosslight_source/_parsing_scancode_file_item.py,sha256=4U8wTuuNm-2-hanTxiQr2FvHTBrf2ZwESyea_E8caHU,13466
+fosslight_source/_parsing_scanoss_file.py,sha256=Ss6BWTdT1Q43xTT9GBwL6XyzHT2p57ymVm04NL76Vbg,4506
+fosslight_source/_scan_item.py,sha256=2RdnH5ZvrD7yjGxaHAIgSLmhq0dyW1379RScqPYJtOI,5679
+fosslight_source/cli.py,sha256=ekeAOx6C3-MQxKU3415ZHx8R1Q_aRttnWp9d9b4TRxE,15522
+fosslight_source/run_scancode.py,sha256=GRX1eSppx8d7OHm2VOv3wJBPzI6m5dY6DU8bgg8HCO4,7083
+fosslight_source/run_scanoss.py,sha256=jTX_yfSc5-OhrVuejpoA97Y6n80dNE1L5dXTe0utNgM,5234
+fosslight_source/run_spdx_extractor.py,sha256=Hr9sTv06cJaVITy8amwexIW2FV8_rUcFw6hKmR9ZYws,1990
+fosslight_source-2.1.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fosslight_source-2.1.0.dist-info/METADATA,sha256=OABbodeXRrCuqx6Gnn-Wyo8HVQI4iz17NTNpSAOUR7g,3314
+fosslight_source-2.1.0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+fosslight_source-2.1.0.dist-info/entry_points.txt,sha256=NzFURHC4L8uf1PmnZ2uGQcZxR7UbYCgjetb_9aPHV-w,114
+fosslight_source-2.1.0.dist-info/top_level.txt,sha256=C2vw-0OIent84Vq-UEk1gt_kK1EL8dIItzBzp3WNyA4,17
+fosslight_source-2.1.0.dist-info/RECORD,,

fosslight_source-1.7.16.dist-info/RECORD

@@ -1,16 +0,0 @@
-fosslight_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fosslight_source/_help.py,sha256=XODSRDGc2LYZsxYT-VOLHrkLLVipGd6BGS6K4C39c7A,1992
-fosslight_source/_license_matched.py,sha256=XdD1VErNKk4_ys_kIMNxwftEDwa3ONlgSjf44ti6hmE,2046
-fosslight_source/_parsing_scancode_file_item.py,sha256=87WI1aJmixQWQMrYRN0A7Q-cPxLJqdMkvJiz6xu9Zoc,13237
-fosslight_source/_parsing_scanoss_file.py,sha256=RjiGv0g22KUeXWKwxnFoxIKcdUcrVXFRb_UCiN4OdhY,4390
-fosslight_source/_scan_item.py,sha256=rTpl6X4qL7pjVbkSG2LRsTsmhHEvpd30dpYc4ldyvbA,5427
-fosslight_source/cli.py,sha256=28xmXweT5OAiL3d9bKjePg2IKKqaJrIDQn2ehkgM3ms,13905
-fosslight_source/run_scancode.py,sha256=99vrFb9G9wlkRZwNipuTLZ7j-l5ucogSkgUVT8n0ucA,7267
-fosslight_source/run_scanoss.py,sha256=-Na96WLdU73_Mv6HIo2ex2U0cy4YDWMgbmG4eEnht3c,5146
-fosslight_source/run_spdx_extractor.py,sha256=nwPbb36cFcZsssdecp3lDHgtyM19nuFdiPxrVhtJ2bI,1948
-fosslight_source-1.7.16.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fosslight_source-1.7.16.dist-info/METADATA,sha256=dykrrD9GvQW_wfHHjNIAbc5oQwRuTbO3HfsbP2G6JCI,3318
-fosslight_source-1.7.16.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-fosslight_source-1.7.16.dist-info/entry_points.txt,sha256=NzFURHC4L8uf1PmnZ2uGQcZxR7UbYCgjetb_9aPHV-w,114
-fosslight_source-1.7.16.dist-info/top_level.txt,sha256=C2vw-0OIent84Vq-UEk1gt_kK1EL8dIItzBzp3WNyA4,17
-fosslight_source-1.7.16.dist-info/RECORD,,