fosslight-dependency 4.1.6__py3-none-any.whl → 4.1.8__py3-none-any.whl

fosslight_dependency/_package_manager.py

@@ -4,16 +4,17 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import os
-import sys
 import logging
 import platform
 import re
 import base64
 import subprocess
 import shutil
+import stat
+from packageurl.contrib import url2purl
+from askalono import identify
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
-from packageurl.contrib import url2purl
 
 try:
     from github import Github
@@ -22,13 +23,9 @@ except Exception:
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
-# binary url to check license text
-_license_scanner_linux = os.path.join('third_party', 'nomos', 'nomossa')
-_license_scanner_macos = os.path.join('third_party', 'askalono', 'askalono_macos')
-_license_scanner_windows = os.path.join('third_party', 'askalono', 'askalono.exe')
-
 gradle_config = ['runtimeClasspath', 'runtime']
 android_config = ['releaseRuntimeClasspath']
+ASKALONO_THRESHOLD = 0.7
 
 
 class PackageManager:
@@ -53,7 +50,6 @@ class PackageManager:
         self.dep_items = []
 
         self.platform = platform.system()
-        self.license_scanner_bin = check_license_scanner(self.platform)
 
     def __del__(self):
         self.input_package_list_file = []
@@ -112,10 +108,11 @@ class PackageManager:
                     cmd_gradle = "./gradlew"
             else:
                 ret_task = False
-                logger.warning('No gradlew file exists. (skip to find dependencies relationship.')
+                logger.warning('No gradlew file exists (Skip to find dependencies relationship.).')
                 if ret_plugin:
                     logger.warning('Also it cannot run android-dependency-scanning plugin.')
             if ret_task:
+                current_mode = change_file_mode(cmd_gradle)
                 if ret_alldeps:
                     cmd = f"{cmd_gradle} allDeps"
                     try:
@@ -124,11 +121,10 @@ class PackageManager:
                             self.parse_dependency_tree(ret)
                         else:
                             self.set_direct_dependencies(False)
-                            logger.warning("Failed to run allDeps task.")
+                            logger.warning(f"Fail to run {cmd}")
                     except Exception as e:
                         self.set_direct_dependencies(False)
-                        logger.error(f'Fail to run {cmd}: {e}')
-                        logger.warning('It cannot print the direct/transitive dependencies relationship.')
+                        logger.warning(f"Cannot print 'depends on' information. (fail {cmd}: {e})")
 
                 if ret_plugin:
                     cmd = f"{cmd_gradle} generateLicenseTxt"
@@ -145,6 +141,7 @@ class PackageManager:
                     except Exception as e:
                         logger.error(f'Fail to run {cmd}: {e}')
                         ret_task = False
+                change_file_mode(cmd_gradle, current_mode)
 
             if os.path.isfile(gradle_backup):
                 os.remove(const.SUPPORT_PACKAE.get(self.package_manager_name))
@@ -154,6 +151,9 @@ class PackageManager:
                 if os.path.isfile(module_gradle_backup):
                     os.remove(module_build_gradle)
                     shutil.move(module_gradle_backup, module_build_gradle)
+        if os.path.isfile(self.input_file_name):
+            logger.info(f'Found {self.input_file_name}, skip to run plugin.')
+            ret_task = True
         return ret_task
 
     def add_android_plugin_in_gradle(self, module_build_gradle):
@@ -313,9 +313,8 @@ def connect_github(github_token):
     return g
 
 
-def get_github_license(g, github_repo, platform, license_scanner_bin):
+def get_github_license(g, github_repo):
     license_name = ''
-    tmp_license_txt_file_name = 'tmp_license.txt'
 
     try:
         repository = g.get_repo(github_repo)
@@ -331,94 +330,39 @@ def get_github_license(g, github_repo, platform, license_scanner_bin):
             if license_name == "" or license_name == "NOASSERTION":
                 try:
                     license_txt_data = base64.b64decode(repository.get_license().content).decode('utf-8')
