fosslight-source 2.2.0__py3-none-any.whl → 2.2.2__py3-none-any.whl

fosslight_source/_parsing_scancode_file_item.py

@@ -7,15 +7,10 @@ import os
 import logging
 import re
 import fosslight_util.constant as constant
-from fosslight_util.get_pom_license import get_license_from_pom
 from ._license_matched import MatchedLicense
 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 ._scan_item import is_manifest_file
-from ._scan_item import is_package_dir
 from typing import Tuple
 
 logger = logging.getLogger(constant.LOGGER_NAME)
@@ -83,8 +78,6 @@ def parsing_scancode_32_earlier(scancode_file_list: list, has_error: bool = Fals
     msg = []
     scancode_file_item = []
     license_list = {}  # Key :[license]+[matched_text], value: MatchedLicense()
-    prev_dir = ""
-    prev_dir_value = False
 
     if scancode_file_list:
         for file in scancode_file_list:
@@ -96,22 +89,11 @@ def parsing_scancode_32_earlier(scancode_file_list: list, has_error: bool = Fals
                 is_binary = file.get("is_binary", False)
                 if "type" in file:
                     is_dir = file["type"] == "directory"
-                    if is_dir:
-                        prev_dir_value = is_exclude_dir(file_path)
-                        prev_dir = file_path
-
                 if not is_binary and not is_dir:
                     licenses = file.get("licenses", [])
                     copyright_list = file.get("copyrights", [])
 
                     result_item = SourceItem(file_path)
-                    is_pkg, pkg_path = is_package_dir(os.path.dirname(file_path))
-                    if is_pkg:
-                        result_item.source_name_or_path = pkg_path
-                        if not any(x.source_name_or_path == result_item.source_name_or_path for x in scancode_file_item):
-                            result_item.exclude = True
-                            scancode_file_item.append(result_item)
-                        continue
 
                     if has_error and "scan_errors" in file:
                         error_msg = file.get("scan_errors", [])
@@ -197,35 +179,6 @@ def parsing_scancode_32_earlier(scancode_file_list: list, has_error: bool = Fals
                     if len(license_detected) > 0:
                         result_item.licenses = license_detected
 
-                        detected_without_pom = []
-                        if is_manifest_file(file_path) and len(license_detected) > 0:
-                            result_item.is_manifest_file = True
-                            if file_path.endswith('.pom'):
-                                try:
-                                    pom_licenses = get_license_from_pom(pom_path=file_path, check_parent=False)
-                                    normalize_pom_licenses = []
-                                    if pom_licenses:
-                                        pom_license_list = pom_licenses.split(', ')
-                                        for pom_license in pom_license_list:
-                                            if pom_license not in license_detected:
-                                                for lic_matched_key, lic_info in license_list.items():
-                                                    if hasattr(lic_info, 'matched_text') and lic_info.matched_text:
-                                                        matched_txt = str(lic_info.matched_text).replace(',', '')
-                                                        if pom_license in matched_txt:
-                                                            normalize_pom_licenses.append(lic_info.license)
-                                                            break
-                                            else:
-                                                normalize_pom_licenses.append(pom_license)
-                                    detected_without_pom = list(set(license_detected) - set(normalize_pom_licenses))
-                                    if detected_without_pom:
-                                        result_item.comment = f"Detected: {', '.join(detected_without_pom)}"
-                                        result_item.licenses = []
-                                        result_item.licenses = normalize_pom_licenses
-                                        if not normalize_pom_licenses:
-                                            result_item.exclude = True
-                                except Exception as ex:
-                                    logger.info(f"Failed to extract license from POM {file_path}: {ex}")
-
                         # Remove copyright info for license text file of GPL family
                         if should_remove_copyright_for_gpl_license_text(license_detected, result_item.is_license_text):
                             logger.debug(f"Removing copyright for GPL family license text file: {file_path}")
@@ -233,13 +186,11 @@ def parsing_scancode_32_earlier(scancode_file_list: list, has_error: bool = Fals
                         else:
                             result_item.copyright = copyright_value_list
 
-                        if len(license_expression_list) > 0 and not detected_without_pom:
+                        if len(license_expression_list) > 0:
                             license_expression_list = list(
                                 set(license_expression_list))
                             result_item.comment = ','.join(license_expression_list)
 
-                        if is_exclude_file(file_path, prev_dir, prev_dir_value):
-                            result_item.exclude = True
                         scancode_file_item.append(result_item)
             except Exception as ex:
                 msg.append(f"Error Parsing item: {ex}")
@@ -271,17 +222,9 @@ def parsing_scancode_32_later(
                 is_binary = file.get("is_binary", False)
                 is_dir = file.get("type", "") == "directory"
                 if (not file_path) or is_binary or is_dir:
+                    logger.info(f"Skipping {file_path} because it is binary or directory")
                     continue
-
                 result_item = SourceItem(file_path)
-                is_pkg, pkg_path = is_package_dir(os.path.dirname(file_path))
-                if is_pkg:
-                    result_item.source_name_or_path = pkg_path
-                    if not any(x.source_name_or_path == result_item.source_name_or_path for x in scancode_file_item):
-                        result_item.exclude = True
-                        scancode_file_item.append(result_item)
-                    continue
-
                 if has_error:
                     error_msg = file.get("scan_errors", [])
                     if error_msg:
@@ -334,43 +277,12 @@ def parsing_scancode_32_later(
                                             license_list[lic_matched_key] = lic_info
                                     license_detected.append(found_lic)
                 result_item.licenses = license_detected
-
-                result_item.exclude = is_exclude_file(file_path)
                 file_ext = os.path.splitext(file_path)[1].lower()
                 is_source_file = file_ext and file_ext in SOURCE_EXTENSIONS
                 result_item.is_license_text = is_notice_file(file_path) or (
                     file.get("percentage_of_license_text", 0) > 90 and not is_source_file
                 )
 
-                detected_without_pom = []
-                if is_manifest_file(file_path) and len(license_detected) > 0:
-                    result_item.is_manifest_file = True
-                    if file_path.endswith('.pom'):
-                        try:
-                            pom_licenses = get_license_from_pom(pom_path=file_path, check_parent=False)
-                            normalize_pom_licenses = []
-                            if pom_licenses:
-                                pom_license_list = pom_licenses.split(', ')
-                                for pom_license in pom_license_list:
-                                    if pom_license not in license_detected:
-                                        for lic_matched_key, lic_info in license_list.items():
-                                            if hasattr(lic_info, 'matched_text') and lic_info.matched_text:
-                                                matched_txt = str(lic_info.matched_text).replace(',', '')
-                                                if pom_license in matched_txt:
-                                                    normalize_pom_licenses.append(lic_info.license)
-                                                    break
-                                    else:
-                                        normalize_pom_licenses.append(pom_license)
-                            detected_without_pom = list(set(license_detected) - set(normalize_pom_licenses))
-                            if detected_without_pom:
-                                result_item.comment = f"Detected: {', '.join(detected_without_pom)}"
-                                result_item.licenses = []
-                                result_item.licenses = normalize_pom_licenses
-                                if not normalize_pom_licenses:
-                                    result_item.exclude = True
-                        except Exception as ex:
-                            logger.info(f"Failed to extract license from POM {file_path}: {ex}")
-
                 # Remove copyright info for license text file of GPL family
                 if should_remove_copyright_for_gpl_license_text(license_detected, result_item.is_license_text):
                     logger.debug(f"Removing copyright for GPL family license text file: {file_path}")
@@ -378,7 +290,7 @@ def parsing_scancode_32_later(
                 else:
                     result_item.copyright = copyright_value_list
 
-                if len(license_detected) > 1 and not detected_without_pom:
+                if len(license_detected) > 1:
                     license_expression_spdx = file.get("detected_license_expression_spdx", "")
                     license_expression = file.get("detected_license_expression", "")
                     if license_expression_spdx:

fosslight_source/_parsing_scanoss_file.py

@@ -3,12 +3,9 @@
 # Copyright (c) 2020 LG Electronics Inc.
 # SPDX-License-Identifier: Apache-2.0
 
-import os
 import logging
 import fosslight_util.constant as constant
 from ._scan_item import SourceItem
-from ._scan_item import is_exclude_file
-from ._scan_item import is_package_dir
 from ._scan_item import replace_word
 from typing import Tuple
 
@@ -18,7 +15,7 @@ SCANOSS_INFO_HEADER = ['No', 'Source Path', 'Component Declared', 'SPDX Tag',
                        'Matched Rate (line number)', 'scanoss_fileURL']
 
 
-def parsing_extraInfo(scanned_result: dict) -> list:
+def parsing_extra_info(scanned_result: dict) -> list:
     scanoss_extra_info = []
     for scan_item in scanned_result:
         license_w_source = scan_item.scanoss_reference
@@ -37,22 +34,14 @@ def parsing_extraInfo(scanned_result: dict) -> list:
     return scanoss_extra_info
 
 
-def parsing_scanResult(scanoss_report: dict, path_to_scan: str = "", path_to_exclude: list = []) -> Tuple[bool, list]:
+def parsing_scan_result(scanoss_report: dict, excluded_files: set = None) -> 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]
 
     for file_path, findings in scanoss_report.items():
-        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):
+        file_path_normalized = file_path.replace('\\', '/')
+        if file_path_normalized in excluded_files:
             continue
         result_item = SourceItem(file_path)
-        is_pkg, pkg_path = is_package_dir(os.path.dirname(file_path))
-        if is_pkg:
-            result_item.source_name_or_path = pkg_path
-            if not any(x.source_name_or_path == result_item.source_name_or_path for x in scanoss_file_item):
-                result_item.exclude = True
-                scanoss_file_item.append(result_item)
-            continue
 
         if 'id' in findings[0]:
             if "none" == findings[0]['id']:
@@ -86,9 +75,6 @@ def parsing_scanResult(scanoss_report: dict, path_to_scan: str = "", path_to_exc
                 result_item.licenses = license_detected
                 result_item.scanoss_reference = license_w_source
 
-        if is_exclude_file(file_path):
-            result_item.exclude = True
-
         if 'file_url' in findings[0]:
             result_item.fileURL = findings[0]['file_url']
         if 'matched' in findings[0]:

fosslight_source/_scan_item.py

@@ -18,15 +18,7 @@ replace_word = ["-only", "-old-style", "-or-later", "licenseref-scancode-", "lic
 _notice_filename = ['licen[cs]e[s]?', 'notice[s]?', 'legal', 'copyright[s]?', 'copying*', 'patent[s]?', 'unlicen[cs]e', 'eula',
                     '[a,l]?gpl[-]?[1-3]?[.,-,_]?[0-1]?', 'mit', 'bsd[-]?[0-4]?', 'bsd[-]?[0-4][-]?clause[s]?',
                     'apache[-,_]?[1-2]?[.,-,_]?[0-2]?']
-_manifest_filename = [r'.*\.pom$', r'package\.json$', r'setup\.py$', r'pubspec\.yaml$', r'.*\.podspec$', r'Cargo\.toml$']
-_exclude_filename = ["changelog", "config.guess", "config.sub", "changes", "ltmain.sh",
-                     "configure", "configure.ac", "depcomp", "compile", "missing", "makefile"]
-_exclude_extension = [".m4", ".in", ".po"]
-_exclude_directory = ["test", "tests", "doc", "docs"]
-_exclude_directory = [os.path.sep + dir_name +
-                      os.path.sep for dir_name in _exclude_directory]
-_exclude_directory.append("/.")
-_package_directory = ["node_modules", "venv", "Pods", "Carthage"]
+_manifest_filename = [r'.*\.pom$', r'package\.json$', r'setup\.py$', r'setup\.cfg$', r'.*\.podspec$', r'Cargo\.toml$']
 MAX_LICENSE_LENGTH = 200
 MAX_LICENSE_TOTAL_LENGTH = 600
 SUBSTRING_LICENSE_COMMENT = "Maximum character limit (License)"
@@ -209,39 +201,6 @@ class SourceItem(FileItem):
             return self.source_name_or_path == other.source_name_or_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(
-            os.path.sep) else dir_path + os.path.sep
-        dir_path = dir_path if dir_path.startswith(
-            os.path.sep) else os.path.sep + dir_path
-        return any(dir_name in dir_path for dir_name in _exclude_directory)
-    return False
-
-
-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:
-        return True
-    if filename.startswith('.') or filename in _exclude_filename:
-        return True
-
-    dir_path = os.path.dirname(file_path)
-    if prev_dir is not None:  # running ScanCode
-        if dir_path == prev_dir:
-            return prev_dir_exclude_value
-        else:
-            # There will be no execution of this else statement.
-            # Because scancode json output results are sorted by path,
-            # most of them will match the previous if statement.
-            return is_exclude_dir(dir_path)
-    else:  # running SCANOSS
-        return is_exclude_dir(dir_path)
-    return False
-
-
 def is_notice_file(file_path: str) -> bool:
     pattern = r"({})(?<!w)".format("|".join(_notice_filename))
     filename = os.path.basename(file_path)
@@ -252,42 +211,3 @@ def is_manifest_file(file_path: str) -> bool:
     pattern = r"({})$".format("|".join(_manifest_filename))
     filename = os.path.basename(file_path)
     return bool(re.match(pattern, filename, re.IGNORECASE))
-
-
-def is_package_dir(dir_path: str) -> bool:
-    # scancode and scanoss use '/' as path separator regardless of OS
-    dir_path = dir_path.replace('\\', '/')
-    path_parts = dir_path.split('/')
-
-    for pkg_dir in _package_directory:
-        if pkg_dir in path_parts:
-            pkg_index = path_parts.index(pkg_dir)
-            pkg_path = '/'.join(path_parts[:pkg_index + 1])
-            return True, pkg_path
-    return False, ""
-
-
-def _has_parent_in_exclude_list(rel_path: str, path_to_exclude: list) -> bool:
-    path_parts = rel_path.replace('\\', '/').split('/')
-    for i in range(1, len(path_parts)):
-        parent_path = '/'.join(path_parts[:i])
-        if parent_path in path_to_exclude:
-            return True
-    return False
-
-
-def get_excluded_paths(path_to_scan: str, custom_excluded_paths: list = []) -> list:
-    path_to_exclude = custom_excluded_paths.copy()
-    abs_path_to_scan = os.path.abspath(path_to_scan)
-
-    for root, dirs, files in os.walk(path_to_scan):
-        for dir_name in dirs:
-            dir_path = os.path.join(root, dir_name)
-            rel_path = os.path.relpath(dir_path, abs_path_to_scan)
-            if not _has_parent_in_exclude_list(rel_path, path_to_exclude):
-                if dir_name in _package_directory:
-                    path_to_exclude.append(rel_path)
-                elif is_exclude_dir(rel_path):
-                    path_to_exclude.append(rel_path)
-
-    return path_to_exclude

fosslight_source/cli.py

@@ -14,21 +14,23 @@ from datetime import datetime
 import fosslight_util.constant as constant
 from fosslight_util.set_log import init_log
 from fosslight_util.timer_thread import TimerThread
-from fosslight_util.exclude import excluding_files
 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_v2, write_output_file
 from fosslight_util.correct import correct_with_yaml
 from .run_scancode import run_scan
-from ._scan_item import get_excluded_paths
+from fosslight_util.exclude import get_excluded_paths
 from .run_scanoss import run_scanoss_py
 from .run_scanoss import get_scanoss_extra_info
 import yaml
 import argparse
 from .run_spdx_extractor import get_spdx_downloads
+from .run_manifest_extractor import get_manifest_licenses
 from ._scan_item import SourceItem, KB_URL
 from fosslight_util.oss_item import ScannerItem
 from typing import Tuple
+from ._scan_item import is_manifest_file
+
 
 SRC_SHEET_NAME = 'SRC_FL_Source'
 SCANOSS_HEADER = {SRC_SHEET_NAME: ['ID', 'Source Path', 'OSS Name',
@@ -38,6 +40,9 @@ MERGED_HEADER = {SRC_SHEET_NAME: ['ID', 'Source Path', 'OSS Name',
                                   'OSS Version', 'License', 'Download Location',
                                   'Homepage', 'Copyright Text', 'Exclude', 'Comment', 'license_reference']}
 SCANNER_TYPE = ['kb', 'scancode', 'scanoss', 'all']
+EXCLUDE_FILENAME = ["changelog", "config.guess", "config.sub", "changes", "ltmain.sh",
+                    "configure", "configure.ac", "depcomp", "compile", "missing", "Makefile"]
+EXCLUDE_FILE_EXTENSION = [".m4", ".in", ".po"]
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 warnings.filterwarnings("ignore", category=FutureWarning)
@@ -126,23 +131,6 @@ def main() -> None:
         sys.exit(1)
 
 
-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]
-
-    for root, _, files in os.walk(path_to_scan):
-        for file in files:
-            file_path = os.path.join(root, file)
-            abs_file_path = os.path.abspath(file_path)
-            if any(os.path.commonpath([abs_file_path, exclude_path]) == exclude_path
-                   for exclude_path in abs_path_to_exclude):
-                excluded_files += 1
-            total_files += 1
-
-    return total_files, excluded_files
-
-
 def create_report_file(
     _start_time: str, merged_result: list,
     license_list: list, scanoss_result: list,
@@ -150,7 +138,7 @@ def create_report_file(
     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 = [], excluded_file_list: list = [], api_limit_exceed: bool = False
+    formats: list = [], api_limit_exceed: bool = False, files_count: int = 0
 ) -> 'ScannerItem':
     """
     Create report files for given scanned result.
@@ -209,7 +197,6 @@ def create_report_file(
 
     scan_item = ScannerItem(PKG_NAME, _start_time)
     scan_item.set_cover_pathinfo(path_to_scan, path_to_exclude)
-    files_count, _ = count_files(path_to_scan, path_to_exclude)
     scan_item.set_cover_comment(f"Scanned files: {files_count}")
 
     if api_limit_exceed:
@@ -223,12 +210,6 @@ def create_report_file(
 
     if merged_result:
         sheet_list = {}
-        # Remove results that are in excluding file list
-        for i in range(len(merged_result) - 1, -1, -1):  # Iterate from last to first
-            item_path = merged_result[i].source_name_or_path  # Assuming SourceItem has 'file_path' attribute
-            if item_path in excluded_file_list:
-                del merged_result[i]  # Delete matching item
-
         scan_item.append_file_items(merged_result, PKG_NAME)
 
         if selected_scanner == 'scanoss':
@@ -287,7 +268,7 @@ def check_kb_server_reachable() -> bool:
 
 def merge_results(
     scancode_result: list = [], scanoss_result: list = [], spdx_downloads: dict = {},
-    path_to_scan: str = "", run_kb: bool = False
+    path_to_scan: str = "", run_kb: bool = False, manifest_licenses: dict = {}
 ) -> list:
 
     """
@@ -313,6 +294,19 @@ def merge_results(
                 new_result_item = SourceItem(file_name)
                 new_result_item.download_location = download_location
                 scancode_result.append(new_result_item)
+    if manifest_licenses:
+        for file_name, licenses in manifest_licenses.items():
+            if file_name in scancode_result:
+                merged_result_item = scancode_result[scancode_result.index(file_name)]
+                # overwrite existing detected licenses with manifest-provided licenses
+                merged_result_item.licenses = []  # clear existing licenses (setter clears when value falsy)
+                merged_result_item.licenses = licenses
+                merged_result_item.is_manifest_file = True
+            else:
+                new_result_item = SourceItem(file_name)
+                new_result_item.licenses = licenses
+                new_result_item.is_manifest_file = True
+                scancode_result.append(new_result_item)
     if run_kb and not check_kb_server_reachable():
         run_kb = False
     if run_kb:
@@ -365,15 +359,17 @@ def run_scanners(
 
     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)
-    excluded_file_list = excluding_files(path_to_exclude, path_to_scan)
 
     if '.xlsx' not in output_extensions and print_matched_text:
         logger.warning("-m option is only available for excel.")
         print_matched_text = False
 
     if success:
-        excluded_path_with_default_exclusion = get_excluded_paths(path_to_scan, path_to_exclude)
+        path_to_exclude_with_filename = path_to_exclude + EXCLUDE_FILENAME
+        excluded_path_with_default_exclusion, excluded_path_without_dot, excluded_files, cnt_file_except_skipped = (
+            get_excluded_paths(path_to_scan, path_to_exclude_with_filename, EXCLUDE_FILE_EXTENSION))
         logger.debug(f"Skipped paths: {excluded_path_with_default_exclusion}")
+
         if not selected_scanner:
             selected_scanner = 'all'
         if selected_scanner in ['scancode', 'all', 'kb']:
@@ -381,18 +377,21 @@ def run_scanners(
                                                                                       write_json_file, num_cores, True,
                                                                                       print_matched_text, formats, called_by_cli,
                                                                                       time_out, correct_mode, correct_filepath,
-                                                                                      excluded_path_with_default_exclusion)
+                                                                                      excluded_path_with_default_exclusion,
+                                                                                      excluded_files)
+        excluded_files = set(excluded_files) if excluded_files else set()
         if selected_scanner in ['scanoss', 'all']:
             scanoss_result, api_limit_exceed = run_scanoss_py(path_to_scan, output_file_name, formats, True, write_json_file,
-                                                              num_cores, excluded_path_with_default_exclusion)
+                                                              num_cores, excluded_path_with_default_exclusion, excluded_files)
         if selected_scanner in SCANNER_TYPE:
             run_kb = True if selected_scanner in ['kb', 'all'] else False
-            spdx_downloads = get_spdx_downloads(path_to_scan, excluded_path_with_default_exclusion)
-            merged_result = merge_results(scancode_result, scanoss_result, spdx_downloads, path_to_scan, run_kb)
+            spdx_downloads, manifest_licenses = metadata_collector(path_to_scan, excluded_files)
+            merged_result = merge_results(scancode_result, scanoss_result, spdx_downloads,
+                                          path_to_scan, run_kb, manifest_licenses)
             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, excluded_file_list,
-                                           api_limit_exceed)
+                                           correct_filepath, path_to_scan, excluded_path_without_dot, formats,
+                                           api_limit_exceed, cnt_file_except_skipped)
         else:
             print_help_msg_source_scanner()
             result_log[RESULT_KEY] = "Unsupported scanner"
@@ -403,5 +402,38 @@ def run_scanners(
     return success, result_log.get(RESULT_KEY, ""), scan_item, license_list, scanoss_result
 
 
+def metadata_collector(path_to_scan: str, excluded_files: set) -> dict:
+    """
+    Collect metadata for merging.
+
+    - Traverse files with exclusions applied
+    - spdx_downloads: {rel_path: [download_urls]}
+    - manifest_licenses: {rel_path: [license_names]}
+
+    :return: (spdx_downloads, manifest_licenses)
+    """
+    abs_path_to_scan = os.path.abspath(path_to_scan)
+    spdx_downloads = {}
+    manifest_licenses = {}
+
+    for root, dirs, files in os.walk(path_to_scan):
+        for file in files:
+            file_path = os.path.join(root, file)
+            rel_path_file = os.path.relpath(file_path, abs_path_to_scan).replace('\\', '/')
+            if rel_path_file in excluded_files:
+                continue
+
+            downloads = get_spdx_downloads(file_path)
+            if downloads:
+                spdx_downloads[rel_path_file] = downloads
+
+            if is_manifest_file(file_path):
+                licenses = get_manifest_licenses(file_path)
+                if licenses:
+                    manifest_licenses[rel_path_file] = licenses
+
+    return spdx_downloads, manifest_licenses
+
+
 if __name__ == '__main__':
     main()

fosslight_source/run_manifest_extractor.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2025 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+import os
+import json
+import re
+import logging
+from fosslight_util.get_pom_license import get_license_from_pom
+import fosslight_util.constant as constant
+
+logger = logging.getLogger(constant.LOGGER_NAME)
+
+
+def _split_spdx_expression(value: str) -> list[str]:
+    parts = re.split(r'\s+(?:OR|AND)\s+|[|]{2}|&&', value, flags=re.IGNORECASE)
+    tokens: list[str] = []
+    for part in parts:
+        token = part.strip().strip('()')
+        if token:
+            tokens.append(token)
+    unique: list[str] = []
+    for t in tokens:
+        if t not in unique:
+            unique.append(t)
+    return unique
+
+
+def get_licenses_from_package_json(file_path: str) -> list[str]:
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except Exception as ex:
+        logger.info(f"Failed to read package.json {file_path}: {ex}")
+        return []
+
+    if not isinstance(data, dict):
+        return []
+
+    licenses: list[str] = []
+    license_field = data.get('license')
+
+    if isinstance(license_field, str):
+        value = license_field.strip()
+        if value.upper() == 'UNLICENSED':
+            return []
+        if value.upper().startswith('SEE LICENSE IN'):
+            return []
+        licenses.extend(_split_spdx_expression(value))
+    elif isinstance(license_field, dict):
+        type_val = license_field.get('type')
+        if isinstance(type_val, str):
+            type_val = type_val.strip()
+            if type_val and type_val.upper() != 'UNLICENSED':
+                licenses.append(type_val)
+
+    if not licenses:
+        legacy = data.get('licenses')
+        if isinstance(legacy, list):
+            for item in legacy:
+                if isinstance(item, str):
+                    token = item.strip()
+                    if token and token.upper() != 'UNLICENSED':
+                        licenses.append(token)
+                elif isinstance(item, dict):
+                    t = item.get('type')
+                    if isinstance(t, str):
+                        t = t.strip()
+                        if t and t.upper() != 'UNLICENSED':
+                            licenses.append(t)
+
+    unique: list[str] = []
+    for lic in licenses:
+        if lic not in unique:
+            unique.append(lic)
+    return unique
+
+
+def get_licenses_from_setup_cfg(file_path: str) -> list[str]:
+    try:
+        import configparser
+        parser = configparser.ConfigParser()
+        parser.read(file_path, encoding='utf-8')
+        if parser.has_section('metadata'):
+            license_value = parser.get('metadata', 'license', fallback='').strip()
+            if license_value:
+                return _split_spdx_expression(license_value)
+    except Exception as ex:
+        logger.info(f"Failed to parse setup.cfg with configparser for {file_path}: {ex}")
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        meta_match = re.search(r'^\s*\[metadata\]\s*(.*?)(?=^\s*\[|\Z)', content, flags=re.MULTILINE | re.DOTALL)
+        if not meta_match:
+            return []
+        block = meta_match.group(1)
+        m = re.search(r'^\s*license\s*=\s*(.+)$', block, flags=re.MULTILINE)
+        if not m:
+            return []
+        val = m.group(1).strip()
+        if (len(val) >= 2) and ((val[0] == val[-1]) and val[0] in ('"', "'")):
+            val = val[1:-1].strip()
+        if not val:
+            return []
+        return _split_spdx_expression(val)
+    except Exception as ex:
+        logger.info(f"Failed to parse setup.cfg {file_path} via regex fallback: {ex}")
+        return []
+
+
+def get_licenses_from_setup_py(file_path: str) -> list[str]:
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except Exception as ex:
+        logger.info(f"Failed to read setup.py {file_path}: {ex}")
+        return []
+
+    match = re.search(r'license\s*=\s*([\'"]{1,3})(.+?)\1', content, flags=re.IGNORECASE | re.DOTALL)
+    if not match:
+        return []
+    value = match.group(2).strip()
+    if not value:
+        return []
+
+    return _split_spdx_expression(value)
+
+
+def get_licenses_from_podspec(file_path: str) -> list[str]:
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except Exception as ex:
+        logger.info(f"Failed to read podspec {file_path}: {ex}")
+        return []
+
+    m = re.search(r'\blicense\s*=\s*([\'"])(.+?)\1', content, flags=re.IGNORECASE)
+    if m:
+        value = m.group(2).strip()
+        if value:
+            return _split_spdx_expression(value)
+
+    m = re.search(r'\blicense\s*=\s*\{[^}]*?:type\s*=>\s*([\'"])(.+?)\1', content, flags=re.IGNORECASE | re.DOTALL)
+    if m:
+        value = m.group(2).strip()
+        if value:
+            return _split_spdx_expression(value)
+
+    m = re.search(r'\blicense\s*=\s*\{[^}]*?:type\s*=>\s*:(\w+)', content, flags=re.IGNORECASE | re.DOTALL)
+    if m:
+        value = m.group(1).strip()
+        if value:
+            return _split_spdx_expression(value)
+
+    m = re.search(r'\blicense\s*=\s*:(\w+)', content, flags=re.DOTALL | re.IGNORECASE)
+    if m:
+        value = m.group(1).strip()
+        if value:
+            return _split_spdx_expression(value)
+
+    return []
+
+
+def get_licenses_from_cargo_toml(file_path: str) -> list[str]:
+    try:
+        data = None
+        try:
+            import tomllib as toml_loader  # Python 3.11+
+            with open(file_path, 'rb') as f:
+                data = toml_loader.load(f)
+        except Exception:
+            try:
+                import tomli as toml_loader  # Backport
+                with open(file_path, 'rb') as f:
+                    data = toml_loader.load(f)
+            except Exception:
+                data = None
+
+        if isinstance(data, dict):
+            package_tbl = data.get('package') or {}
+            license_value = package_tbl.get('license')
+            if isinstance(license_value, str) and license_value.strip():
+                return _split_spdx_expression(license_value.strip())
+            if package_tbl.get('license-file'):
+                return []
+    except Exception as ex:
+        logger.info(f"Failed to parse Cargo.toml via toml parser for {file_path}: {ex}")
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        pkg_match = re.search(r'^\s*\[package\]\s*(.*?)(?=^\s*\[|\Z)', content, flags=re.MULTILINE | re.DOTALL)
+        if not pkg_match:
+            return []
+        block = pkg_match.group(1)
+        m = re.search(r'^\s*license\s*=\s*(?P<q>"""|\'\'\'|"|\')(?P<val>.*?)(?P=q)', block, flags=re.MULTILINE | re.DOTALL)
+        if m:
+            val = m.group('val').strip()
+            if val:
+                return _split_spdx_expression(val)
+        m2 = re.search(r'^\s*license-file\s*=\s*(?:"""|\'\'\'|"|\')(.*?)(?:"""|\'\'\'|"|\')', block,
+                       flags=re.MULTILINE | re.DOTALL)
+        if m2:
+            return []
+    except Exception as ex:
+        logger.info(f"Failed to parse Cargo.toml {file_path}: {ex}")
+        return []
+    return []
+
+
+def get_manifest_licenses(file_path: str) -> list[str]:
+    if file_path.endswith('.pom'):
+        try:
+            pom_licenses = get_license_from_pom(group_id='', artifact_id='', version='', pom_path=file_path, check_parent=True)
+            if not pom_licenses:
+                return []
+            return [x.strip() for x in pom_licenses.split(', ') if x.strip()]
+        except Exception as ex:
+            logger.info(f"Failed to extract license from POM {file_path}: {ex}")
+            return []
+    elif os.path.basename(file_path).lower() == 'package.json':
+        try:
+            return get_licenses_from_package_json(file_path)
+        except Exception as ex:
+            logger.info(f"Failed to extract license from package.json {file_path}: {ex}")
+            return []
+    elif os.path.basename(file_path).lower() == 'setup.cfg':
+        try:
+            return get_licenses_from_setup_cfg(file_path)
+        except Exception as ex:
+            logger.info(f"Failed to extract license from setup.cfg {file_path}: {ex}")
+            return []
+    elif os.path.basename(file_path).lower() == 'setup.py':
+        try:
+            return get_licenses_from_setup_py(file_path)
+        except Exception as ex:
+            logger.info(f"Failed to extract license from setup.py {file_path}: {ex}")
+            return []
+    elif os.path.basename(file_path).lower().endswith('.podspec'):
+        try:
+            return get_licenses_from_podspec(file_path)
+        except Exception as ex:
+            logger.info(f"Failed to extract license from podspec {file_path}: {ex}")
+            return []
+    elif os.path.basename(file_path).lower() == 'cargo.toml':
+        try:
+            return get_licenses_from_cargo_toml(file_path)
+        except Exception as ex:
+            logger.info(f"Failed to extract license from Cargo.toml {file_path}: {ex}")
+            return []

fosslight_source/run_scancode.py

@@ -29,7 +29,8 @@ def run_scan(
     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 = []
+    correct_filepath: str = "", path_to_exclude: list = [],
+    excluded_files: list = []
 ) -> Tuple[bool, str, list, list]:
     if not called_by_cli:
         global logger
@@ -90,39 +91,40 @@ def run_scan(
                         exclude_path_normalized = os.path.normpath(exclude_path).replace("\\", "/")
 
                         if exclude_path_normalized.endswith("/**"):
-                            exclude_path_normalized = exclude_path_normalized[:-3]
-                        elif exclude_path_normalized.endswith("**"):
-                            exclude_path_normalized = exclude_path_normalized.rstrip("*")
-
-                        if exclude_path_normalized.startswith("**/"):
-                            exclude_path_normalized = exclude_path_normalized[3:]
-
-                        full_exclude_path = os.path.join(abs_path_to_scan, exclude_path)
-                        is_dir = os.path.isdir(full_exclude_path)
-                        is_file = os.path.isfile(full_exclude_path)
-                        if is_dir:
-                            dir_name = os.path.basename(exclude_path_normalized.rstrip("/"))
-                            base_path = exclude_path_normalized.rstrip("/")
-
-                            if dir_name:
-                                total_files_to_excluded.append(dir_name)
-                                max_depth = 0
-                                for root, dirs, files in os.walk(full_exclude_path):
-                                    depth = root[len(full_exclude_path):].count(os.sep)
-                                    max_depth = max(max_depth, depth)
-                                for depth in range(1, max_depth + 2):
-                                    pattern = base_path + "/*" * depth
-                                    total_files_to_excluded.append(pattern)
+                            base_dir = exclude_path_normalized[:-3].rstrip("/")
+                            if base_dir:
+                                full_exclude_path = os.path.join(abs_path_to_scan, base_dir)
+                                if os.path.isdir(full_exclude_path):
+                                    total_files_to_excluded.append(base_dir)
+                                    total_files_to_excluded.append(exclude_path_normalized)
+                                else:
+                                    total_files_to_excluded.append(exclude_path_normalized)
                             else:
                                 total_files_to_excluded.append(exclude_path_normalized)
-                        elif is_file:
-                            total_files_to_excluded.append(exclude_path_normalized)
                         else:
-                            if "/" in exclude_path_normalized:
-                                dir_name = os.path.basename(exclude_path_normalized.rstrip("/"))
-                                if dir_name:
-                                    total_files_to_excluded.append(dir_name)
-                            total_files_to_excluded.append(exclude_path_normalized)
+                            has_glob_chars = any(char in exclude_path_normalized for char in ['*', '?', '['])
+                            if not has_glob_chars:
+                                full_exclude_path = os.path.join(abs_path_to_scan, exclude_path_normalized)
+                                is_dir = os.path.isdir(full_exclude_path)
+                                is_file = os.path.isfile(full_exclude_path)
+                            else:
+                                is_dir = False
+                                is_file = False
+
+                            if is_dir:
+                                base_path = exclude_path_normalized.rstrip("/")
+                                if base_path:
+                                    total_files_to_excluded.append(base_path)
+                                    total_files_to_excluded.append(f"{base_path}/**")
+                                else:
+                                    total_files_to_excluded.append(exclude_path_normalized)
+                            elif is_file:
+                                total_files_to_excluded.append(f"**/{exclude_path_normalized}")
+                            else:
+                                total_files_to_excluded.append(exclude_path_normalized)
+
+                if excluded_files:
+                    total_files_to_excluded.extend(f"**/{file_path}" for file_path in excluded_files)
 
                 total_files_to_excluded = sorted(list(set(total_files_to_excluded)))
                 ignore_tuple = tuple(total_files_to_excluded)

fosslight_source/run_scanoss.py

@@ -12,8 +12,8 @@ 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_v2  # , write_output_file
-from ._parsing_scanoss_file import parsing_scanResult  # scanoss
-from ._parsing_scanoss_file import parsing_extraInfo  # scanoss
+from ._parsing_scanoss_file import parsing_scan_result  # scanoss
+from ._parsing_scanoss_file import parsing_extra_info  # scanoss
 import shutil
 from pathlib import Path
 from scanoss.scanner import Scanner, ScanType
@@ -28,11 +28,12 @@ SCANOSS_OUTPUT_FILE = "scanoss_raw_result.json"
 
 
 def get_scanoss_extra_info(scanned_result: dict) -> list:
-    return parsing_extraInfo(scanned_result)
+    return parsing_extra_info(scanned_result)
 
 
-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:
+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 = [], excluded_files: set = None) -> list:
     """
     Run scanoss.py for the given path.
 
@@ -72,7 +73,7 @@ def run_scanoss_py(path_to_scan: str, output_file_name: str = "", format: list =
     try:
         scanner = Scanner(
             ignore_cert_errors=True,
-            skip_folders=path_to_exclude,
+            skip_folders=list(path_to_exclude) if path_to_exclude else [],
             scan_output=output_json_file,
             scan_options=ScanType.SCAN_SNIPPETS.value,
             nb_threads=num_threads if num_threads > 0 else 10
@@ -86,30 +87,16 @@ def run_scanoss_py(path_to_scan: str, output_file_name: str = "", format: list =
         logger.debug(f"{captured_output}")
 
         if os.path.isfile(output_json_file):
-            total_files_to_excluded = []
-            if path_to_exclude:
-                for path in path_to_exclude:
-                    path = os.path.join(path_to_scan, os.path.relpath(path, os.path.abspath(path_to_scan))) \
-                           if not os.path.isabs(path_to_scan) and os.path.isabs(path) else os.path.join(path_to_scan, path)
-                    if os.path.isdir(path):
-                        for root, _, files in os.walk(path):
-                            root = root[len(path_to_scan) + 1:]
-                            total_files_to_excluded.extend([os.path.normpath(os.path.join(root, file)).replace('\\', '/')
-                                                            for file in files])
-                    elif os.path.isfile(path):
-                        path = path[len(path_to_scan) + 1:]
-                        total_files_to_excluded.append(os.path.normpath(path).replace('\\', '/'))
-
             with open(output_json_file, "r") as st_json:
                 st_python = json.load(st_json)
-                for key_to_exclude in total_files_to_excluded:
+                for key_to_exclude in excluded_files:
                     if key_to_exclude in st_python:
                         del st_python[key_to_exclude]
             with open(output_json_file, 'w') as st_json:
                 json.dump(st_python, st_json, indent=4)
             with open(output_json_file, "r") as st_json:
                 st_python = json.load(st_json)
-                scanoss_file_list = parsing_scanResult(st_python, path_to_scan, path_to_exclude)
+                scanoss_file_list = parsing_scan_result(st_python, excluded_files)
 
     except Exception as error:
         logger.debug(f"SCANOSS Parsing {path_to_scan}: {error}")

fosslight_source/run_spdx_extractor.py

@@ -12,39 +12,15 @@ import mmap
 logger = logging.getLogger(constant.LOGGER_NAME)
 
 
-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):
-        for file in files:
-            file_path = os.path.join(root, file)
-            abs_file_path = os.path.abspath(file_path)
-            if any(os.path.commonpath([abs_file_path, exclude_path]) == exclude_path
-                    for exclude_path in abs_path_to_exclude):
-                continue
-            file_list.append(file_path)
-    return file_list
-
-
-def get_spdx_downloads(path_to_scan: str, path_to_exclude: list = []) -> dict:
-    download_dict = {}
+def get_spdx_downloads(file_path: str) -> list[str]:
+    results = []
     find_word = re.compile(rb"SPDX-PackageDownloadLocation\s*:\s*(\S+)", re.IGNORECASE)
-
-    file_list = get_file_list(path_to_scan, path_to_exclude)
-
-    for file in file_list:
-        try:
-            rel_path_file = os.path.relpath(file, path_to_scan)
-            # remove the path_to_scan from the file paths
-            if os.path.getsize(file) > 0:
-                with open(file, "r") as f:
-                    with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mmap_obj:
-                        for word in find_word.findall(mmap_obj):
-                            if rel_path_file in download_dict:
-                                download_dict[rel_path_file].append(word.decode('utf-8'))
-                            else:
-                                download_dict[rel_path_file] = [word.decode('utf-8')]
-        except Exception as ex:
-            msg = str(ex)
-            logger.warning(f"Failed to extract SPDX download location. {rel_path_file}, {msg}")
-    return download_dict
+    try:
+        if os.path.getsize(file_path) > 0:
+            with open(file_path, "r") as f:
+                with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mmap_obj:
+                    for word in find_word.findall(mmap_obj):
+                        results.append(word.decode('utf-8'))
+    except Exception as ex:
+        logger.warning(f"Failed to extract SPDX download location. {file_path}, {ex}")
+    return results

{fosslight_source-2.2.0.dist-info → fosslight_source-2.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fosslight_source
-Version: 2.2.0
+Version: 2.2.2
 Summary: FOSSLight Source Scanner
 Home-page: https://github.com/fosslight/fosslight_source_scanner
 Download-URL: https://github.com/fosslight/fosslight_source_scanner
@@ -17,7 +17,7 @@ License-File: LICENSE
 Requires-Dist: pyparsing
 Requires-Dist: scanoss>=1.18.0
 Requires-Dist: XlsxWriter
-Requires-Dist: fosslight_util>=2.1.31
+Requires-Dist: fosslight_util>=2.1.34
 Requires-Dist: PyYAML
 Requires-Dist: wheel>=0.38.1
 Requires-Dist: intbitset

fosslight_source-2.2.2.dist-info/RECORD

@@ -0,0 +1,17 @@
+fosslight_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fosslight_source/_help.py,sha256=Ge6g9GKWGza11E74PFnBMqsj40UCUz-a_xArDZ1FClU,2316
+fosslight_source/_license_matched.py,sha256=-3H881XQjFDafRttBsuboS3VbCPYEvPH1pwWXptknE4,2164
+fosslight_source/_parsing_scancode_file_item.py,sha256=9TjCwTTPaytqTlZzCKzaX-n20xJLy346xwp0Ee-rWWA,14951
+fosslight_source/_parsing_scanoss_file.py,sha256=L3iHqmQF2jeSpHYuYSre44doXKy-BoX0u1Lm2IfJSU8,3866
+fosslight_source/_scan_item.py,sha256=rWoC-jMc6Hf_dpiwVdQjATNhkzRgLVn966q3UA1TAxc,9412
+fosslight_source/cli.py,sha256=Ohsl9h4-9zS72pPQCf22Ij7LrUinhpioC_2DNro3bXQ,19385
+fosslight_source/run_manifest_extractor.py,sha256=oaCdfXDp0bRqeEq0U3Yaf6fiZ-xjOOGsZBVbAeMN2zI,9105
+fosslight_source/run_scancode.py,sha256=TFyNLV6P9rSBo9royDoG6az4l7Tkpl8Gr66IFK1DBU8,9021
+fosslight_source/run_scanoss.py,sha256=_gdA4kOByI4saT4bDvMwIabpxtpH4f_yruHdBtb_g-o,4852
+fosslight_source/run_spdx_extractor.py,sha256=wIdjDIpzglc2tfrh_YodkAQ0QqfgfmJBSuE2bf4w4Tg,862
+fosslight_source-2.2.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fosslight_source-2.2.2.dist-info/METADATA,sha256=Jw2ERDhSs7sfNrQuV3bLT5vnC4fMDYGV-EFmTak_yfc,3557
+fosslight_source-2.2.2.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+fosslight_source-2.2.2.dist-info/entry_points.txt,sha256=G4bBRWqSrJ68g-2M-JtNDrSZsdym_M7_KohQ2qR1vG8,113
+fosslight_source-2.2.2.dist-info/top_level.txt,sha256=C2vw-0OIent84Vq-UEk1gt_kK1EL8dIItzBzp3WNyA4,17
+fosslight_source-2.2.2.dist-info/RECORD,,

fosslight_source-2.2.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-fosslight_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fosslight_source/_help.py,sha256=Ge6g9GKWGza11E74PFnBMqsj40UCUz-a_xArDZ1FClU,2316
-fosslight_source/_license_matched.py,sha256=-3H881XQjFDafRttBsuboS3VbCPYEvPH1pwWXptknE4,2164
-fosslight_source/_parsing_scancode_file_item.py,sha256=JjFm1rYzFnV7VOO0lyY32qfID9UlOwNCUfhxABgG6Ng,20692
-fosslight_source/_parsing_scanoss_file.py,sha256=0f5JzjnFU-kcPZRX7OKnextyvANjKwwNZeyCJVC7eME,4624
-fosslight_source/_scan_item.py,sha256=mPNdVdVagiPI4YlL0Nu656nU5yvWTdZTKR2SxXA8l1g,12612
-fosslight_source/cli.py,sha256=x3z8NuiU7hAX8rWHqeEyAtMn5Rtw6dGk5UjvGGfIjl8,17902
-fosslight_source/run_scancode.py,sha256=BcMzUEoHX4ukvj9Z2mZX-6HaY2yKk_AvQHeDzS6REPg,8934
-fosslight_source/run_scanoss.py,sha256=8wu3sa-YBqjfb5x2dbDJuAdw3rrExueOW23WdzqDCaU,5721
-fosslight_source/run_spdx_extractor.py,sha256=Hr9sTv06cJaVITy8amwexIW2FV8_rUcFw6hKmR9ZYws,1990
-fosslight_source-2.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fosslight_source-2.2.0.dist-info/METADATA,sha256=1vWU_HiBNhGVBpjym9Mz8jKf8opyCXZRPAHg1qzUy3E,3557
-fosslight_source-2.2.0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-fosslight_source-2.2.0.dist-info/entry_points.txt,sha256=G4bBRWqSrJ68g-2M-JtNDrSZsdym_M7_KohQ2qR1vG8,113
-fosslight_source-2.2.0.dist-info/top_level.txt,sha256=C2vw-0OIent84Vq-UEk1gt_kK1EL8dIItzBzp3WNyA4,17
-fosslight_source-2.2.0.dist-info/RECORD,,