fosslight-source 2.3.3__tar.gz → 2.3.5__tar.gz

{fosslight_source-2.3.3/src/fosslight_source.egg-info → fosslight_source-2.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fosslight_source
-Version: 2.3.3
+Version: 2.3.5
 Summary: FOSSLight Source Scanner
 Author: LG Electronics
 License-Expression: Apache-2.0
@@ -24,8 +24,8 @@ Requires-Dist: fosslight_util>=2.2.2
 Requires-Dist: PyYAML
 Requires-Dist: wheel>=0.38.1
 Requires-Dist: intbitset
-Requires-Dist: fosslight_binary>=5.1.22
 Requires-Dist: scancode-toolkit>=32.0.2
+Requires-Dist: lxml>=6.0.1
 Requires-Dist: cryptography<49; platform_system == "Darwin" and platform_machine == "x86_64"
 Requires-Dist: fingerprints==1.2.3
 Requires-Dist: normality==2.6.1

{fosslight_source-2.3.3 → fosslight_source-2.3.5}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fosslight_source"
-version = "2.3.3"
+version = "2.3.5"
 description = "FOSSLight Source Scanner"
 readme = "README.md"
 license = "Apache-2.0"
@@ -33,8 +33,8 @@ dependencies = [
     "PyYAML",
     "wheel>=0.38.1",
     "intbitset",
-    "fosslight_binary>=5.1.22",
     "scancode-toolkit>=32.0.2",
+    "lxml>=6.0.1",
     # cryptography 49.x does not provide macOS x86_64 wheels, causing source builds to require OpenSSL/pkg-config.
     "cryptography<49; platform_system == 'Darwin' and platform_machine == 'x86_64'",
     "fingerprints==1.2.3",
@@ -55,6 +55,9 @@ Download = "https://github.com/fosslight/fosslight_source_scanner"
 [project.scripts]
 fosslight_source = "fosslight_source.cli:main"
 
+[project.entry-points."scancode_pre_scan"]
+ignore-binaries = "fosslight_source._scancode_ignore_binaries:IgnoreBinaries"
+
 [tool.setuptools]
 package-dir = {"" = "src"}
 

{fosslight_source-2.3.3 → fosslight_source-2.3.5}/src/fosslight_source/_help.py

@@ -37,7 +37,7 @@ _HELP_MESSAGE_SOURCE_SCANNER = f"""
     ────────────────────────────────────────────────────────────────────
     -s <mode>              Choose mode: scancode, scanoss, kb, or all(default)
     -c <number>            Number of CPU cores/threads to use for scanning
-    -t <seconds>           Timeout in seconds for ScanCode scanning
+    -t <seconds>           Timeout in seconds for ScanCode and SCANOSS scanning
     -j                     Generate raw scanner results in JSON format
     --no_merge             Keep source paths file-based without folder merge
     --no_correction        Skip OSS information correction with sbom-info.yaml

{fosslight_source-2.3.3 → fosslight_source-2.3.5}/src/fosslight_source/_parsing_scancode_file_item.py

@@ -73,7 +73,9 @@ def get_error_from_header(header_item: list) -> Tuple[bool, str]:
     return has_error, str_error
 
 
-def parsing_scancode_32_earlier(scancode_file_list: list, has_error: bool = False) -> Tuple[bool, list, list, dict]:
+def parsing_scancode_32_earlier(
+    scancode_file_list: list, has_error: bool = False, ui_mode: bool = False
+) -> Tuple[bool, list, list, dict]:
     rc = True
     msg = []
     scancode_file_item = []
@@ -118,7 +120,10 @@ def parsing_scancode_32_earlier(scancode_file_list: list, has_error: bool = Fals
 
                     # Set the license value
                     license_detected = []
-                    if licenses is None or licenses == "":
+                    if not licenses:
+                        licenses = []
+                    # Keep license and/or copyright findings; UI keeps finding-less files too.
+                    if not licenses and not copyright_value_list and not ui_mode:
                         continue
 
                     license_expression_list = file.get("license_expressions", {})
@@ -191,6 +196,9 @@ def parsing_scancode_32_earlier(scancode_file_list: list, has_error: bool = Fals
                                 set(license_expression_list))
                             result_item.comment = ','.join(license_expression_list)
 
+                        scancode_file_item.append(result_item)
+                    elif copyright_value_list or ui_mode:
+                        result_item.copyright = copyright_value_list
                         scancode_file_item.append(result_item)
             except Exception as ex:
                 msg.append(f"Error Parsing item: {ex}")
@@ -223,7 +231,7 @@ def get_license_expression_spdx(license_expression: str) -> str:
 
 
 def parsing_scancode_32_later(
-    scancode_file_list: list, has_error: bool = False
+    scancode_file_list: list, has_error: bool = False, ui_mode: bool = False
 ) -> Tuple[bool, list, list, dict]:
     rc = True
     msg = []
@@ -258,9 +266,10 @@ def parsing_scancode_32_later(
                         copyright_value_list.append(copyright_data)
                 license_detected = []
                 licenses = file.get("license_detections", [])
-                if not licenses:
+                # Keep license and/or copyright findings; UI keeps finding-less files too.
+                if not licenses and not copyright_value_list and not ui_mode:
                     continue
-                for lic in licenses:
+                for lic in licenses or []:
                     matched_lic_list = lic.get("matches", [])
                     for matched_lic in matched_lic_list:
                         found_lic_list = matched_lic.get("license_expression", "")
@@ -322,7 +331,8 @@ def parsing_scancode_32_later(
 
 
 def parsing_file_item(
-    scancode_file_list: list, has_error: bool, need_matched_license: bool = False
+    scancode_file_list: list, has_error: bool, need_matched_license: bool = False,
+    ui_mode: bool = False
 ) -> Tuple[bool, list, list, dict]:
 
     rc = True
@@ -330,9 +340,13 @@ def parsing_file_item(
 
     first_item = next(iter(scancode_file_list or []), {})
     if "licenses" in first_item:
-        rc, scancode_file_item, msg, license_list = parsing_scancode_32_earlier(scancode_file_list, has_error)
+        rc, scancode_file_item, msg, license_list = parsing_scancode_32_earlier(
+            scancode_file_list, has_error, ui_mode
+        )
     else:
-        rc, scancode_file_item, msg, license_list = parsing_scancode_32_later(scancode_file_list, has_error)
+        rc, scancode_file_item, msg, license_list = parsing_scancode_32_later(
+            scancode_file_list, has_error, ui_mode
+        )
     if not need_matched_license:
         license_list = {}
     return rc, scancode_file_item, msg, license_list

fosslight_source-2.3.5/src/fosslight_source/_scancode_ignore_binaries.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2018 nexB Inc. and others.
+# Copyright (c) 2026 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Vendored from scancode-ignore-binaries (aboutcode-org/scancode-plugins)
+# so PyPI installs do not need a GitHub git dependency.
+# SPDX-PackageDownloadLocation: https://github.com/aboutcode-org/scancode-plugins/tree/main/misc/scancode-ignore-binaries
+
+from plugincode.pre_scan import PreScanPlugin
+from plugincode.pre_scan import pre_scan_impl
+from commoncode.cliutils import PluggableCommandLineOption
+from commoncode.cliutils import PRE_SCAN_GROUP
+from typecode.contenttype import get_type
+
+
+@pre_scan_impl
+class IgnoreBinaries(PreScanPlugin):
+    """
+    Ignore binary files.
+    """
+
+    options = [
+        PluggableCommandLineOption(
+            ('--ignore-binaries',),
+            is_flag=True,
+            help='Ignore binary files.',
+            sort_order=10,
+            help_group=PRE_SCAN_GROUP,
+        )
+    ]
+
+    def is_enabled(self, ignore_binaries, **kwargs):
+        return ignore_binaries
+
+    def process_codebase(self, codebase, ignore_binaries, **kwargs):
+        """
+        Remove binary Resources from the resource tree.
+        """
+        if not ignore_binaries:
+            return
+
+        resources_to_remove = []
+        for resource in codebase.walk():
+            if not resource.is_file:
+                continue
+            if is_binary(resource.location):
+                resources_to_remove.append(resource)
+
+        for resource in resources_to_remove:
+            resource.remove(codebase)
+
+
+def is_binary(location):
+    """
+    Return True if the resource at location is a binary file.
+    """
+    t = get_type(location)
+    return (
+        t.is_binary
+        or t.is_archive
+        or t.is_media
+        or t.is_office_doc
+        or t.is_compressed
+        or t.is_filesystem
+        or t.is_winexe
+        or t.is_elf
+        or t.is_java_class
+        or t.is_data
+    )

{fosslight_source-2.3.3 → fosslight_source-2.3.5}/src/fosslight_source/cli.py

@@ -90,6 +90,7 @@ def main() -> None:
     parser.add_argument('--kb_url', type=str, required=False, default="")
     parser.add_argument('--kb_token', type=str, required=False, default="")
     parser.add_argument('--no_merge', action='store_true', required=False)
+    parser.add_argument('--ui', action='store_true', required=False)
 
     args = parser.parse_args()
 
@@ -121,6 +122,7 @@ def main() -> None:
     kb_url = args.kb_url
     kb_token = args.kb_token
     merge_by_folder = not args.no_merge
+    ui_mode = args.ui
 
     time_out = args.timeout
     core = args.cores
@@ -130,7 +132,7 @@ def main() -> None:
                               print_matched_text, formats, time_out, correct_mode, correct_filepath,
                               selected_scanner, path_to_exclude, hide_progress=hide_progress,
                               kb_url=kb_url, kb_token=kb_token,
-                              merge_by_folder=merge_by_folder)
+                              merge_by_folder=merge_by_folder, ui_mode=ui_mode)
 
         _result_log["Scan Result"] = result[1]
         try:
@@ -149,7 +151,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 = [], api_limit_exceed: bool = False, files_count: int = 0, final_output_path: str = "",
+    formats: list = [], scanoss_skipped: bool = False, files_count: int = 0, final_output_path: str = "",
     run_kb_msg: str = "", merge_by_folder: bool = True
 ) -> 'ScannerItem':
     """
@@ -216,8 +218,12 @@ def create_report_file(
         else:
             scan_item.set_cover_comment("(No OSS detected.)")
 
-    if api_limit_exceed:
-        scan_item.set_cover_comment("SCANOSS skipped (API limits)")
+    if scanoss_skipped:
+        is_kb_success = run_kb_msg != "" and "Completed" in run_kb_msg
+        if is_kb_success:
+            scan_item.set_cover_comment("SCANOSS replaced with KB")
+        else:
+            scan_item.set_cover_comment("SCANOSS skipped")
 
     if run_kb_msg:
         scan_item.set_cover_comment(run_kb_msg)
@@ -390,11 +396,20 @@ def _collect_kb_file_hashes(
 def merge_results(
     scancode_result: list = [], scanoss_result: list = [], spdx_downloads: dict = {},
     path_to_scan: str = "", run_kb: bool = False, manifest_licenses: dict = {},
-    excluded_files: set = None, hide_progress: bool = False, kb_url: str = "", kb_token: str = ""
+    excluded_files: set = None, hide_progress: bool = False, kb_url: str = "", kb_token: str = "",
+    ui_mode: bool = False
 ) -> tuple[list, Optional[str], int, int]:
 
     """
     Merge scanner results and spdx parsing result.
+
+    ScanOSS items for files already present in scancode_result (same path) do not
+    replace the ScanCode license; only OSS name, version, and download location
+    from ScanOSS are applied. ScanOSS-only files are appended in full.
+
+    When ui_mode is False, items with both empty download location and empty
+    license are removed after merging.
+
     :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.
@@ -403,12 +418,27 @@ def merge_results(
     :param excluded_files: set of relative paths to exclude from KB-only file discovery.
     :param kb_url: KB API base URL.
     :param kb_token: KB API bearer token.
+    :param ui_mode: if False, drop items with no download location and no license.
     :return: (merged_result, kb failure message, requested file_hash count, returned match count).
     """
     if excluded_files is None:
         excluded_files = set()
 
-    scancode_result.extend([item for item in scanoss_result if item not in scancode_result])
+    # Merge ScanOSS into ScanCode results.
+    # When ScanCode already detected a license for the same file, keep that license
+    # and only load OSS name, version, and download location from ScanOSS.
+    # Files found only by ScanOSS are appended as-is (including ScanOSS licenses).
+    for scanoss_item in scanoss_result:
+        if scanoss_item in scancode_result:
+            scancode_item = scancode_result[scancode_result.index(scanoss_item)]
+            if scanoss_item.oss_name:
+                scancode_item.oss_name = scanoss_item.oss_name
+            if scanoss_item.oss_version:
+                scancode_item.oss_version = scanoss_item.oss_version
+            if scanoss_item.download_location:
+                scancode_item.download_location = scanoss_item.download_location
+        else:
+            scancode_result.append(scanoss_item)
 
     # If download loc. in SPDX form found, overwrite the scanner result.
     # If scanner result doesn't exist, create a new row.
@@ -424,19 +454,16 @@ def merge_results(
     if manifest_licenses:
         for file_name, licenses in manifest_licenses.items():
             valid_licenses = [lic.strip() for lic in licenses if isinstance(lic, str) and lic.strip()]
-            if not valid_licenses:
+            # Non-UI: skip manifests with no extracted licenses.
+            # UI: keep/create the row and mark is_manifest_file even without licenses.
+            if not valid_licenses and not ui_mode:
                 continue
-            if file_name in scancode_result:
-                merged_result_item = scancode_result[scancode_result.index(file_name)]
+            item = _get_or_append_source_item(scancode_result, file_name)
+            item.is_manifest_file = True
+            if valid_licenses:
                 # overwrite existing detected licenses with manifest-provided licenses
-                merged_result_item.licenses = []  # clear existing licenses (setter clears when value falsy)
-                merged_result_item.licenses = valid_licenses
-                merged_result_item.is_manifest_file = True
-            else:
-                new_result_item = SourceItem(file_name)
-                new_result_item.licenses = valid_licenses
-                new_result_item.is_manifest_file = True
-                scancode_result.append(new_result_item)
+                item.licenses = []  # clear existing licenses (setter clears when value falsy)
+                item.licenses = valid_licenses
 
     kb_origin_urls: dict[str, str] = {}
     kb_status_message: Optional[str] = None
@@ -465,9 +492,36 @@ def merge_results(
             if extra_item.download_location:
                 scancode_result.append(extra_item)
 
+    if not ui_mode:
+        scancode_result[:] = [
+            item for item in scancode_result
+            if not _has_empty_download_and_license(item)
+        ]
+
     return scancode_result, kb_status_message, kb_requested_count, kb_returned_count
 
 
+def _get_or_append_source_item(scancode_result: list, file_name: str) -> SourceItem:
+    if file_name in scancode_result:
+        return scancode_result[scancode_result.index(file_name)]
+    item = SourceItem(file_name)
+    scancode_result.append(item)
+    return item
+
+
+def _has_empty_download_and_license(item: SourceItem) -> bool:
+    downloads = item.download_location
+    if isinstance(downloads, str):
+        has_download = bool(downloads.strip())
+    else:
+        has_download = bool(downloads) and any(bool(d and str(d).strip()) for d in downloads)
+
+    licenses = item.licenses
+    has_license = bool(licenses) and any(bool(lic and str(lic).strip()) for lic in licenses)
+
+    return (not has_download) and (not has_license)
+
+
 def _finalize_temp_output(
     temp_output_path: str,
     final_output_path: str,
@@ -502,7 +556,8 @@ def run_scanners(
     correct_mode: bool = True, correct_filepath: str = "",
     selected_scanner: str = ALL_MODE, path_to_exclude: list = [],
     all_exclude_mode: tuple = (), hide_progress: bool = False,
-    kb_url: str = "", kb_token: str = "", merge_by_folder: bool = True
+    kb_url: str = "", kb_token: str = "", merge_by_folder: bool = True,
+    ui_mode: bool = False
 ) -> Tuple[bool, str, 'ScannerItem', list, list]:
     """
     Run Scancode and scanoss.py for the given path.
@@ -532,7 +587,7 @@ def run_scanners(
     spdx_downloads = {}
     result_log = {}
     scan_item = []
-    api_limit_exceed = False
+    scanoss_skipped = False
     kb_url, kb_token = resolve_kb_config(kb_url, kb_token)
 
     success, msg, output_path, output_files, output_extensions, formats = check_output_formats_v2(output_file_name, formats)
@@ -572,7 +627,7 @@ def run_scanners(
                  excluded_path_without_dot,
                  excluded_files,
                  cnt_file_except_skipped) = get_excluded_paths(path_to_scan, path_to_exclude_with_filename)
-                logger.debug(f"Skipped paths: {excluded_path_with_default_exclusion}")
+                logger.debug(f"Skipped paths count: {len(excluded_path_with_default_exclusion)}")
 
             if not selected_scanner:
                 selected_scanner = ALL_MODE
@@ -580,14 +635,17 @@ def run_scanners(
                 success, result_log[RESULT_KEY], scancode_result, license_list = run_scan(
                     path_to_scan, output_file_name, 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_files, hide_progress,
+                    correct_filepath, path_to_exclude,
+                    hide_progress=hide_progress,
+                    ui_mode=ui_mode,
                 )
             excluded_files = set(excluded_files) if excluded_files else set()
             if selected_scanner in ['scanoss', ALL_MODE]:
-                scanoss_result, api_limit_exceed = run_scanoss_py(path_to_scan, output_path, formats, True, num_cores,
-                                                                  excluded_path_with_default_exclusion, excluded_files,
-                                                                  write_json_file, hide_progress)
+                scanoss_result, scanoss_skipped = run_scanoss_py(
+                    path_to_scan, output_path, formats, True, num_cores,
+                    excluded_path_with_default_exclusion, excluded_files,
+                    write_json_file, hide_progress, timeout=time_out
+                )
 
             run_kb_msg = ""
             if selected_scanner in SCANNER_TYPE:
@@ -598,23 +656,21 @@ def run_scanners(
                         run_kb_msg = f"KB({kb_url}) Unreachable"
 
                 spdx_downloads, manifest_licenses = metadata_collector(path_to_scan, excluded_files)
-                merged_result, kb_status_message, kb_requested_count, kb_returned_count = merge_results(
+                merged_result, kb_status_message, kb_requested_count, _ = merge_results(
                     scancode_result, scanoss_result, spdx_downloads,
                     path_to_scan, run_kb, manifest_licenses, excluded_files,
                     hide_progress, kb_url, kb_token,
+                    ui_mode=ui_mode,
                 )
                 if kb_status_message:
                     run_kb_msg = f"KB({kb_url}) {kb_status_message}"
                 elif run_kb and kb_requested_count > 0:
-                    run_kb_msg = (
-                        f"KB({kb_url}) response : {kb_returned_count}/"
-                        f" requested: {kb_requested_count}"
-                    )
+                    run_kb_msg = f"KB({kb_url}) : Completed"
                 mark_oss_info_correction_files_as_excluded(merged_result)
                 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, excluded_path_without_dot, formats,
-                                               api_limit_exceed, cnt_file_except_skipped, final_output_path, run_kb_msg,
+                                               scanoss_skipped, cnt_file_except_skipped, final_output_path, run_kb_msg,
                                                merge_by_folder)
             else:
                 print_help_msg_source_scanner()
@@ -656,7 +712,7 @@ def metadata_collector(path_to_scan: str, excluded_files: set) -> dict:
 
     - Traverse files with exclusions applied
     - spdx_downloads: {rel_path: [download_urls]}
-    - manifest_licenses: {rel_path: [license_names]}
+    - manifest_licenses: {rel_path: [license_names]} (empty list if extraction failed)
 
     :return: (spdx_downloads, manifest_licenses)
     """
@@ -676,9 +732,7 @@ def metadata_collector(path_to_scan: str, excluded_files: set) -> dict:
                 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
+                manifest_licenses[rel_path_file] = get_manifest_licenses(file_path) or []
 
     return spdx_downloads, manifest_licenses
 

{fosslight_source-2.3.3 → fosslight_source-2.3.5}/src/fosslight_source/run_scancode.py

@@ -7,6 +7,8 @@ import os
 import multiprocessing
 import warnings
 import logging
+from typing import Tuple
+
 from scancode import cli
 import fosslight_util.constant as constant
 from fosslight_util.set_log import init_log
@@ -14,15 +16,12 @@ from fosslight_util.time import current_timestamp_utc, timestamp_for_filename
 from ._parsing_scancode_file_item import parsing_file_item
 from ._parsing_scancode_file_item import get_error_from_header
 from fosslight_util.output_format import check_output_formats_v2
-from fosslight_binary.binary_analysis import check_binary
 from fosslight_util.exclude import (
     EXCLUDE_DIRECTORY,
     EXCLUDE_FILE_EXTENSION,
     EXCLUDE_FILENAME,
     PACKAGE_DIRECTORY,
 )
-from commoncode.fileset import is_included
-from typing import Tuple, Iterable
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 warnings.filterwarnings("ignore", category=FutureWarning)
@@ -62,42 +61,53 @@ def _apply_scancode_unset_workaround(kwargs: dict) -> None:
         logger.debug("scancode UNSET workaround skipped: %s", ex)
 
 
-def _directory_ignore_pattern(dir_name: str) -> str:
-    """Path-based glob for a directory name (avoids matching the scan root itself)."""
-    normalized = dir_name.strip().strip("/").replace("\\", "/")
-    if not normalized:
-        return dir_name
-    return f"**/{normalized}/**"
-
-
-def _default_scancode_coarse_ignore_patterns() -> frozenset:
-    """
-    Coarse ignore patterns aligned with fosslight_util.get_excluded_paths() rules.
-    Directory names use path-based globs (e.g. **/tests/**) so they do not match
-    the scan root directory name itself.
-    """
-    patterns = {".*"}
-    for name in PACKAGE_DIRECTORY + EXCLUDE_DIRECTORY:
-        patterns.add(_directory_ignore_pattern(name))
-    for ext in EXCLUDE_FILE_EXTENSION:
-        patterns.add(f"*.{ext}")
-    for name in EXCLUDE_FILENAME:
-        patterns.add(name)
-    return frozenset(patterns)
+_WILDCARD_EXTENSIONS = {
+    "png", "mp3", "wav", "comp", "bin", "o", "db", "tflite",
+    "ttf", "exe", "dll", "jpg", "jpeg", "gif",
+    "zip", "tar", "tgz", "gz",
+    "bmp", "webp", "ico",
+} | {ext.lower() for ext in EXCLUDE_FILE_EXTENSION}
+
+
+def _normalize_custom_pattern(pattern: str, abs_path_to_scan: str) -> set:
+    pat = pattern.replace('\\', '/').strip()
+    if not pat:
+        return set()
+
+    patterns_to_add = {pat}
+
+    if pat.endswith("/**"):
+        base = pat[:-3].rstrip("/")
+        if base:
+            patterns_to_add.add(base)
+    elif pat.endswith("/*"):
+        base = pat[:-2].rstrip("/")
+        if base:
+            patterns_to_add.add(base)
+            patterns_to_add.add(f"{base}/**")
+    elif pat.endswith("/"):
+        base = pat.rstrip("/")
+        if base:
+            patterns_to_add.add(base)
+            patterns_to_add.add(f"{base}/**")
+            patterns_to_add.add(f"{base}/*")
+    else:
+        full_path = os.path.join(abs_path_to_scan, pat)
+        if os.path.isdir(full_path):
+            patterns_to_add.add(f"{pat}/**")
+            patterns_to_add.add(f"{pat}/*")
 
+    return patterns_to_add
 
-def _is_covered_by_coarse_ignore(rel_path: str, coarse_patterns: Iterable[str]) -> bool:
-    excludes = {pattern: "" for pattern in coarse_patterns}
-    return not is_included(rel_path, includes={}, excludes=excludes)
 
+def _expand_custom_exclude_pattern(pattern: str, abs_path_to_scan: str) -> set:
+    exclude_path_normalized = os.path.normpath(
+        pattern.replace('\\', '/').strip()
+    ).replace("\\", "/")
+    if not exclude_path_normalized:
+        return set()
 
-def _add_path_to_exclude_pattern(
-    patterns: set,
-    exclude_path: str,
-    abs_path_to_scan: str,
-    coarse_patterns: frozenset,
-) -> None:
-    exclude_path_normalized = os.path.normpath(exclude_path).replace("\\", "/")
+    patterns = set(_normalize_custom_pattern(exclude_path_normalized, abs_path_to_scan))
 
     if exclude_path_normalized.endswith("/**"):
         base_dir = exclude_path_normalized[:-3].rstrip("/")
@@ -105,17 +115,15 @@ def _add_path_to_exclude_pattern(
             full_exclude_path = os.path.join(abs_path_to_scan, base_dir)
             if os.path.isdir(full_exclude_path):
                 patterns.add(base_dir)
-                patterns.add(exclude_path_normalized)
-            else:
-                patterns.add(exclude_path_normalized)
+            patterns.add(exclude_path_normalized)
         else:
             patterns.add(exclude_path_normalized)
-        return
+        return patterns
 
     has_glob_chars = any(char in exclude_path_normalized for char in ['*', '?', '['])
     if has_glob_chars:
         patterns.add(exclude_path_normalized)
-        return
+        return patterns
 
     full_exclude_path = os.path.join(abs_path_to_scan, exclude_path_normalized)
     if os.path.isdir(full_exclude_path):
@@ -126,29 +134,51 @@ def _add_path_to_exclude_pattern(
         else:
             patterns.add(exclude_path_normalized)
     elif os.path.isfile(full_exclude_path):
-        if not _is_covered_by_coarse_ignore(exclude_path_normalized, coarse_patterns):
+        ext = os.path.splitext(exclude_path_normalized)[1].lstrip('.').lower()
+        if ext in _WILDCARD_EXTENSIONS:
+            patterns.add(f"*.{ext}")
+        else:
             patterns.add(f"**/{exclude_path_normalized}")
     else:
-        patterns.add(exclude_path_normalized)
+        ext = os.path.splitext(exclude_path_normalized)[1].lstrip('.').lower()
+        if ext in _WILDCARD_EXTENSIONS:
+            patterns.add(f"*.{ext}")
+        else:
+            patterns.add(exclude_path_normalized)
 
+    return patterns
 
-def _build_scancode_ignore_patterns(
-    path_to_exclude: list,
-    abs_path_to_scan: str,
-    binary_paths: list,
-) -> tuple:
-    coarse_patterns = _default_scancode_coarse_ignore_patterns()
-    patterns = set(coarse_patterns)
 
-    for path in path_to_exclude or []:
-        if os.path.isabs(path):
-            exclude_path = os.path.relpath(path, abs_path_to_scan)
-        else:
-            exclude_path = path
-        _add_path_to_exclude_pattern(patterns, exclude_path, abs_path_to_scan, coarse_patterns)
+def _directory_ignore_pattern(dir_name: str) -> str:
+    """Path-based glob for a directory name (avoids matching the scan root itself)."""
+    normalized = dir_name.strip().strip("/").replace("\\", "/")
+    if not normalized:
+        return dir_name
+    return f"**/{normalized}/**"
 
-    for rel_path in binary_paths:
-        patterns.add(f"**/{rel_path}")
+
+def _default_scancode_ignore_patterns(
+    path_to_exclude: list = None,
+    abs_path_to_scan: str = ""
+) -> tuple:
+    """
+    Coarse ignore patterns aligned with fosslight_util.get_excluded_paths() rules.
+    Directory names use path-based globs (e.g. **/tests/**) so they do not match
+    the scan root directory name itself.
+    Binary files are excluded separately via scancode --ignore-binaries.
+    """
+    patterns = {".*"}
+    for name in PACKAGE_DIRECTORY + EXCLUDE_DIRECTORY:
+        patterns.add(_directory_ignore_pattern(name))
+    for ext in EXCLUDE_FILE_EXTENSION:
+        patterns.add(f"*.{ext}")
+    for name in EXCLUDE_FILENAME:
+        patterns.add(name)
+
+    for pattern in path_to_exclude or []:
+        if os.path.isabs(pattern):
+            pattern = os.path.relpath(pattern, abs_path_to_scan)
+        patterns.update(_expand_custom_exclude_pattern(pattern, abs_path_to_scan))
 
     return tuple(sorted(patterns))
 
@@ -160,7 +190,8 @@ def run_scan(
     formats: list = [], called_by_cli: bool = False,
     time_out: int = 120, correct_mode: bool = True,
     correct_filepath: str = "", path_to_exclude: list = [],
-    excluded_files: list = [], hide_progress: bool = False
+    excluded_files: list = [], hide_progress: bool = False,
+    ui_mode: bool = False
 ) -> Tuple[bool, str, list, list]:
     if not called_by_cli:
         global logger
@@ -198,8 +229,13 @@ def run_scan(
             output_json_file = ""
 
         if not called_by_cli:
-            logger, _result_log = init_log(os.path.join(output_path, f"fosslight_log_src_{_file_time}.txt"),
-                                           True, logging.INFO, logging.DEBUG, _PKG_NAME, path_to_scan, path_to_exclude)
+            log_file_path = os.path.join(
+                output_path, f"fosslight_log_src_{_file_time}.txt"
+            )
+            logger, _result_log = init_log(
+                log_file_path, True, logging.INFO, logging.DEBUG,
+                _PKG_NAME, path_to_scan, path_to_exclude
+            )
 
             logger.info(f"Tool Info : {_result_log['Tool Info']}")
 
@@ -213,22 +249,8 @@ def run_scan(
                 pretty_params["path_to_exclude"] = path_to_exclude
                 pretty_params["output_file"] = output_file_name
                 abs_path_to_scan = os.path.abspath(path_to_scan)
-                binary_paths = []
-                for root, _, files in os.walk(path_to_scan):
-                    for name in files:
-                        full_path = os.path.join(root, name)
-                        try:
-                            if not check_binary(full_path, True):
-                                continue
-                        except Exception:
-                            continue
-                        rel_path = os.path.relpath(full_path, abs_path_to_scan)
-                        rel_norm = os.path.normpath(rel_path).replace("\\", "/")
-                        binary_paths.append(rel_norm)
-                        logger.debug(f"Excluded binary from scancode: {rel_norm}")
-
-                ignore_tuple = _build_scancode_ignore_patterns(
-                    path_to_exclude, abs_path_to_scan, binary_paths
+                ignore_tuple = _default_scancode_ignore_patterns(
+                    path_to_exclude, abs_path_to_scan
                 )
                 logger.debug(f"Scancode ignore patterns: {len(ignore_tuple)}")
 
@@ -241,12 +263,14 @@ def run_scan(
                     "processes": num_cores,
                     "pretty_params": pretty_params,
                     "output_json_pp": output_json_file,
-                    "only_findings": True,
+                    # Non-UI: only files with findings (license/copyright). UI: all files.
+                    "only_findings": not ui_mode,
                     "license_text": True,
                     "url": True,
                     "timeout": time_out,
                     "include": (),
                     "ignore": ignore_tuple,
+                    "ignore_binaries": True,
                     "quiet": hide_progress
                 }
                 _apply_scancode_unset_workaround(kwargs)
@@ -262,8 +286,9 @@ def run_scan(
                             _result_log["Error_files"] = error_msg
                             msg = "Failed to analyze :" + error_msg
                     if "files" in results:
-                        rc, result_list, parsing_msg, license_list = parsing_file_item(results["files"],
-                                                                                       has_error, need_license)
+                        rc, result_list, parsing_msg, license_list = parsing_file_item(
+                            results["files"], has_error, need_license, ui_mode=ui_mode
+                        )
                         if parsing_msg:
                             _result_log["Parsing Log"] = parsing_msg
                         if rc:
@@ -271,12 +296,6 @@ def run_scan(
                                 success = True
                             result_list = sorted(
                                 result_list, key=lambda row: (''.join(row.licenses)))
-
-                            for scan_item in result_list:
-                                if os.path.isdir(scan_item.source_name_or_path):
-                                    continue
-                                if check_binary(os.path.join(path_to_scan, scan_item.source_name_or_path), True):
-                                    scan_item.exclude = True
             except Exception as ex:
                 success = False
                 msg = str(ex)

{fosslight_source-2.3.3 → fosslight_source-2.3.5}/src/fosslight_source/run_scanoss.py

@@ -31,7 +31,8 @@ def get_scanoss_extra_info(scanned_result: dict) -> list:
 def run_scanoss_py(path_to_scan: str, output_path: str = "", format: list = [],
                    called_by_cli: bool = False, num_threads: int = -1,
                    path_to_exclude: list = [], excluded_files: set = None,
-                   write_json_file: bool = False, hide_progress: bool = False) -> Tuple[list, bool]:
+                   write_json_file: bool = False, hide_progress: bool = False,
+                   timeout: int = 120) -> Tuple[list, bool]:
     """
     Run scanoss.py for the given path.
 
@@ -40,17 +41,18 @@ def run_scanoss_py(path_to_scan: str, output_path: str = "", format: list = [],
     :param format: Output file format (not being used except when calling check_output_format).
     :param called_by_cli: if not called by cli, initialize logger.
     :param write_json_file: if requested, keep the raw files.
+    :param timeout: timeout in seconds for SCANOSS API request.
     :return scanoss_file_list: list of ScanItem (scanned result by files).
     """
 
     scanoss_file_list = []
-    api_limit_exceed = False
+    scanoss_skipped = False
     try:
         importlib_metadata.distribution("scanoss")
     except Exception as error:
         logger.warning(f"{error}. Skipping scan with scanoss.")
         logger.warning("Please install scanoss and dataclasses before run fosslight_source with scanoss option.")
-        return scanoss_file_list, api_limit_exceed
+        return scanoss_file_list, scanoss_skipped
 
     output_json_file = os.path.join(output_path, SCANOSS_OUTPUT_FILE)
     output_wfp_file = os.path.join(output_path, SCANOSS_RESULT_FILE)
@@ -66,13 +68,21 @@ def run_scanoss_py(path_to_scan: str, output_path: str = "", format: list = [],
             scan_output=output_json_file,
             scan_options=ScanType.SCAN_SNIPPETS.value,
             nb_threads=num_threads if num_threads > 0 else 10,
-            scanoss_settings=scanoss_settings
+            scanoss_settings=scanoss_settings,
+            timeout=timeout
         )
         output_buffer = io.StringIO()
         with contextlib.redirect_stdout(output_buffer), contextlib.redirect_stderr(output_buffer):
             scanner.scan_folder_with_options(scan_dir=path_to_scan)
         captured_output = output_buffer.getvalue()
         api_limit_exceed = "due to service limits being exceeded" in captured_output
+        timeout_occurred = "The SCANOSS API request timed out" in captured_output
+        if timeout_occurred or api_limit_exceed:
+            scanoss_skipped = True
+            if timeout_occurred:
+                logger.debug("SCANOSS skipped (Timeout)")
+            elif api_limit_exceed:
+                logger.debug("SCANOSS skipped (API Limit Exceeded)")
 
         if os.path.isfile(output_json_file):
             logger.debug("|---SCANOSS Parsing")
@@ -97,4 +107,4 @@ def run_scanoss_py(path_to_scan: str, output_path: str = "", format: list = [],
 
     logger.info(f"|---Number of files detected with SCANOSS: {(len(scanoss_file_list))}")
 
-    return scanoss_file_list, api_limit_exceed
+    return scanoss_file_list, scanoss_skipped

{fosslight_source-2.3.3 → fosslight_source-2.3.5/src/fosslight_source.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fosslight_source
-Version: 2.3.3
+Version: 2.3.5
 Summary: FOSSLight Source Scanner
 Author: LG Electronics
 License-Expression: Apache-2.0
@@ -24,8 +24,8 @@ Requires-Dist: fosslight_util>=2.2.2
 Requires-Dist: PyYAML
 Requires-Dist: wheel>=0.38.1
 Requires-Dist: intbitset
-Requires-Dist: fosslight_binary>=5.1.22
 Requires-Dist: scancode-toolkit>=32.0.2
+Requires-Dist: lxml>=6.0.1
 Requires-Dist: cryptography<49; platform_system == "Darwin" and platform_machine == "x86_64"
 Requires-Dist: fingerprints==1.2.3
 Requires-Dist: normality==2.6.1

{fosslight_source-2.3.3 → fosslight_source-2.3.5}/src/fosslight_source.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ src/fosslight_source/_merge.py
 src/fosslight_source/_parsing_scancode_file_item.py
 src/fosslight_source/_parsing_scanoss_file.py
 src/fosslight_source/_scan_item.py
+src/fosslight_source/_scancode_ignore_binaries.py
 src/fosslight_source/cli.py
 src/fosslight_source/run_manifest_extractor.py
 src/fosslight_source/run_scancode.py

fosslight_source-2.3.5/src/fosslight_source.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+fosslight_source = fosslight_source.cli:main
+
+[scancode_pre_scan]
+ignore-binaries = fosslight_source._scancode_ignore_binaries:IgnoreBinaries

{fosslight_source-2.3.3 → fosslight_source-2.3.5}/src/fosslight_source.egg-info/requires.txt

@@ -6,8 +6,8 @@ fosslight_util>=2.2.2
 PyYAML
 wheel>=0.38.1
 intbitset
-fosslight_binary>=5.1.22
 scancode-toolkit>=32.0.2
+lxml>=6.0.1
 fingerprints==1.2.3
 normality==2.6.1
 tqdm

fosslight_source-2.3.3/src/fosslight_source.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-fosslight_source = fosslight_source.cli:main