fosslight-dependency 3.15.5__py3-none-any.whl → 4.0.0__py3-none-any.whl

fosslight_dependency/_analyze_dependency.py

@@ -28,7 +28,7 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
                        output_custom_dir='', app_name=const.default_app_name, github_token='', manifest_file_name=[],
                        direct=True):
     ret = True
-    package_sheet_list = []
+    package_dep_item_list = []
     cover_comment = ''
 
     if package_manager_name == const.PYPI:
@@ -60,7 +60,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_sheet_list
+        return ret, package_dep_item_list
 
     if manifest_file_name:
         package_manager.set_manifest_file(manifest_file_name)
@@ -76,7 +76,8 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
             logger.info(f"Parse oss information with file: {f_name}")
 
             if os.path.isfile(f_name):
-                package_sheet_list.extend(package_manager.parse_oss_information(f_name))
+                package_manager.parse_oss_information(f_name)
+                package_dep_item_list.extend(package_manager.dep_items)
             else:
                 logger.error(f"Failed to open input file: {f_name}")
                 ret = False
@@ -90,4 +91,4 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
 
     del package_manager
 
-    return ret, package_sheet_list, cover_comment
+    return ret, package_dep_item_list, cover_comment

fosslight_dependency/_graph_convertor.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+from typing import Optional, Tuple
+import igraph as ig
+import matplotlib.pyplot as plt
+
+
+class GraphConvertor:
+    def __init__(self, dep_items: Optional[list] = None):
+        self._verticies = {}
+        self._edges = []
+        if dep_items:
+            self.init_list(dep_items)
+
+    def init_list(self, dep_items: list):
+        """
+        Initialize dep_items to self._verticies and self._edges
+
+        Args:
+            dep_items : List containing package information
+        """
+        depend_on_package_dict = {}
+        for idx, file_item in enumerate(dep_items):
+            package_name = file_item.purl
+            depend_on_packages = file_item.depends_on
+            self._verticies[package_name] = idx
+            depend_on_package_dict[package_name] = depend_on_packages
+        else:
+            for package_name, depend_on_packages in depend_on_package_dict.items():
+                if not package_name:
+                    pass
+                else:
+                    package_idx = self._verticies[package_name]
+                    for depend_on_package in depend_on_packages:
+                        if not depend_on_package:
+                            pass
+                        else:
+                            depend_on_package_idx = self._verticies[depend_on_package]
+                            self._edges.append((package_idx, depend_on_package_idx))
+
+    def save(self, path: str, size: Tuple[(int, int)]):
+        g = ig.Graph((len(self._verticies)), (self._edges), directed=True)
+
+        g["title"] = "Dependency Graph"
+        g.vs["name"] = list(self._verticies.keys())
+
+        fig, ax = plt.subplots(figsize=(tuple(map((lambda x: x / 100), size))))
+        fig.tight_layout()
+
+        ig.plot(
+            g,
+            target=ax,
+            layout="kk",
+            vertex_size=15,
+            vertex_color=["#FFD2D2"],
+            vertex_label=(g.vs["name"]),
+            vertex_label_dist=1.5,
+            vertex_label_size=7.0,
+            edge_width=0.5,
+            edge_color=["#FFD2D2"],
+            edge_arrow_size=5,
+            edge_arrow_width=5,
+        )
+
+        fig.savefig(path)

fosslight_dependency/_help.py