-                    tmp_license_txt = open(tmp_license_txt_file_name, 'w', encoding='utf-8')
-                    tmp_license_txt.write(license_txt_data)
-                    tmp_license_txt.close()
-                    license_name = check_and_run_license_scanner(platform, license_scanner_bin, tmp_license_txt_file_name)
+                    license_name = check_license_name(license_txt_data)
                 except Exception:
-                    logger.info("Cannot find the license name with license scanner binary.")
-
-                if os.path.isfile(tmp_license_txt_file_name):
-                    os.remove(tmp_license_txt_file_name)
+                    logger.info("Cannot find the license name with askalono.")
         except Exception:
             logger.info("Cannot find the license name with github api.")
 
     return license_name
 
 
-def check_license_scanner(platform):
-    license_scanner_bin = ''
-
-    if platform == const.LINUX:
-        license_scanner = _license_scanner_linux
-    elif platform == const.MACOS:
-        license_scanner = _license_scanner_macos
-    elif platform == const.WINDOWS:
-        license_scanner = _license_scanner_windows
+def check_license_name(license_txt, is_filepath=False):
+    license_name = ''
+    if is_filepath:
+        with open(license_txt, 'r', encoding='utf-8') as f:
+            license_content = f.read()
     else:
-        logger.debug("Not supported OS to analyze license text with binary.")
+        license_content = license_txt
 
-    if license_scanner:
-        try:
-            base_path = sys._MEIPASS
-        except Exception:
-            base_path = os.path.dirname(__file__)
-
-        data_path = os.path.join(base_path, license_scanner)
-        license_scanner_bin = data_path
-
-    return license_scanner_bin
-
-
-def check_and_run_license_scanner(platform, license_scanner_bin, file_dir):
-    license_name = ''
+    detect_askalono = identify(license_content)
+    if detect_askalono.score > ASKALONO_THRESHOLD:
+        license_name = detect_askalono.name
+    return license_name
 
-    if not license_scanner_bin:
-        logger.error('Not supported OS for license scanner binary.')
 
-    try:
-        tmp_output_file_name = "tmp_license_scanner_output.txt"
+def change_file_mode(filepath, mode=''):
+    current_mode = os.stat(filepath).st_mode
 
-        if file_dir == "UNKNOWN":
-            license_name = ""
+    if not os.path.exists(filepath):
+        logger.debug(f"The file{filepath} does not exist.")
+    else:
+        if not mode:
+            new_mode = current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
         else:
-            if platform == const.LINUX:
-                run_license_scanner = f"{license_scanner_bin} {file_dir} > {tmp_output_file_name}"
-            elif platform == const.MACOS:
-                run_license_scanner = f"{license_scanner_bin} identify {file_dir} > {tmp_output_file_name}"
-            elif platform == const.WINDOWS:
-                run_license_scanner = f"{license_scanner_bin} identify {file_dir} > {tmp_output_file_name}"
-            else:
-                run_license_scanner = ''
-
-            if run_license_scanner is None:
-                license_name = ""
-                return license_name
-            else:
-                ret = subprocess.run(run_license_scanner, shell=True, stderr=subprocess.PIPE)
-                if ret.returncode != 0 or ret.stderr:
-                    os.remove(tmp_output_file_name)
-                    return ""
-
-            fp = open(tmp_output_file_name, "r", encoding='utf8')
-            license_output = fp.read()
-            fp.close()
-
-            if platform == const.LINUX:
-                license_output_re = re.findall(r'.*contains license\(s\)\s(.*)', license_output)
-            else:
-                license_output_re = re.findall(r"License:\s{1}(\S*)\s{1}", license_output)
-
-            if len(license_output_re) == 1:
-                license_name = license_output_re[0]
-                if license_name == "No_license_found":
-                    license_name = ""
-            else:
-                license_name = ""
-            os.remove(tmp_output_file_name)
-
-    except Exception as ex:
-        logger.error(f"Failed to run license scan binary. {ex}")
-        license_name = ""
-
-    return license_name
+            new_mode = mode
+        os.chmod(filepath, new_mode)
+        logger.debug(f"File mode of {filepath} has been changed to {oct(new_mode)}.")
+    return current_mode

fosslight_dependency/package_manager/Carthage.py

