fosslight-dependency 4.1.20__py3-none-any.whl → 4.1.22__py3-none-any.whl

fosslight_dependency/_analyze_dependency.py

@@ -8,6 +8,7 @@ import logging
 import fosslight_dependency.constant as const
 from fosslight_dependency.package_manager.Pypi import Pypi
 from fosslight_dependency.package_manager.Npm import Npm
+from fosslight_dependency.package_manager.Yarn import Yarn
 from fosslight_dependency.package_manager.Maven import Maven
 from fosslight_dependency.package_manager.Gradle import Gradle
 from fosslight_dependency.package_manager.Pub import Pub
@@ -32,11 +33,15 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
     ret = True
     package_dep_item_list = []
     cover_comment = ''
+    npm_fallback_to_yarn = False
 
     if package_manager_name == const.PYPI:
         package_manager = Pypi(input_dir, output_dir, pip_activate_cmd, pip_deactivate_cmd)
     elif package_manager_name == const.NPM:
         package_manager = Npm(input_dir, output_dir)
+        npm_fallback_to_yarn = True
+    elif package_manager_name == const.YARN:
+        package_manager = Yarn(input_dir, output_dir)
     elif package_manager_name == const.MAVEN:
         package_manager = Maven(input_dir, output_dir, output_custom_dir)
     elif package_manager_name == const.GRADLE:
@@ -66,7 +71,7 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
     else:
         logger.error(f"Not supported package manager name: {package_manager_name}")
         ret = False
-        return ret, package_dep_item_list
+        return ret, package_dep_item_list, cover_comment, package_manager_name
 
     if manifest_file_name:
         package_manager.set_manifest_file(manifest_file_name)
@@ -74,6 +79,24 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
     if direct:
         package_manager.set_direct_dependencies(direct)
     ret = package_manager.run_plugin()
+
+    if not ret and npm_fallback_to_yarn:
+        logger.warning("Npm analysis failed. Attempting to use Yarn as fallback...")
+        del package_manager
+        package_manager = Yarn(input_dir, output_dir)
+        package_manager_name = const.YARN
+
+        if manifest_file_name:
+            package_manager.set_manifest_file(manifest_file_name)
+        if direct:
+            package_manager.set_direct_dependencies(direct)
+
+        ret = package_manager.run_plugin()
+        if ret:
+            logger.info("Successfully switched to Yarn")
+        else:
+            logger.error("Yarn also failed")
+
     if ret:
         if direct:
             package_manager.parse_direct_dependencies()
@@ -100,4 +123,4 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
 
     del package_manager
 
-    return ret, package_dep_item_list, cover_comment
+    return ret, package_dep_item_list, cover_comment, package_manager_name

fosslight_dependency/_help.py

@@ -16,6 +16,7 @@ _HELP_MESSAGE_DEPENDENCY = """
         Maven (Java)
         NPM (Node.js)
         PNPM (Node.js)
+        Yarn (Node.js)
         PIP (Python)
         Pub (Dart with flutter)
         Cocoapods (Swift/Obj-C)
@@ -33,7 +34,7 @@ _HELP_MESSAGE_DEPENDENCY = """
             -v\t\t\t\t    Print the version of the script.
             -m <package_manager>\t    Enter the package manager.
                                         \t(npm, maven, gradle, pypi, pub, cocoapods, android, swift, carthage,
-                                        \t go, nuget, helm, unity, cargo, pnpm)
+                                        \t go, nuget, helm, unity, cargo, pnpm, yarn)
             -p <input_path>\t\t    Enter the path where the script will be run.
             -e <exclude_path>\t\t    Enter the path where the analysis will not be performed.
             -o <output_path>\t\t    Output path

fosslight_dependency/constant.py

@@ -25,12 +25,14 @@ HELM = 'helm'
 UNITY = 'unity'
 CARGO = 'cargo'
 PNPM = 'pnpm'