@@ -37,6 +37,10 @@ _HELP_MESSAGE_DEPENDENCY = """
             \t\t\t\t\t(If you want to generate the specific file name, add the output path with file name.)
             -f <format> [<format> ...]\t    Output formats (excel, csv, opossum, yaml, spdx-tag, spdx-yaml, spdx-json, spdx-xml)
         \t\t\t\t    Multiple formats can be specified separated by space.
+            --graph-path <save_path> \t    Enter the path where the graph image will be saved
+            \t\t\t\t\t(ex. /your/directory/path/filename.{pdf, jpg, png}) (recommend pdf extension)
+            --graph-size <width> <height>   Enter the size of the graph image (The size unit is pixels)
+            \t\t\t\t\t--graph-path option is required
             --direct\t\t\t    Print the direct/transitive dependency type in comment.
                                 \t\tChoice 'True' or 'False'. (default:True)
             --notice\t\t\t    Print the open source license notice text.

fosslight_dependency/_package_manager.py

@@ -49,8 +49,8 @@ class PackageManager:
         self.manifest_file_name = []
         self.relation_tree = {}
         self.package_name = ''
-        self.purl_dict = {}
         self.cover_comment = ''
+        self.dep_items = []
 
         self.platform = platform.system()
         self.license_scanner_bin = check_license_scanner(self.platform)
@@ -67,6 +67,7 @@ class PackageManager:
         self.manifest_file_name = []
         self.relation_tree = {}
         self.package_name = ''
+        self.dep_items = []
 
     def run_plugin(self):
         ret = True
@@ -257,18 +258,6 @@ class PackageManager:
         except Exception as e:
             logger.warning(f'Fail to parse gradle dependency tree:{e}')
 
-    def change_dep_to_purl(self, sheet_list):
-        for oss_item in sheet_list:
-            try:
-                if len(oss_item) < 10:
-                    break
-                deps_list = oss_item[9]
-                deps_purl = list(filter(None, map(lambda x: self.purl_dict.get(x, ''), deps_list)))
-                oss_item[9] = ','.join(deps_purl)
-            except Exception as e:
-                logger.warning(f'Fail to change depend_on to purl:{e}')
-        return sheet_list
-
 
 def get_url_to_purl(url, pkg_manager, oss_name='', oss_version=''):
     purl_prefix = f'pkg:{pkg_manager}'

fosslight_dependency/dependency_item.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+from fosslight_util.constant import LOGGER_NAME
+from fosslight_util.oss_item import FileItem
+
+_logger = logging.getLogger(LOGGER_NAME)
+
+
+class DependencyItem(FileItem):
+    def __init__(self):
+        super().__init__("")
+
+        self._depends_on_raw = []  # name(version) format
+        self._depends_on = []  # purl format
+        self.purl = ""
+
+    def __del__(self):
+        pass
+
+    @property
+    def depends_on(self):
+        return self._depends_on
+
+    @depends_on.setter
+    def depends_on(self, value):
+        if not value:
+            self._depends_on = []
+        else:
+            if not isinstance(value, list):
+                value = value.split(",")
+            self._depends_on.extend(value)
+            self._depends_on = [item.strip() for item in self._depends_on]
+            self._depends_on = list(set(self._depends_on))
+
+    @property
+    def depends_on_raw(self):
+        return self._depends_on_raw
+
+    @depends_on_raw.setter
+    def depends_on_raw(self, value):
+        if not value:
+            self._depends_on_raw = []
+        else:
+            if not isinstance(value, list):
+                value = value.split(",")
+            self._depends_on_raw.extend(value)
+            self._depends_on_raw = [item.strip() for item in self._depends_on_raw]
+            self._depends_on_raw = list(set(self._depends_on_raw))
+
+    def get_print_array(self):
+        items = []
+        for oss in self.oss_items:
+            exclude = "Exclude" if self.exclude or oss.exclude else ""
+            lic = ",".join(oss.license)
+            depends_on = ",".join(self.depends_on) if len(self.depends_on) > 0 else ""
+
+            oss_item = [self.purl, oss.name, oss.version, lic, oss.download_location, oss.homepage,
+                        oss.copyright, exclude, oss.comment, depends_on]
+            items.append(oss_item)
+
+        return items
+
+    def get_print_json(self):
+        items = []
+        for oss in self.oss_items:
+            json_item = {}
+            json_item["name"] = oss.name
+            json_item["version"] = oss.version
+
+            if self.purl != "":
+                json_item["package url"] = self.purl
+            if len(oss.license) > 0:
+                json_item["license"] = oss.license
+            if oss.download_location != "":
+                json_item["download location"] = oss.download_location
+            if oss.homepage != "":
+                json_item["homepage"] = oss.homepage
+            if oss.copyright != "":
+                json_item["copyright text"] = oss.copyright
+            if self.exclude or oss.exclude:
+                json_item["exclude"] = True
+            if oss.comment != "":
+                json_item["comment"] = oss.comment
+            if len(self.depends_on) > 0:
+                json_item["depends on"] = self.depends_on
+
+            items.append(json_item)
+
+        return items
+
+
+def change_dependson_to_purl(purl_dict, dep_items):
+    for dep_item in dep_items:
+        try:
+            dep_item.depends_on = list(filter(None, map(lambda x: purl_dict.get(x, ''), dep_item.depends_on_raw)))
+
+        except Exception as e:
+            _logger.warning(f'Fail to change depend_on to purl:{e}')
+    return dep_items

fosslight_dependency/package_manager/Android.py

@@ -8,6 +8,8 @@ import logging
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager, get_url_to_purl
+from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -40,43 +42,41 @@ class Android(PackageManager):
 
     def parse_oss_information(self, f_name):
         with open(f_name, 'r', encoding='utf8') as input_fp:
-            sheet_list = []
-
+            purl_dict = {}
             for i, line in enumerate(input_fp.readlines()):
-                comment = ''
+                dep_item = DependencyItem()
+                oss_item = OssItem()
                 split_str = line.strip().split("\t")
                 if i < 2:
                     continue
 
-                if len(split_str) == 9:
-                    idx, manifest_file, oss_name, oss_version, license_name, dn_loc, homepage, NA, NA = split_str
-                elif len(split_str) == 7:
-                    idx, manifest_file, oss_name, oss_version, license_name, dn_loc, homepage = split_str
+                if len(split_str) == 9 or len(split_str) == 7:
+                    _, _, oss_item.name, oss_item.version, oss_item.license, \
+                        oss_item.download_location, oss_item.homepage = split_str[:7]
                 else:
                     continue
-                purl = get_url_to_purl(dn_loc, 'maven')
-                self.purl_dict[f'{oss_name}({oss_version})'] = purl
+                dep_item.purl = get_url_to_purl(oss_item.download_location, 'maven')
+                purl_dict[f'{oss_item.name}({oss_item.version})'] = dep_item.purl
 
-                comment_list = []
-                deps_list = []
                 if self.direct_dep:
-                    dep_key = f"{oss_name}({oss_version})"
+                    dep_key = f"{oss_item.name}({oss_item.version})"
                     if self.total_dep_list:
                         if dep_key not in self.total_dep_list:
                             continue
                     if dep_key in self.direct_dep_list:
-                        comment_list.append('direct')
+                        oss_item.comment = 'direct'
                     else:
-                        comment_list.append('transitive')
+                        oss_item.comment = 'transitive'
                     try:
                         if dep_key in self.relation_tree:
-                            deps_list.extend(self.relation_tree[dep_key])
+                            dep_item.depends_on_raw = self.relation_tree[dep_key]
                     except Exception as e:
                         logger.error(f"Fail to find oss scope in dependency tree: {e}")
-                comment = ','.join(comment_list)
 
-                sheet_list.append([purl, oss_name, oss_version, license_name, dn_loc, homepage,
-                                  '', '', comment, deps_list])
-            sheet_list = self.change_dep_to_purl(sheet_list)
+                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 sheet_list
+        return

fosslight_dependency/package_manager/Carthage.py

@@ -11,6 +11,8 @@ 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.dependency_item import DependencyItem
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -35,9 +37,8 @@ class Carthage(PackageManager):
     def parse_oss_information(self, f_name):
         github = "github"
         checkout_dir_list = get_checkout_dirname()
-        comment = ''
+
         with open(f_name, 'r', encoding='utf8') as input_fp:
-            sheet_list = []
             g = ''
             if not checkout_dir_list:
                 g = connect_github(self.github_token)
@@ -47,21 +48,24 @@ class Carthage(PackageManager):
                 # Ref. https://github.com/Carthage/Carthage/blob/master/Documentation/Artifacts.md
                 re_result = re.findall(r'(github|git)[\s]\"(\S*)\"[\s]\"(\S*)\"', line)
                 try:
+                    dep_item = DependencyItem()
+                    oss_item = OssItem()
                     repo = re_result[0][0]
                     oss_path = re_result[0][1]
                     if oss_path.endswith('.git'):
                         oss_path = oss_path[:-4]
                     oss_origin_name = oss_path.split('/')[-1]
-                    oss_name = self.package_manager_name + ":" + oss_origin_name
+                    oss_item.name = self.package_manager_name + ":" + oss_origin_name
 
                     if repo == github:
-                        homepage = self.dn_url + oss_path
+                        oss_item.homepage = self.dn_url + oss_path
                     else:
-                        homepage = oss_path
-                    dn_loc = homepage
-                    oss_version = re_result[0][2]
+                        oss_item.homepage = oss_path
+                    oss_item.download_location = oss_item.homepage
+                    oss_item.version = re_result[0][2]
 
-                    purl = get_url_to_purl(homepage, self.package_manager_name, oss_origin_name, oss_version)
+                    dep_item.purl = get_url_to_purl(oss_item.homepage, self.package_manager_name,
+                                                    oss_origin_name, oss_item.version)
 
                     license_name = ''
                     find_license = False
@@ -89,20 +93,17 @@ class Carthage(PackageManager):
                             except Exception as e:
                                 logger.warning(f"Failed to get license with github api: {e}")
                                 license_name == ''
-
+                    oss_item.license = license_name
                     if self.direct_dep_list:
                         if oss_origin_name in self.direct_dep_list:
-                            comment = 'direct'
+                            oss_item.comment = 'direct'
                         else:
-                            comment = 'transitive'
-
-                    sheet_list.append([purl, oss_name, oss_version, license_name, dn_loc, homepage,
-                                      '', '', comment, ''])
-
+                            oss_item.comment = 'transitive'
+                    dep_item.oss_items.append(oss_item)
+                    self.dep_items.append(dep_item)
                 except Exception as e:
                     logger.warning(f"Failed to parse oss information: {e}")
-
-        return sheet_list
+        return
 
     def parse_direct_dependencies(self):
         self.direct_dep = True

fosslight_dependency/package_manager/Cocoapods.py

@@ -11,6 +11,8 @@ import re
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager, get_url_to_purl
+from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -36,7 +38,6 @@ class Cocoapods(PackageManager):
 
         spec_repo_list = []
         external_source_list = []
-        comment = ''
 
         if _spec_repos in podfile_yaml:
             for spec_item_key in podfile_yaml[_spec_repos]:
@@ -81,26 +82,26 @@ class Cocoapods(PackageManager):
                 if rel_key in self.relation_tree:
                     self.relation_tree[rel_key] = []
 
-        sheet_list = []
+        purl_dict = {}
         for pod_oss_name_origin, pod_oss_version in pod_item_list.items():
+            dep_item = DependencyItem()
+            oss_item = OssItem()
             try:
-                comment_list = []
-                deps_list = []
                 if self.direct_dep and (len(self.direct_dep_list) > 0):
                     if pod_oss_name_origin in self.direct_dep_list:
-                        comment_list.append('direct')
+                        oss_item.comment = 'direct'
                     else:
-                        comment_list.append('transitive')
-                    if f'{pod_oss_name_origin}({oss_version})' in self.relation_tree:
-                        deps_list.extend(self.relation_tree[f'{pod_oss_name_origin}({oss_version})'])
-                comment = ','.join(comment_list)
+                        oss_item.comment = 'transitive'
+                    if f'{pod_oss_name_origin}({pod_oss_version})' in self.relation_tree:
+                        dep_item.depends_on_raw = self.relation_tree[f'{pod_oss_name_origin}({pod_oss_version})']
 
-                oss_name_report = f'{self.package_manager_name}:{pod_oss_name_origin}'
+                oss_item.name = f'{self.package_manager_name}:{pod_oss_name_origin}'
                 pod_oss_name = pod_oss_name_origin
+                oss_item.version = pod_oss_version
                 if '/' in pod_oss_name_origin:
                     pod_oss_name = pod_oss_name_origin.split('/')[0]
                 if pod_oss_name in external_source_list:
-                    oss_name_report = pod_oss_name_origin
+                    oss_item.name = pod_oss_name_origin
                     podspec_filename = pod_oss_name + '.podspec.json'
                     spec_file_path = os.path.join("Pods", "Local Podspecs", podspec_filename)
                 else:
@@ -122,24 +123,27 @@ class Cocoapods(PackageManager):
                         file_path_without_version = os.path.join(os.sep, *file_path[:-2])
                     else:
                         file_path_without_version = os.path.join(*file_path[:-2])
-                    spec_file_path = os.path.join(file_path_without_version, pod_oss_version, file_path[-1])
+                    spec_file_path = os.path.join(file_path_without_version, oss_item.version, file_path[-1])
 
-                oss_name, oss_version, license_name, dn_loc, homepage = self.get_oss_in_podspec(spec_file_path)
-                purl = get_url_to_purl(homepage, self.package_manager_name, pod_oss_name_origin, oss_version)
-                self.purl_dict[f'{pod_oss_name_origin}({oss_version})'] = purl
+                oss_name, oss_version, oss_item.license, oss_item.download_location, \
+                    oss_item.homepage = self.get_oss_in_podspec(spec_file_path)
+                dep_item.purl = get_url_to_purl(oss_item.homepage, self.package_manager_name, pod_oss_name_origin, oss_version)
+                purl_dict[f'{pod_oss_name_origin}({oss_version})'] = dep_item.purl
                 if pod_oss_name in external_source_list:
-                    homepage = dn_loc
+                    oss_item.homepage = ''
                 if oss_name == '':
                     continue
-                if pod_oss_version != oss_version:
-                    logger.warning(f'{pod_oss_name_origin} has different version({pod_oss_version})\
+                if oss_item.version != oss_version:
+                    logger.warning(f'{pod_oss_name_origin} has different version({oss_item.version})\
                                    with spec version({oss_version})')
-                sheet_list.append([purl, oss_name_report, pod_oss_version, license_name, dn_loc, homepage,
-                                  '', '', comment, deps_list])
+                dep_item.oss_items.append(oss_item)
+                self.dep_items.append(dep_item)
             except Exception as e:
                 logger.warning(f"Fail to get {pod_oss_name_origin}:{e}")
-        sheet_list = self.change_dep_to_purl(sheet_list)
-        return sheet_list
+        if self.direct_dep:
+            self.dep_items = change_dependson_to_purl(purl_dict, self.dep_items)
+
+        return
 
     def get_oss_in_podspec(self, spec_file_path):
         oss_name = ''

fosslight_dependency/package_manager/Go.py

@@ -14,6 +14,8 @@ import shutil
 import fosslight_util.constant as constant
 import fosslight_dependency.constant as const
 from fosslight_dependency._package_manager import PackageManager, get_url_to_purl
+from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -78,7 +80,7 @@ class Go(PackageManager):
 
     def parse_oss_information(self, f_name):
         indirect = 'Indirect'
-        sheet_list = []
+        purl_dict = {}
         json_list = []
         with open(f_name, 'r', encoding='utf8') as input_fp:
             json_data_raw = ''
@@ -88,52 +90,51 @@ class Go(PackageManager):
                     json_list.append(json.loads(json_data_raw))
                     json_data_raw = ''
 
-        for dep_item in json_list:
+        for dep_i in json_list:
+            dep_item = DependencyItem()
+            oss_item = OssItem()
             try:
-                if 'Main' in dep_item:
-                    if dep_item['Main']:
+                if 'Main' in dep_i:
+                    if dep_i['Main']:
                         continue
-                package_path = dep_item['Path']
-                oss_name = f"{self.package_manager_name}:{package_path}"
-                oss_origin_version = dep_item['Version']
+                package_path = dep_i['Path']
+                oss_item.name = f"{self.package_manager_name}:{package_path}"
+                oss_origin_version = dep_i['Version']
                 if oss_origin_version.startswith('v'):
-                    oss_version = oss_origin_version[1:]
+                    oss_item.version = oss_origin_version[1:]
+                else:
+                    oss_item.version = oss_origin_version
 
-                comment_list = []
-                deps_list = []
                 if self.direct_dep:
-                    if indirect in dep_item:
-                        if dep_item[indirect]:
-                            comment_list.append('transitive')
+                    if indirect in dep_i:
+                        if dep_i[indirect]:
+                            oss_item.comment = 'transitive'
                         else:
-                            comment_list.append('direct')
+                            oss_item.comment = 'direct'
                     else:
-                        comment_list.append('direct')
+                        oss_item.comment = 'direct'
 
-                if f'{package_path}({oss_version})' in self.relation_tree:
-                    deps_list.extend(self.relation_tree[f'{package_path}({oss_version})'])
+                if f'{package_path}({oss_item.version})' in self.relation_tree:
+                    dep_item.depends_on_raw = self.relation_tree[f'{package_path}({oss_item.version})']
 
                 homepage_set = []
-                homepage = self.dn_url + package_path
-                purl = get_url_to_purl(f"{homepage}@{oss_version}", self.package_manager_name)
-                self.purl_dict[f'{package_path}({oss_version})'] = purl
+                oss_item.homepage = self.dn_url + package_path
+                dep_item.purl = get_url_to_purl(f"{oss_item.homepage}@{oss_item.version}", self.package_manager_name)
+                purl_dict[f'{package_path}({oss_item.version})'] = dep_item.purl
 
                 if oss_origin_version:
-                    tmp_homepage = f"{homepage}@{oss_origin_version}"
+                    tmp_homepage = f"{oss_item.homepage}@{oss_origin_version}"
                     homepage_set.append(tmp_homepage)
-                homepage_set.append(homepage)
-
-                license_name = ''
-                dn_loc = ''
+                homepage_set.append(oss_item.homepage)
 
                 for homepage_i in homepage_set:
                     try:
                         res = urllib.request.urlopen(homepage_i)
                         if res.getcode() == 200:
                             urlopen_success = True
-                            if homepage_i == homepage:
-                                if oss_version:
-                                    comment_list.append(f'Cannot connect {tmp_homepage}, get info from the latest version.')
+                            if homepage_i == oss_item.homepage:
+                                if oss_item.version:
+                                    oss_item.comment = f'Cannot connect {tmp_homepage}, get info from the latest version.'
                             break
                     except Exception:
                         continue
@@ -144,20 +145,19 @@ class Go(PackageManager):
 
                     license_data = bs_obj.find('a', {'data-test-id': 'UnitHeader-license'})
                     if license_data:
-                        license_name = license_data.text
+                        oss_item.license = license_data.text
 
                     repository_data = bs_obj.find('div', {'class': 'UnitMeta-repo'})
                     if repository_data:
-                        dn_loc = repository_data.find('a')['href']
+                        oss_item.download_location = repository_data.find('a')['href']
                     else:
-                        dn_loc = homepage
+                        oss_item.download_location = oss_item.homepage
 
             except Exception as e:
                 logging.warning(f"Fail to parse {package_path} in go mod : {e}")
                 continue
-
-            comment = ','.join(comment_list)
-            sheet_list.append([purl, oss_name, oss_version, license_name, dn_loc, homepage,
-                              '', '', comment, deps_list])
-        sheet_list = self.change_dep_to_purl(sheet_list)
-        return sheet_list
+            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