@@ -9,8 +9,8 @@ import os
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager
-from fosslight_dependency._package_manager import connect_github, get_github_license, check_and_run_license_scanner
-from fosslight_dependency._package_manager import get_url_to_purl
+from fosslight_dependency._package_manager import connect_github, get_github_license
+from fosslight_dependency._package_manager import get_url_to_purl, check_license_name
 from fosslight_dependency.dependency_item import DependencyItem
 from fosslight_util.oss_item import OssItem
 
@@ -79,9 +79,7 @@ class Carthage(PackageManager):
                                 for license_file_reg in license_file_regs:
                                     match_result = re.match(license_file_reg, filename_in_dir.lower())
                                     if match_result is not None:
-                                        license_name = check_and_run_license_scanner(self.platform,
-                                                                                     self.license_scanner_bin,
-                                                                                     filename_with_checkout_path)
+                                        license_name = check_license_name(filename_with_checkout_path, True)
                                         find_license = True
                                         break
                     if license_name == '':
@@ -89,7 +87,7 @@ class Carthage(PackageManager):
                             try:
                                 if not g:
                                     g = connect_github(self.github_token)
-                                license_name = get_github_license(g, oss_path, self.platform, self.license_scanner_bin)
+                                license_name = get_github_license(g, oss_path)
                             except Exception as e:
                                 logger.warning(f"Failed to get license with github api: {e}")
                                 license_name == ''

fosslight_dependency/package_manager/Maven.py

@@ -13,7 +13,7 @@ import re
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager
-from fosslight_dependency._package_manager import version_refine, get_url_to_purl
+from fosslight_dependency._package_manager import version_refine, get_url_to_purl, change_file_mode
 from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
 from fosslight_util.oss_item import OssItem
 
@@ -142,7 +142,7 @@ class Maven(PackageManager):
         else:
             cmd_mvn = "mvn"
         cmd = f"{cmd_mvn} license:aggregate-download-licenses"
-
+        current_mode = change_file_mode(cmd_mvn)
         ret = subprocess.call(cmd, shell=True)
         if ret != 0:
             logger.error(f"Failed to run maven plugin: {cmd}")
@@ -159,6 +159,7 @@ class Maven(PackageManager):
         except Exception as e:
             logger.error(f"Failed to run '{cmd}': {e}")
             self.set_direct_dependencies(False)
+        change_file_mode(cmd_mvn, current_mode)
 
     def create_dep_stack(self, dep_line):
         dep_stack = []

fosslight_dependency/package_manager/Nuget.py

@@ -12,7 +12,7 @@ import requests
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager
-from fosslight_dependency._package_manager import check_and_run_license_scanner, get_url_to_purl
+from fosslight_dependency._package_manager import check_license_name, get_url_to_purl
 from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
 from fosslight_util.oss_item import OssItem
 
@@ -54,7 +54,8 @@ class Nuget(PackageManager):
                 oss_item.version = oss_version
 
                 license_name = ''
-                response = requests.get(f'{self.nuget_api_url}{oss_origin_name}/{oss_item.version}/{oss_origin_name}.nuspec')
+                response = requests.get(f'{self.nuget_api_url.lower()}{oss_origin_name.lower()}/ \
+                                        {oss_item.version.lower()}/{oss_origin_name.lower()}.nuspec')
                 if response.status_code == 200:
                     root = fromstring(response.text)
                     xmlns = ''
@@ -73,14 +74,9 @@ class Nuget(PackageManager):
                         if license_url is not None:
                             url_res = requests.get(license_url.text)
                             if url_res.status_code == 200:
-                                tmp_license_txt = open(tmp_license_txt_file_name, 'w', encoding='utf-8')
-                                tmp_license_txt.write(url_res.text)
-                                tmp_license_txt.close()
-                                license_name_with_license_scanner = check_and_run_license_scanner(self.platform,
-                                                                                                  self.license_scanner_bin,
-                                                                                                  tmp_license_txt_file_name)
-                                if license_name_with_license_scanner != "":
-                                    license_name = license_name_with_license_scanner
+                                license_name_with_scanner = check_license_name(url_res.text)
+                                if license_name_with_scanner != "":
+                                    license_name = license_name_with_scanner
                                 else:
                                     license_name = license_url.text
                     oss_item.license = license_name

