fosslight-source 2.0.0__tar.gz → 2.1.0__tar.gz

{fosslight_source-2.0.0 → fosslight_source-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fosslight_source
-Version: 2.0.0
+Version: 2.1.0
 Summary: FOSSLight Source Scanner
 Home-page: https://github.com/fosslight/fosslight_source_scanner
 Author: LG Electronics

{fosslight_source-2.0.0 → fosslight_source-2.1.0}/requirements.txt

@@ -1,8 +1,8 @@
 pyparsing
-scancode-toolkit>=32.0.2,==32.0.*
+scancode-toolkit>=32.2.0
 scanoss
 XlsxWriter
-fosslight_util>=2.0.0
+fosslight_util>=2.1.0
 PyYAML
 wheel>=0.38.1
 intbitset

{fosslight_source-2.0.0 → fosslight_source-2.1.0}/setup.py

@@ -14,7 +14,7 @@ with open('requirements.txt', 'r', 'utf-8') as f:
 if __name__ == "__main__":
     setup(
         name='fosslight_source',
-        version='2.0.0',
+        version='2.1.0',
         package_dir={"": "src"},
         packages=find_packages(where='src'),
         description='FOSSLight Source Scanner',

{fosslight_source-2.0.0 → fosslight_source-2.1.0}/src/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-2.0.0 → fosslight_source-2.1.0}/src/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-2.0.0 → fosslight_source-2.1.0}/src/fosslight_source/_parsing_scancode_file_item.py

@@ -13,6 +13,7 @@ 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 = []
@@ -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 = []
@@ -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-2.0.0 → fosslight_source-2.1.0}/src/fosslight_source/_parsing_scanoss_file.py

@@ -9,6 +9,7 @@ import fosslight_util.constant as constant
 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,7 +17,7 @@ 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
@@ -35,7 +36,7 @@ def parsing_extraInfo(scanned_result):
     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]
 
@@ -44,6 +45,7 @@ def parsing_scanResult(scanoss_report, path_to_scan="", path_to_exclude=[]):
         if any(os.path.commonpath([abs_file_path, exclude_path]) == exclude_path for exclude_path in abs_path_to_exclude):
             continue
         result_item = SourceItem(file_path)
+
         if 'id' in findings[0]:
             if "none" == findings[0]['id']:
                 continue

{fosslight_source-2.0.0 → fosslight_source-2.1.0}/src/fosslight_source/_scan_item.py

@@ -7,7 +7,7 @@ import os
 import logging
 import re
 import fosslight_util.constant as constant
-from fosslight_util.oss_item import FileItem, OssItem
+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-"]
@@ -28,7 +28,7 @@ SUBSTRING_LICENSE_COMMENT = "Maximum character limit (License)"
 
 class SourceItem(FileItem):
 
-    def __init__(self, value):
+    def __init__(self, value: str) -> None:
         super().__init__("")
         self.source_name_or_path = value
         self.is_license_text = False
@@ -42,18 +42,20 @@ class SourceItem(FileItem):
         self.oss_name = ""
         self.oss_version = ""
 
-    def __del__(self):
+        self.checksum = get_checksum_sha1(value)
+
+    def __del__(self) -> None:
         pass
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.file)
 
     @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:
@@ -70,7 +72,7 @@ class SourceItem(FileItem):
             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 set_oss_item(self):
+    def set_oss_item(self) -> None:
         self.oss_items = []
         if self.download_location:
             for url in self.download_location:
@@ -84,7 +86,7 @@ class SourceItem(FileItem):
             item.comment = self.comment
             self.oss_items.append(item)
 
-    def get_print_array(self):
+    def get_print_array(self) -> list:
         print_rows = []
         for item in self.oss_items:
             print_rows.append([self.source_name_or_path, item.name, item.version, ",".join(item.license),
@@ -93,14 +95,14 @@ class SourceItem(FileItem):
                                self.license_reference])
         return print_rows
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if type(other) == str:
             return self.source_name_or_path == other
         else:
             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(
@@ -111,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:
@@ -133,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-2.0.0 → fosslight_source-2.1.0}/src/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
@@ -23,6 +24,7 @@ import argparse
 from .run_spdx_extractor import get_spdx_downloads
 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',
@@ -39,7 +41,7 @@ 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
 
@@ -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,12 +170,33 @@ 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
@@ -213,10 +242,10 @@ def create_report_file(_start_time, merged_result, license_list, scanoss_result,
 
     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):
+    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, ""))
+        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}")
@@ -227,7 +256,7 @@ def create_report_file(_start_time, merged_result, license_list, scanoss_result,
     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 SourceItem.
@@ -257,9 +286,14 @@ def merge_results(scancode_result=[], scanoss_result=[], spdx_downloads={}):
     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.
 
@@ -284,8 +318,9 @@ 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)
@@ -308,7 +343,7 @@ def run_scanners(path_to_scan, output_file_name="", write_json_file=False, num_c
             merged_result = merge_results(scancode_result, scanoss_result, spdx_downloads)
             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)
+                                           correct_filepath, path_to_scan, path_to_exclude, formats)
         else:
             print_help_msg_source_scanner()
             result_log[RESULT_KEY] = "Unsupported scanner"

{fosslight_source-2.0.0 → fosslight_source-2.1.0}/src/fosslight_source/run_scancode.py

@@ -14,17 +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 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
 
@@ -40,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()

{fosslight_source-2.0.0 → fosslight_source-2.1.0}/src/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-2.0.0 → fosslight_source-2.1.0}/src/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-2.0.0 → fosslight_source-2.1.0}/src/fosslight_source.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fosslight-source
-Version: 2.0.0
+Version: 2.1.0
 Summary: FOSSLight Source Scanner
 Home-page: https://github.com/fosslight/fosslight_source_scanner
 Author: LG Electronics

{fosslight_source-2.0.0 → fosslight_source-2.1.0}/src/fosslight_source.egg-info/requires.txt

@@ -1,8 +1,8 @@
 pyparsing
-scancode-toolkit==32.0.*,>=32.0.2
+scancode-toolkit>=32.2.0
 scanoss
 XlsxWriter
-fosslight_util>=2.0.0
+fosslight_util>=2.1.0
 PyYAML
 wheel>=0.38.1
 intbitset