+YARN = 'yarn'
 
 # Supported package name and manifest file
 SUPPORT_PACKAE = {
     PYPI: ['requirements.txt', 'setup.py', 'pyproject.toml'],
     PNPM: 'pnpm-lock.yaml',
     NPM: 'package.json',
+    YARN: 'yarn.lock',
     MAVEN: 'pom.xml',
     GRADLE: 'build.gradle',
     PUB: 'pubspec.yaml',

fosslight_dependency/package_manager/Maven.py

@@ -46,12 +46,13 @@ class Maven(PackageManager):
         ret = True
 
         if not os.path.isfile(self.input_file_name):
-            self.is_run_plugin = True
             pom_backup = 'pom.xml_backup'
 
             ret = self.add_plugin_in_pom(pom_backup)
             if ret:
-                self.run_maven_plugin()
+                ret_plugin = self.run_maven_plugin()
+                if ret_plugin:
+                    self.is_run_plugin = True
 
             if os.path.isfile(pom_backup):
                 shutil.move(pom_backup, const.SUPPORT_PACKAE.get(self.package_manager_name))
@@ -133,6 +134,7 @@ class Maven(PackageManager):
             shutil.rmtree(top_path)
 
     def run_maven_plugin(self):
+        ret_plugin = True
         logger.info('Run maven license scanning plugin with temporary pom.xml')
         current_mode = ''
         if os.path.isfile('mvnw') or os.path.isfile('mvnw.cmd'):
@@ -148,21 +150,24 @@ class Maven(PackageManager):
         ret = subprocess.call(cmd, shell=True)
         if ret != 0:
             logger.error(f"Failed to run maven plugin: {cmd}")
+            ret_plugin = False
 
-        cmd = f"{cmd_mvn} dependency:tree"
-        try:
-            ret_txt = subprocess.check_output(cmd, text=True, shell=True)
-            if ret_txt is not None:
-                self.parse_dependency_tree(ret_txt)
-                self.set_direct_dependencies(True)
-            else:
-                logger.error(f"Failed to run: {cmd}")
+        if ret_plugin:
+            cmd = f"{cmd_mvn} dependency:tree"
+            try:
+                ret_txt = subprocess.check_output(cmd, text=True, shell=True)
+                if ret_txt is not None:
+                    self.parse_dependency_tree(ret_txt)
+                    self.set_direct_dependencies(True)
+                else:
+                    logger.error(f"Failed to run: {cmd}")
+                    self.set_direct_dependencies(False)
+            except Exception as e:
+                logger.error(f"Failed to run '{cmd}': {e}")
                 self.set_direct_dependencies(False)
-        except Exception as e:
-            logger.error(f"Failed to run '{cmd}': {e}")
-            self.set_direct_dependencies(False)
         if current_mode:
             change_file_mode(cmd_mvn, current_mode)
+        return ret_plugin
 
     def create_dep_stack(self, dep_line):
         dep_stack = []

fosslight_dependency/package_manager/Npm.py

@@ -53,7 +53,7 @@ class Npm(PackageManager):
             self.flag_tmp_node_modules = True
             cmd_ret = subprocess.call(npm_install_cmd, shell=True)
             if cmd_ret != 0:
-                logger.error(f"{npm_install_cmd} returns an error")
+                logger.error(f"{npm_install_cmd} failed")
                 return False
 
         # customized json file for obtaining specific items with license-checker
@@ -109,13 +109,15 @@ class Npm(PackageManager):
         cmd = 'npm ls -a --omit=dev --json -s'
         result = subprocess.run(cmd, shell=True, capture_output=True, text=True, encoding='utf-8')
         rel_tree = result.stdout
-        if rel_tree is None:
-            logger.error(f"It returns the error: {cmd}")
-            logger.error(f"No output for {cmd}")
+        if not rel_tree or rel_tree.strip() == '':
+            logger.error(f"No output for {cmd}, stderr: {result.stderr}")
+            ret = False
+        elif result.returncode > 1:
+            logger.error(f"'{cmd}' failed with exit code({result.returncode}), stderr: {result.stderr}")
             ret = False
         if ret:
             if result.returncode == 1:
-                logger.warning(f"'{cmd}' returns error code: {result.stderr}")
+                logger.debug(f"'{cmd}' has warnings: {result.stderr}")
 
             try:
                 rel_json = json.loads(rel_tree)

fosslight_dependency/package_manager/Pypi.py

@@ -239,7 +239,7 @@ class Pypi(PackageManager):
                             metadata = package.get('metadata', {})
                             package_name = metadata.get('name', '')
                             if package_name:
-                                if package_name in ['pip', 'setuptools']:
+                                if package_name in ['pip', 'setuptools', 'wheel']:
                                     continue
                                 self.total_dep_list.append(re.sub(r"[-_.]+", "-", package_name).lower())
                 else:

fosslight_dependency/package_manager/Yarn.py

@@ -0,0 +1,222 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2025 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import logging
+import subprocess
+import json
+import fosslight_util.constant as constant
+import fosslight_dependency.constant as const
+from fosslight_dependency.package_manager.Npm import Npm
+from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
+from fosslight_dependency._package_manager import get_url_to_purl
+from fosslight_dependency.package_manager.Npm import check_multi_license, check_unknown_license
+
+logger = logging.getLogger(constant.LOGGER_NAME)
+
+
+class Yarn(Npm):
+
+    def __init__(self, input_dir, output_dir):
+        super().__init__(input_dir, output_dir)
+        self.package_manager_name = const.YARN
+        self.yarn_version = None
+
+    def detect_yarn_version(self):
+        """Detect Yarn version (1.x = Classic, 2+ = Berry)"""
+        if self.yarn_version is not None:
+            return self.yarn_version
+
+        try:
+            result = subprocess.run('yarn -v', shell=True, capture_output=True, text=True, encoding='utf-8')
+            if result.returncode == 0:
+                version_str = result.stdout.strip()
+                major_version = int(version_str.split('.')[0])
+                self.yarn_version = major_version
+                logger.info(f"Detected Yarn version: {version_str} (major: {major_version})")
+                return major_version
+        except Exception as e:
+            logger.warning(f"Failed to detect Yarn version: {e}")
+        return None
+
+    def start_license_checker(self):
+        ret = True
+        license_checker_cmd = f'license-checker --production --json --out {self.input_file_name}'
+        custom_path_option = ' --customPath '
+        node_modules = 'node_modules'
+
+        self.detect_yarn_version()
+
+        # For Yarn Berry (2+), check if using PnP mode
+        is_pnp_mode = False
+        if self.yarn_version and self.yarn_version >= 2:
+            # Check if .pnp.cjs exists (PnP mode indicator)
+            if os.path.exists('.pnp.cjs') or os.path.exists('.pnp.js'):
+                is_pnp_mode = True
+                logger.info("Detected Yarn Berry with PnP mode")
+
+        if not os.path.isdir(node_modules):
+            logger.info("node_modules directory does not exist.")
+            self.flag_tmp_node_modules = True
+
+            # For PnP mode, try to force node_modules creation
+            if is_pnp_mode:
+                logger.info("Attempting to create node_modules for PnP project...")
+                yarn_install_cmd = 'YARN_NODE_LINKER=node-modules yarn install --production --ignore-scripts'
+                logger.info(f"Executing: {yarn_install_cmd}")
+            else:
+                yarn_install_cmd = 'yarn install --production --ignore-scripts'
+                logger.info(f"Executing: {yarn_install_cmd}")
+
+            cmd_ret = subprocess.call(yarn_install_cmd, shell=True)
+            if cmd_ret != 0:
+                logger.error(f"{yarn_install_cmd} failed")
+                if is_pnp_mode:
+                    logger.error("Yarn Berry PnP mode detected. Consider setting 'nodeLinker: node-modules' in .yarnrc.yml")
+                return False
+            else:
+                logger.info(f"Successfully executed {yarn_install_cmd}")
+
+        self.make_custom_json(self.tmp_custom_json)
+
+        cmd = license_checker_cmd + custom_path_option + self.tmp_custom_json
+        cmd_ret = subprocess.call(cmd, shell=True)
+        if cmd_ret != 0:
+            logger.error(f"It returns the error: {cmd}")
+            logger.error("Please check if the license-checker is installed.(sudo npm install -g license-checker)")
+            ret = False
+        else:
+            self.append_input_package_list_file(self.input_file_name)
+        if os.path.exists(self.tmp_custom_json):
+            os.remove(self.tmp_custom_json)
+
+        return ret
+
+    def parse_oss_information(self, f_name):
+        with open(f_name, 'r', encoding='utf8') as json_file:
+            json_data = json.load(json_file)
+
+        _licenses = 'licenses'
+        _repository = 'repository'
+        _private = 'private'
+
+        keys = [key for key in json_data]
+        purl_dict = {}
+        for i in range(0, len(keys)):
+            dep_item = DependencyItem()
+            oss_item = OssItem()
+            d = json_data.get(keys[i - 1])
+            oss_init_name = d['name']
+            oss_item.name = f'{const.NPM}:{oss_init_name}'
+
+            if d[_licenses]:
+                license_name = d[_licenses]
+            else:
+                license_name = ''
+
+            oss_item.version = d['version']
+            package_path = d['path']
+
+            private_pkg = False
+            if _private in d:
+                if d[_private]:
+                    private_pkg = True
+
+            oss_item.download_location = f"{self.dn_url}{oss_init_name}/v/{oss_item.version}"
+            dn_loc = f"{self.dn_url}{oss_init_name}"
+            dep_item.purl = get_url_to_purl(oss_item.download_location, self.package_manager_name)
+            purl_dict[f'{oss_init_name}({oss_item.version})'] = dep_item.purl
+            if d[_repository]:
+                dn_loc = d[_repository]
+            elif private_pkg:
+                dn_loc = ''
+
+            oss_item.homepage = dn_loc
+
+            if private_pkg:
+                oss_item.download_location = oss_item.homepage
+                oss_item.comment = 'private'
+            if self.package_name == f'{oss_init_name}({oss_item.version})':
+                oss_item.comment = 'root package'
+            elif self.direct_dep and len(self.relation_tree) > 0:
+                if f'{oss_init_name}({oss_item.version})' in self.relation_tree[self.package_name]:
+                    oss_item.comment = 'direct'
+                else:
+                    oss_item.comment = 'transitive'
+
+                if f'{oss_init_name}({oss_item.version})' in self.relation_tree:
+                    dep_item.depends_on_raw = self.relation_tree[f'{oss_init_name}({oss_item.version})']
+
+            # For Yarn, use 'package.json' instead of yarn.lock for license info
+            manifest_file_path = os.path.join(package_path, 'package.json')
+            multi_license, license_comment, multi_flag = check_multi_license(license_name, manifest_file_path)
+
+            if multi_flag:
+                oss_item.comment = license_comment
+                license_name = multi_license
+            else:
+                license_name = license_name.replace(",", "")
+                license_name = check_unknown_license(license_name, manifest_file_path)
+            oss_item.license = license_name
+
+            dep_item.oss_items.append(oss_item)
+            self.dep_items.append(dep_item)
+
+        if self.direct_dep:
+            self.dep_items = change_dependson_to_purl(purl_dict, self.dep_items)
+        return
+
+    def parse_rel_dependencies(self, rel_name, rel_ver, rel_dependencies):
+        """Override to handle missing packages and packages without version"""
+        _dependencies = 'dependencies'
+        _version = 'version'
+        _peer = 'peerMissing'
+        _missing = 'missing'
+
+        for rel_dep_name in rel_dependencies.keys():
+            # Optional, non-installed dependencies are listed as empty objects
+            if rel_dependencies[rel_dep_name] == {}:
+                continue
+            if _peer in rel_dependencies[rel_dep_name]:
+                if rel_dependencies[rel_dep_name][_peer]:
+                    continue
+            # Skip missing packages (not installed)
+            if _missing in rel_dependencies[rel_dep_name]:
+                if rel_dependencies[rel_dep_name][_missing]:
+                    continue
+            # Skip if version key doesn't exist
+            if _version not in rel_dependencies[rel_dep_name]:
+                continue
+
+            if f'{rel_name}({rel_ver})' not in self.relation_tree:
+                self.relation_tree[f'{rel_name}({rel_ver})'] = []
+            elif f'{rel_dep_name}({rel_dependencies[rel_dep_name][_version]})' in self.relation_tree[f'{rel_name}({rel_ver})']:
+                continue
+            self.relation_tree[f'{rel_name}({rel_ver})'].append(f'{rel_dep_name}({rel_dependencies[rel_dep_name][_version]})')
+            if _dependencies in rel_dependencies[rel_dep_name]:
+                self.parse_rel_dependencies(rel_dep_name, rel_dependencies[rel_dep_name][_version],
+                                            rel_dependencies[rel_dep_name][_dependencies])
+
+    def parse_direct_dependencies(self):
+        if not self.direct_dep:
+            return
+        try:
+            # For Yarn, check if package.json exists (not yarn.lock)
+            # input_package_list_file[0] is the license-checker output file path
+            manifest_dir = os.path.dirname(self.input_package_list_file[0])
+            package_json_path = os.path.join(manifest_dir, 'package.json')
+
+            if os.path.isfile(package_json_path):
+                ret, err_msg = self.parse_transitive_relationship()
+                if not ret:
+                    self.direct_dep = False
+                    logger.warning(f'It cannot print direct/transitive dependency: {err_msg}')
+            else:
+                logger.info('Direct/transitive support is not possible because the package.json file does not exist.')
+                self.direct_dep = False
+        except Exception as e:
+            logger.warning(f'Cannot print direct/transitive dependency: {e}')
+            self.direct_dep = False

fosslight_dependency/run_dependency_scanner.py

@@ -106,6 +106,22 @@ def find_package_manager(input_dir, abs_path_to_exclude=[], manifest_file_name=[
     # both npm and pnpm are detected, remove npm.
     if 'npm' in found_package_manager.keys() and 'pnpm' in found_package_manager.keys():
         del found_package_manager['npm']
+
+    # both npm and yarn are detected, check which one to use based on lock file
+    if 'npm' in found_package_manager.keys() and 'yarn' in found_package_manager.keys():
+        # Remove npm from directories where yarn.lock exists
+        dirs_to_remove_from_npm = []
+        for yarn_dir in found_package_manager['yarn'].keys():
+            if yarn_dir in found_package_manager['npm']:
+                dirs_to_remove_from_npm.append(yarn_dir)
+
+        for dir_to_remove in dirs_to_remove_from_npm:
+            del found_package_manager['npm'][dir_to_remove]
+
+        # If npm has no directories left, remove it entirely
+        if not found_package_manager['npm']:
+            del found_package_manager['npm']
+
     if len(found_package_manager) >= 1:
         log_lines = ["\nDetected Manifest Files automatically"]
         log_lines = print_package_info(found_package_manager, log_lines)
@@ -207,6 +223,7 @@ def run_dependency_scanner(package_manager='', input_dir='', output_dir_file='',
     autodetect = True
     found_package_manager = {}
     if package_manager:
+        scan_item.set_cover_comment(f"Manual detect mode (-m {package_manager})")
         autodetect = False
         support_packagemanager = list(const.SUPPORT_PACKAE.keys())
 
@@ -221,7 +238,6 @@ def run_dependency_scanner(package_manager='', input_dir='', output_dir_file='',
             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 = []
 
@@ -259,33 +275,34 @@ def run_dependency_scanner(package_manager='', input_dir='', output_dir_file='',
     cover_comment = ''
     for pm, manifest_file_name_list in found_package_manager.items():
         if not manifest_file_name_list and not autodetect:
-            ret, package_dep_item_list, cover_comment = analyze_dependency(pm, input_dir, output_path,
-                                                                           pip_activate_cmd, pip_deactivate_cmd,
-                                                                           output_custom_dir, app_name, github_token,
-                                                                           [], direct)
+            ret, package_dep_item_list, cover_comment, actual_pm = analyze_dependency(pm, input_dir, output_path,
+                                                                                      pip_activate_cmd, pip_deactivate_cmd,
+                                                                                      output_custom_dir, app_name, github_token,
+                                                                                      [], direct)
             if ret:
-                success_pm[pm][input_dir].extend(['manual mode (-m option)'])
+                success_pm[actual_pm][input_dir].extend(['manual mode (-m option)'])
                 scan_item.append_file_items(package_dep_item_list)
             else:
-                fail_pm[pm][input_dir].extend(['manual mode (-m option)'])
+                fail_pm[actual_pm][input_dir].extend(['manual mode (-m option)'])
         else:
             for manifest_dir, manifest_file_name in manifest_file_name_list.items():
                 input_dir = manifest_dir
                 if manifest_file_name == pass_key:
                     continue
                 os.chdir(input_dir)
-                ret, package_dep_item_list, cover_comment = analyze_dependency(pm, input_dir, output_path,
-                                                                               pip_activate_cmd, pip_deactivate_cmd,
-                                                                               output_custom_dir, app_name, github_token,
-                                                                               manifest_file_name, direct)
+                ret, package_dep_item_list, cover_comment, actual_pm = analyze_dependency(pm, input_dir, output_path,
+                                                                                          pip_activate_cmd, pip_deactivate_cmd,
+                                                                                          output_custom_dir, app_name,
+                                                                                          github_token,
+                                                                                          manifest_file_name, direct)
                 if ret:
-                    success_pm[pm][input_dir].extend(manifest_file_name)
+                    success_pm[actual_pm][input_dir].extend(manifest_file_name)
                     scan_item.append_file_items(package_dep_item_list)
 
                     dup_pm = None
-                    if pm == const.GRADLE and const.ANDROID in found_package_manager:
+                    if actual_pm == const.GRADLE and const.ANDROID in found_package_manager:
                         dup_pm = const.ANDROID
-                    elif pm == const.ANDROID and const.GRADLE in found_package_manager:
+                    elif actual_pm == const.ANDROID and const.GRADLE in found_package_manager:
                         dup_pm = const.GRADLE
 
                     if dup_pm:
@@ -296,7 +313,7 @@ def run_dependency_scanner(package_manager='', input_dir='', output_dir_file='',
                         else:
                             found_package_manager[dup_pm][manifest_dir] = pass_key
                 else:
-                    fail_pm[pm][input_dir].extend(manifest_file_name)
+                    fail_pm[actual_pm][input_dir].extend(manifest_file_name)
 
     success_pm = {k: dict(v) for k, v in success_pm.items()}
     fail_pm = {k: dict(v) for k, v in fail_pm.items()}

{fosslight_dependency-4.1.20.dist-info → fosslight_dependency-4.1.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fosslight-dependency
-Version: 4.1.20
+Version: 4.1.22
 Summary: FOSSLight Dependency Scanner
 Home-page: https://github.com/fosslight/fosslight_dependency_scanner
 Download-URL: https://github.com/fosslight/fosslight_dependency_scanner
@@ -65,7 +65,7 @@ In this user guide, you can see how to install the FOSSLight Dependency Scanner
 </thead>
 <tbody>
   <tr>
-    <td rowspan="2">Javascript</td>
+    <td rowspan="3">Javascript</td>
     <td>Npm</td>
     <td>package.json</td>
     <td>O</td>
@@ -78,6 +78,13 @@ In this user guide, you can see how to install the FOSSLight Dependency Scanner
     <td>O</td>
     <td>O</td>
     <td>O</td>
+  </tr>
+    <tr>
+    <td>Yarn</td>
+    <td>package.json</td>
+    <td>O</td>
+    <td>O</td>
+    <td>O</td>
   </tr>
   <tr>
     <td rowspan="2">Java</td>

{fosslight_dependency-4.1.20.dist-info → fosslight_dependency-4.1.22.dist-info}/RECORD

@@ -1,11 +1,11 @@
 fosslight_dependency/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fosslight_dependency/_analyze_dependency.py,sha256=oJ_6gka5V8cdafxoiQhgepGDnjO5EVM9JX4AdBacMzw,4707
+fosslight_dependency/_analyze_dependency.py,sha256=TX86cl7BF3_kCsAQY459X9sqGqP0xbJI7hqnqe7IbnU,5598
 fosslight_dependency/_graph_convertor.py,sha256=D8GwmJfuj9Wg3_DeKRPLGGdyHSLcoU2Q0VzKQbkJG4g,2267
-fosslight_dependency/_help.py,sha256=wt7M6wnyJJr-RIQ1pvMceevpGAKCSTQsAlGiKOXMQUE,3595
+fosslight_dependency/_help.py,sha256=npxm927ZnlEoXKTwhtVyDRygq7ur7sKmn4xtg2vh86I,3624
 fosslight_dependency/_package_manager.py,sha256=mN1ukEmZkm6COhxWm-mVfhCZkHppfFgXyXzBT1x02Sw,15016
-fosslight_dependency/constant.py,sha256=5upuTFSTmmQwqv2u-MRcEG4lxaIZAIi_c-rAPhOrsfM,1226
+fosslight_dependency/constant.py,sha256=0Jr0D5T9S3AuLTEgepiqcKvW4nIJeqotz1lt_YDwbGU,1263
 fosslight_dependency/dependency_item.py,sha256=wNLWcsNycf3HQ5Pib2WrMeo2dn0eHCRg20NLcL95Qew,3345
-fosslight_dependency/run_dependency_scanner.py,sha256=1F9zrKd4VjeXI9l5M-ZW0qxq-Cf27u8u7_aw8l_O7vQ,20406
+fosslight_dependency/run_dependency_scanner.py,sha256=4uocLr5HY2r9ouLI0NGLTI8TE-5g3aQlA9eaP7cqBHk,21338
 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
@@ -15,21 +15,22 @@ fosslight_dependency/package_manager/Cocoapods.py,sha256=k_URV1ekMOU8l_y9_KIp_lu
 fosslight_dependency/package_manager/Go.py,sha256=eEWvPoE3Jd0lMJAxWMNdFcoi21fJF0EwtRbjBDHF8KQ,7309
 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=vAiBEAEGQD5eaFGVSLmrZ8AAtoz_IuTmhaWuPTmsku0,10503
-fosslight_dependency/package_manager/Npm.py,sha256=1ILIBYiU1gwi6yTbc4GSyjYf7omChoBntUBf_SnyBGU,10845
+fosslight_dependency/package_manager/Maven.py,sha256=ps6kxpB_aWMwjoNWFnXxetxn_y7iGDUz4NcNoxMmDNA,10709
+fosslight_dependency/package_manager/Npm.py,sha256=cPKo3TewAPN8IQUUFlJZ7nc202_GnpMzGMl4gIF4St8,10982
 fosslight_dependency/package_manager/Nuget.py,sha256=u4w084Qozk4nrVdT4o_nDiT8v4URIlXaOrDh11Hu1Bw,8885
 fosslight_dependency/package_manager/Pnpm.py,sha256=LDKooFGQHui_Q5U7XqSJ8KcCPiLVndXf5oGKTJExh5w,7056
 fosslight_dependency/package_manager/Pub.py,sha256=Rrz8_6wdrmMU6f3vbbuAwyMbODBauXNnBbI619OQgDk,10184
-fosslight_dependency/package_manager/Pypi.py,sha256=Iko_MGEBPrYr1I2-430bG4mkAwFqTUPpjWWKfJ9SM1c,17178
+fosslight_dependency/package_manager/Pypi.py,sha256=Ae-mFl9jSgc1XrUdzAuKGuZA4nduSsWaC-u6VVjFNtg,17187
 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/Yarn.py,sha256=8K2bTImdvPtuDT_Tz1StnBnx6DjoHWV1Wzb0WlhBRhw,9586
 fosslight_dependency/package_manager/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fosslight_dependency-4.1.20.dist-info/Apache-2.0.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fosslight_dependency-4.1.20.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fosslight_dependency-4.1.20.dist-info/LicenseRef-3rd_party_licenses.txt,sha256=EcsFt7aE1rp3OXAdJgmXayfOZdpRdBMcmRnyoqWMCsw,95687
-fosslight_dependency-4.1.20.dist-info/METADATA,sha256=9FAGK-KEqZOfJJUntY_zcvBL6Pjf-kTakBdTSrrZtEE,5213
-fosslight_dependency-4.1.20.dist-info/MIT.txt,sha256=9cx4CbArgByWvkoEZNqpzbpJgA9TUe2D62rMocQpgfs,1082
-fosslight_dependency-4.1.20.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-fosslight_dependency-4.1.20.dist-info/entry_points.txt,sha256=AeU-9Bl8al8Sa-XvhitGHdT3ZTPIrlhqADcp7s5OLF8,90
-fosslight_dependency-4.1.20.dist-info/top_level.txt,sha256=Jc0V7VcVCH0TEM8ksb8dwroTYz4AmRaQnlr3FB71Hcs,21
-fosslight_dependency-4.1.20.dist-info/RECORD,,
+fosslight_dependency-4.1.22.dist-info/Apache-2.0.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fosslight_dependency-4.1.22.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fosslight_dependency-4.1.22.dist-info/LicenseRef-3rd_party_licenses.txt,sha256=EcsFt7aE1rp3OXAdJgmXayfOZdpRdBMcmRnyoqWMCsw,95687
+fosslight_dependency-4.1.22.dist-info/METADATA,sha256=s2CAZTjyfixbchU-26Mzb9OKpRJ3_K-Op86QqX1qhw0,5319
+fosslight_dependency-4.1.22.dist-info/MIT.txt,sha256=9cx4CbArgByWvkoEZNqpzbpJgA9TUe2D62rMocQpgfs,1082
+fosslight_dependency-4.1.22.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+fosslight_dependency-4.1.22.dist-info/entry_points.txt,sha256=AeU-9Bl8al8Sa-XvhitGHdT3ZTPIrlhqADcp7s5OLF8,90
+fosslight_dependency-4.1.22.dist-info/top_level.txt,sha256=Jc0V7VcVCH0TEM8ksb8dwroTYz4AmRaQnlr3FB71Hcs,21
+fosslight_dependency-4.1.22.dist-info/RECORD,,