fosslight_dependency/package_manager/Pub.py

@@ -10,11 +10,10 @@ import re
 import shutil
 import yaml
 import subprocess
-from askalono import identify
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager
-from fosslight_dependency._package_manager import get_url_to_purl
+from fosslight_dependency._package_manager import get_url_to_purl, check_license_name
 from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
 from fosslight_util.oss_item import OssItem
 
@@ -135,9 +134,7 @@ class Pub(PackageManager):
                 purl_dict[f'{oss_origin_name}({oss_item.version})'] = dep_item.purl
                 license_txt = json_data['license']
                 if license_txt is not None:
-                    detect_askalono = identify(license_txt)
-                    if detect_askalono.score > 0.7:
-                        oss_item.license = detect_askalono.name
+                    oss_item.license = check_license_name(license_txt)
 
                 if self.direct_dep:
                     if oss_origin_name not in self.total_dep_list:

fosslight_dependency/package_manager/Pypi.py

@@ -13,7 +13,7 @@ import re
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager
-from fosslight_dependency._package_manager import check_and_run_license_scanner, get_url_to_purl
+from fosslight_dependency._package_manager import check_license_name, get_url_to_purl
 from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
 from fosslight_util.oss_item import OssItem
 
@@ -111,7 +111,7 @@ class Pypi(PackageManager):
             install_cmd = cmd_separator.join(install_cmd_list)
         else:
             logger.error(const.SUPPORT_PACKAE[self.package_manager_name])
-            logger.error('Cannot create virtualenv becuase it cannot find: '
+            logger.error('Cannot create virtualenv because it cannot find: '
                          + ', '.join(const.SUPPORT_PACKAE[self.package_manager_name]))
             logger.error("Please run with '-a' and '-d' option.")
             return False
@@ -302,12 +302,7 @@ class Pypi(PackageManager):
                 if license_name is not None:
                     license_name = license_name.replace(';', ',')
                 else:
-                    license_file_dir = d['LicenseFile']
-                    license_name_with_lic_scanner = check_and_run_license_scanner(self.platform,
-                                                                                  self.license_scanner_bin,
-                                                                                  license_file_dir)
-                    if license_name_with_lic_scanner != "":
-                        license_name = license_name_with_lic_scanner
+                    license_name = check_license_name(d['LicenseFile'], True)
                 oss_item.license = license_name
 
                 if oss_init_name == self.package_name:

fosslight_dependency/package_manager/Swift.py

@@ -140,7 +140,7 @@ class Swift(PackageManager):
             github_repo = "/".join(oss_item.homepage.split('/')[-2:])
             dep_item.purl = get_url_to_purl(oss_item.download_location, self.package_manager_name, github_repo, oss_item.version)
             purl_dict[f'{oss_origin_name}({oss_item.version})'] = dep_item.purl
-            oss_item.license = get_github_license(g, github_repo, self.platform, self.license_scanner_bin)
+            oss_item.license = get_github_license(g, github_repo)
 
             if self.direct_dep and len(self.direct_dep_list) > 0:
                 if oss_origin_name in self.direct_dep_list:

fosslight_dependency/package_manager/Unity.py

@@ -7,16 +7,16 @@ import os
 import logging
 import re
 import yaml
+import requests
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager
-from fosslight_dependency._package_manager import check_and_run_license_scanner, get_url_to_purl
+from fosslight_dependency._package_manager import check_license_name, get_url_to_purl
 from fosslight_dependency.dependency_item import DependencyItem
 from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 proprietary_license = 'Proprietary License'
-unclassifed_license = 'UnclassifiedLicense'
 license_md = 'LICENSE.md'
 third_party_md = 'Third Party Notices.md'
 
@@ -49,10 +49,8 @@ class Unity(PackageManager):
                 oss_packagecache_dir = os.path.join(self.packageCache_dir, f'{oss_item.name}@{oss_item.version}')
                 license_f = os.path.join(oss_packagecache_dir, license_md)
                 if os.path.isfile(license_f):
-                    license_name = check_and_run_license_scanner(self.platform,
-                                                                 self.license_scanner_bin,
-                                                                 license_f)
-                    if license_name == unclassifed_license or license_name == '':
+                    license_name = check_license_name(license_f, True)
+                    if license_name == '':
                         with open(license_f, 'r', encoding='utf-8') as f:
                             for line in f:
                                 matched_l = re.search(r'Unity\s[\s\w]*\sLicense', line)
@@ -76,11 +74,14 @@ class Unity(PackageManager):
                 if oss_item.homepage and oss_item.homepage.startswith('git@'):
                     oss_item.homepage = oss_item.homepage.replace('git@', 'https://')
                 if oss_item.homepage is None or oss_item.homepage.startswith(self.unity_internal_url):
-                    if license_name != proprietary_license:
+                    if (license_name != proprietary_license) and license_name != '':
                         oss_item.homepage = f'{self.mirror_url}{oss_item.name}'
                 if oss_item.homepage is None:
                     oss_item.homepage = ''
-
+                else:
+                    if not check_url_alive(oss_item.homepage):
+                        minor_version = '.'.join(oss_item.version.split('.')[0:2])
+                        oss_item.homepage = f'https://docs.unity3d.com/Packages/{oss_item.name}@{minor_version}'
                 oss_item.download_location = oss_item.homepage
                 dep_item.purl = get_url_to_purl(oss_item.download_location, self.package_manager_name)
                 if dep_item.purl == 'None':
@@ -102,3 +103,16 @@ class Unity(PackageManager):
             logger.error(f"Fail to parse unity oss information: {e}")
 
         return
+
+
+def check_url_alive(url):
+    alive = False
+    try:
+        response = requests.get(url)
+        if response.status_code == 200:
+            alive = True
+        else:
+            logger.debug(f"{url} returned status code {response.status_code}")
+    except requests.exceptions.RequestException as e:
+        logger.debug(f"Check if url({url})is alive err: {e}")
+    return alive

fosslight_dependency/run_dependency_scanner.py

@@ -51,17 +51,17 @@ def paginate_file(file_path):
             input("Press Enter to see the next page...")
 
 
-def find_package_manager(input_dir, abs_path_to_exclude=[]):
+def find_package_manager(input_dir, abs_path_to_exclude=[], manifest_file_name=[]):
     ret = True
-    manifest_file_name = []
-    for value in const.SUPPORT_PACKAE.values():
-        if isinstance(value, list):
-            manifest_file_name.extend(value)
-        else:
-            manifest_file_name.append(value)
+    if not manifest_file_name:
+        for value in const.SUPPORT_PACKAE.values():
+            if isinstance(value, list):
+                manifest_file_name.extend(value)
+            else:
+                manifest_file_name.append(value)
 
     found_manifest_file = []
-    for (parent, _, files) in os.walk(input_dir):
+    for parent, dirs, files in os.walk(input_dir):
         if len(files) < 1:
             continue
         if os.path.basename(parent) in _exclude_dir:
@@ -76,6 +76,13 @@ def find_package_manager(input_dir, abs_path_to_exclude=[]):
                 continue
             if file in manifest_file_name:
                 found_manifest_file.append(file)
+        for dir in dirs:
+            for manifest_f in manifest_file_name:
+                manifest_l = manifest_f.split(os.path.sep)
+                if len(manifest_l) > 1:
+                    if manifest_l[0] == dir:
+                        if os.path.exists(os.path.join(parent, manifest_f)):
+                            found_manifest_file.append(manifest_f)
         if len(found_manifest_file) > 0:
             input_dir = parent
             break
@@ -99,7 +106,7 @@ def find_package_manager(input_dir, abs_path_to_exclude=[]):
         logger.warning(f"### Set Package Manager = {', '.join(found_package_manager.keys())}")
     else:
         ret = False
-        logger.info("It cannot find the manifest file.")
+        logger.info("Cannot find the manifest file.")
 
     return ret, found_package_manager, input_dir
 
@@ -168,17 +175,6 @@ def run_dependency_scanner(package_manager='', input_dir='', output_dir_file='',
         logger.error(msg)
         return False, scan_item
 
-    autodetect = True
-    if package_manager:
-        autodetect = False
-        support_packagemanager = list(const.SUPPORT_PACKAE.keys())
-
-        if package_manager not in support_packagemanager:
-            logger.error(f"(-m option) You entered the unsupported package manager({package_manager}).")
-            logger.error("Please enter the supported package manager({0}) with '-m' option."
-                         .format(", ".join(support_packagemanager)))
-            return False, scan_item
-
     if input_dir:
         if os.path.isdir(input_dir):
             os.chdir(input_dir)
@@ -192,20 +188,44 @@ def run_dependency_scanner(package_manager='', input_dir='', output_dir_file='',
         os.chdir(input_dir)
     scan_item.set_cover_pathinfo(input_dir, path_to_exclude)
 
+    autodetect = True
     found_package_manager = {}
-    if autodetect:
-        try:
-            ret, found_package_manager, input_dir = find_package_manager(input_dir, abs_path_to_exclude)
+    if package_manager:
+        autodetect = False
+        support_packagemanager = list(const.SUPPORT_PACKAE.keys())
+
+        if package_manager not in support_packagemanager:
+            logger.error(f"(-m option) You entered the unsupported package manager({package_manager}).")
+            logger.error("Please enter the supported package manager({0}) with '-m' option."
+                         .format(", ".join(support_packagemanager)))
+            return False, scan_item
+        manifest_file_name = []
+        value = const.SUPPORT_PACKAE[package_manager]
+        if isinstance(value, list):
+            manifest_file_name.extend(value)
+        else:
+            manifest_file_name.append(value)
+        scan_item.set_cover_comment(f"Manual detect mode (-m {package_manager})")
+    else:
+        manifest_file_name = []
+
+    try:
+        ret, found_package_manager, input_dir = find_package_manager(input_dir, abs_path_to_exclude, manifest_file_name)
+        if ret:
             os.chdir(input_dir)
-        except Exception as e:
+    except Exception as e:
+        if autodetect:
             logger.error(f'Fail to find package manager: {e}')
             ret = False
-        finally:
-            if not ret:
-                logger.warning("Dependency scanning terminated because the package manager was not found.")
+    finally:
+        if not ret:
+            if not autodetect:
+                logger.info('Try to analyze dependency without manifest file. (Manual mode)')
+                found_package_manager[package_manager] = []
+            else:
+                logger.error("Terminated: package manager could not be found.")
                 ret = False
-    else:
-        found_package_manager[package_manager] = ["manual detect ('-m option')"]
+                return False, scan_item
 
     pass_key = 'PASS'
     success_pm = []
@@ -242,7 +262,8 @@ def run_dependency_scanner(package_manager='', input_dir='', output_dir_file='',
                        'and https://fosslight.org/fosslight-guide-en/scanner/3_dependency.html#-prerequisite.'
             scan_item.set_cover_comment(f"Analysis failed Package manager: {', '.join(fail_pm)} ({info_msg})")
     else:
-        scan_item.set_cover_comment("No Package manager detected.")
+        if autodetect:
+            scan_item.set_cover_comment("No Package manager detected.")
 
     if ret and graph_path:
         graph_path = os.path.abspath(graph_path)

{fosslight_dependency-4.1.6.dist-info → fosslight_dependency-4.1.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fosslight-dependency
-Version: 4.1.6
+Version: 4.1.8
 Summary: FOSSLight Dependency Scanner
 Home-page: https://github.com/fosslight/fosslight_dependency_scanner
 Author: LG Electronics
@@ -9,10 +9,10 @@ Download-URL: https://github.com/fosslight/fosslight_dependency_scanner
 Platform: UNKNOWN
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Description-Content-Type: text/markdown
 Requires-Dist: openpyxl
 Requires-Dist: beautifulsoup4

{fosslight_dependency-4.1.6.dist-info → fosslight_dependency-4.1.8.dist-info}/RECORD

@@ -2,36 +2,33 @@ fosslight_dependency/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 fosslight_dependency/_analyze_dependency.py,sha256=uYbHDlFfEf-LsCWc6hTKN-QCD1T_2jaEgBf3z4M_4Lk,4226
 fosslight_dependency/_graph_convertor.py,sha256=D8GwmJfuj9Wg3_DeKRPLGGdyHSLcoU2Q0VzKQbkJG4g,2267
 fosslight_dependency/_help.py,sha256=INeP24fFfV2HPhZJMqk_KCu08X7nneAumBqMWQ7Sbw8,3336
-fosslight_dependency/_package_manager.py,sha256=TDYP0tlqr7A346BoC2EKEZSq7Eua2cWdJQ5YvMIc9Wc,17265
+fosslight_dependency/_package_manager.py,sha256=GUqMLidGGVrek0XpApron3SWFf66VsmfycsmnvxQOkY,14890
 fosslight_dependency/constant.py,sha256=FAkzrW1S6Ua_TAbvQ2y6d0dhEZcgonB11miKUj7lB98,1080
 fosslight_dependency/dependency_item.py,sha256=wNLWcsNycf3HQ5Pib2WrMeo2dn0eHCRg20NLcL95Qew,3345
-fosslight_dependency/run_dependency_scanner.py,sha256=HVee14Ol9QTjIKhDTVu0b3Shg43JQTQTV4NufbOhWHs,16471
+fosslight_dependency/run_dependency_scanner.py,sha256=zFlHAwj9fhsiaut_VhvQneX8Ngz82xgau4ThmHxk8pI,17399
 fosslight_dependency/LICENSES/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 fosslight_dependency/LICENSES/LicenseRef-3rd_party_licenses.txt,sha256=EcsFt7aE1rp3OXAdJgmXayfOZdpRdBMcmRnyoqWMCsw,95687
 fosslight_dependency/package_manager/Android.py,sha256=0UZFvbLxDIreerK4fR316YPyhUpPliV_kfZulrxkUyo,3218
 fosslight_dependency/package_manager/Cargo.py,sha256=I27IKtUFf2fOr9ZngB8T9x6pPYhpk1m5CxbwM1dw9rk,5898
-fosslight_dependency/package_manager/Carthage.py,sha256=qCHH6bhdowgPR5mS89AQLl_0Z5LRoyMZU4vAVHzPNCM,6390
+fosslight_dependency/package_manager/Carthage.py,sha256=VU506KafUiHBrr_62iOOXNI1fDOreOQgcC2EWM5PpQo,6122
 fosslight_dependency/package_manager/Cocoapods.py,sha256=k_URV1ekMOU8l_y9_KIp_luu96ZGOl1xLIkH737VREA,8524
 fosslight_dependency/package_manager/Go.py,sha256=O-6DTTRM2EoTpCVmlIPKFy8ZTz64EHTooOAoUimjeyk,6491
 fosslight_dependency/package_manager/Gradle.py,sha256=IYmj9q3XiE_DPKdtll6lyRr98lFuyKWW2qz57X26Fn0,4359
 fosslight_dependency/package_manager/Helm.py,sha256=ucx2Y0tWX37UHIzIGaRyTe7uQ2vlu2nUuO09hOMq9ZU,4223
-fosslight_dependency/package_manager/Maven.py,sha256=JXiP8LwQZ10tf1l0Qgd4fvmv1RcVn52_PiMx6sTpSKo,10329
+fosslight_dependency/package_manager/Maven.py,sha256=XDVTmxRjeQmATpJDP__yw47Pk5e4utXAkkEkskXPQCQ,10443
 fosslight_dependency/package_manager/Npm.py,sha256=hwKC08m05KlHgfQpPX7lnDEJC-A7WKF9OniYW4n9TDM,10638
-fosslight_dependency/package_manager/Nuget.py,sha256=FGD5tV1mTBl3G9mxWWnoMwLZUiSW7VCcHS7FxhCqU1g,9334
-fosslight_dependency/package_manager/Pub.py,sha256=ZsBSEyYkdIQCFCbc9OeAf5-hAw2oY_fA-KDvnVi9z_E,10299
-fosslight_dependency/package_manager/Pypi.py,sha256=7eBB5ko4HhRhby5txo9NXZl6td1O_8k11v8R9FwxygU,16254
-fosslight_dependency/package_manager/Swift.py,sha256=rAGecP705HJQGBQUj_4ssyty_lDF4YwTt7ymjso0-VQ,6793
-fosslight_dependency/package_manager/Unity.py,sha256=LoyWCMa6R3x0VCsTH1EEJ7FQmYsraCDnoHZUHCmYeiU,4708
+fosslight_dependency/package_manager/Nuget.py,sha256=x1SPdxwXS2Oyi1RnLasvJJL-IFJl45VI2CXt3wReW24,8884
+fosslight_dependency/package_manager/Pub.py,sha256=Rrz8_6wdrmMU6f3vbbuAwyMbODBauXNnBbI619OQgDk,10184
+fosslight_dependency/package_manager/Pypi.py,sha256=A3pXJC_7H7PTa6i3B_PvJY85qsc6W9AqOze7kB8E3Ws,15831
+fosslight_dependency/package_manager/Swift.py,sha256=8fdbdAXTNlp2NDoSqQXm48JGAg9UhxA91M1-NhHkT40,6752
+fosslight_dependency/package_manager/Unity.py,sha256=n1006GZ6Qrk8wAdO6wla1Q-JD7Evin7REVj-HDeTARc,5142
 fosslight_dependency/package_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fosslight_dependency/third_party/askalono/askalono.exe,sha256=NyngElHbrg3zLFRVwn6fPDZE_EDAEb1N8tiwWoCm4pQ,4743680
-fosslight_dependency/third_party/askalono/askalono_macos,sha256=cYSNXhAQpkdd8lkgnY5skNeDmU_8DIuP84eFi0OXKkE,5589868
-fosslight_dependency/third_party/nomos/nomossa,sha256=oFF9I-fhug6AVNyFnWeVXwDRin6NWSvk1g7mHBotB3Q,866408
-fosslight_dependency-4.1.6.dist-info/Apache-2.0.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fosslight_dependency-4.1.6.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fosslight_dependency-4.1.6.dist-info/LicenseRef-3rd_party_licenses.txt,sha256=EcsFt7aE1rp3OXAdJgmXayfOZdpRdBMcmRnyoqWMCsw,95687
-fosslight_dependency-4.1.6.dist-info/METADATA,sha256=gI4z5TG8NOQuKlFjhZRZAvgEUyi3FPNHJOz_Bb8Cjzw,4982
-fosslight_dependency-4.1.6.dist-info/MIT.txt,sha256=9cx4CbArgByWvkoEZNqpzbpJgA9TUe2D62rMocQpgfs,1082
-fosslight_dependency-4.1.6.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-fosslight_dependency-4.1.6.dist-info/entry_points.txt,sha256=e1QZbnCrQvfbwe9L6PxXnkRZMhl-PSo0QyUes0dGjU8,91
-fosslight_dependency-4.1.6.dist-info/top_level.txt,sha256=Jc0V7VcVCH0TEM8ksb8dwroTYz4AmRaQnlr3FB71Hcs,21
-fosslight_dependency-4.1.6.dist-info/RECORD,,
+fosslight_dependency-4.1.8.dist-info/Apache-2.0.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fosslight_dependency-4.1.8.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fosslight_dependency-4.1.8.dist-info/LicenseRef-3rd_party_licenses.txt,sha256=EcsFt7aE1rp3OXAdJgmXayfOZdpRdBMcmRnyoqWMCsw,95687
+fosslight_dependency-4.1.8.dist-info/METADATA,sha256=t5oEFJ8QBw9OduU3e6TB_IaeC4EcABk13D9D0mfO87Q,4984
+fosslight_dependency-4.1.8.dist-info/MIT.txt,sha256=9cx4CbArgByWvkoEZNqpzbpJgA9TUe2D62rMocQpgfs,1082
+fosslight_dependency-4.1.8.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+fosslight_dependency-4.1.8.dist-info/entry_points.txt,sha256=e1QZbnCrQvfbwe9L6PxXnkRZMhl-PSo0QyUes0dGjU8,91
+fosslight_dependency-4.1.8.dist-info/top_level.txt,sha256=Jc0V7VcVCH0TEM8ksb8dwroTYz4AmRaQnlr3FB71Hcs,21
+fosslight_dependency-4.1.8.dist-info/RECORD,,