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

fosslight_dependency/package_manager/Gradle.py

@@ -10,6 +10,8 @@ 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.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -33,10 +35,11 @@ class Gradle(PackageManager):
         with open(f_name, 'r', encoding='utf8') as json_file:
             json_data = json.load(json_file)
 
-        sheet_list = []
+        purl_dict = {}
 
         for d in json_data['dependencies']:
-            comment = ''
+            dep_item = DependencyItem()
+            oss_item = OssItem()
             used_filename = False
             group_id = ""
             artifact_id = ""
@@ -50,51 +53,49 @@ class Gradle(PackageManager):
             else:
                 oss_name, oss_ini_version = parse_oss_name_version_in_filename(filename)
                 used_filename = True
-
-            dep_key = f"{oss_name}({oss_ini_version})"
+            oss_item.name = oss_name
+            dep_key = f"{oss_item.name}({oss_ini_version})"
             if self.total_dep_list:
                 if dep_key not in self.total_dep_list:
                     continue
 
-            oss_version = version_refine(oss_ini_version)
+            oss_item.version = version_refine(oss_ini_version)
 
-            license_names = []
-            purl = ''
             try:
+                license_names = []
                 for licenses in d['licenses']:
                     if licenses['name'] != '':
                         license_names.append(licenses['name'].replace(",", ""))
-                license_name = ', '.join(license_names)
+                oss_item.license = ', '.join(license_names)
             except Exception:
                 logger.info("Cannot find the license name")
 
             if used_filename or group_id == "":
-                dn_loc = 'Unknown'
-                homepage = ''
+                oss_item.download_location = 'Unknown'
             else:
-                dn_loc = f"{self.dn_url}{group_id}/{artifact_id}/{oss_ini_version}"
-                homepage = f"{self.dn_url}{group_id}/{artifact_id}"
-                purl = get_url_to_purl(dn_loc, 'maven')
-                self.purl_dict[f'{oss_name}({oss_ini_version})'] = purl
+                oss_item.download_location = f"{self.dn_url}{group_id}/{artifact_id}/{oss_ini_version}"
+                oss_item.homepage = f"{self.dn_url}{group_id}/{artifact_id}"
+                dep_item.purl = get_url_to_purl(oss_item.download_location, 'maven')
+                purl_dict[f'{oss_item.name}({oss_ini_version})'] = dep_item.purl
 
-            comment_list = []
-            deps_list = []
             if self.direct_dep:
                 if len(self.direct_dep_list) > 0:
                     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)
-        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
 
 
 def parse_oss_name_version_in_filename(name):

fosslight_dependency/package_manager/Helm.py

@@ -12,6 +12,8 @@ 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_util.download import extract_compressed_dir
+from fosslight_dependency.dependency_item import DependencyItem
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -62,7 +64,6 @@ class Helm(PackageManager):
 
     def parse_oss_information(self, f_name):
         dep_item_list = []
-        sheet_list = []
         _dependencies = 'dependencies'
 
         with open(f_name, 'r', encoding='utf8') as yaml_fp:
@@ -73,33 +74,33 @@ class Helm(PackageManager):
         for dep in dep_item_list:
             try:
                 f_path = os.path.join(self.tmp_charts_dir, dep, f_name)
-                purl = ''
+                dep_item = DependencyItem()
+                oss_item = OssItem()
                 with open(f_path, 'r', encoding='utf8') as yaml_fp:
                     yaml_f = yaml.safe_load(yaml_fp)
-                    oss_name = f'{self.package_manager_name}:{yaml_f["name"]}'
-                    oss_version = yaml_f.get('version', '')
-                    if oss_version.startswith('v'):
-                        oss_version = oss_version[1:]
+                    oss_item.name = f'{self.package_manager_name}:{yaml_f["name"]}'
+                    oss_item.version = yaml_f.get('version', '')
+                    if oss_item.version.startswith('v'):
+                        oss_item.version = oss_item.version[1:]
 
-                    homepage = yaml_f.get('home', '')
-                    dn_loc = ''
+                    oss_item.homepage = yaml_f.get('home', '')
                     if yaml_f.get('sources', '') != '':
-                        dn_loc = yaml_f.get('sources', '')[0]
+                        oss_item.download_location = yaml_f.get('sources', '')[0]
 
-                    purl = get_url_to_purl(dn_loc if dn_loc else homepage, self.package_manager_name)
+                    dep_item.purl = get_url_to_purl(
+                        oss_item.download_location if oss_item.download_location else oss_item.homepage,
+                        self.package_manager_name
+                    )
 
-                    license_name = ''
                     if yaml_f.get('annotations', '') != '':
-                        license_name = yaml_f['annotations'].get('licenses', '')
+                        oss_item.license = yaml_f['annotations'].get('licenses', '')
 
                     if self.direct_dep:
-                        comment = 'direct'
+                        oss_item.comment = 'direct'
 
             except Exception as e:
                 logging.warning(f"Fail to parse chart info {dep}: {e}")
                 continue
-
-            sheet_list.append([purl, oss_name, oss_version, license_name, dn_loc, homepage,
-                              '', '', comment, ''])
-
-        return sheet_list
+            dep_item.oss_items.append(oss_item)
+            self.dep_items.append(dep_item)
+        return

fosslight_dependency/package_manager/Maven.py

@@ -14,6 +14,8 @@ 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.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -212,21 +214,21 @@ class Maven(PackageManager):
 
         root = tree.getroot()
         dependencies = root.find("dependencies")
-
-        sheet_list = []
-        comment = ''
+        purl_dict = {}
 
         for d in dependencies.iter("dependency"):
+            dep_item = DependencyItem()
+            oss_item = OssItem()
             groupid = d.findtext("groupId")
             artifactid = d.findtext("artifactId")
             version = d.findtext("version")
-            oss_version = version_refine(version)
+            oss_item.version = version_refine(version)
 
-            oss_name = f"{groupid}:{artifactid}"
-            dn_loc = f"{self.dn_url}{groupid}/{artifactid}/{version}"
-            homepage = f"{self.dn_url}{groupid}/{artifactid}"
-            purl = get_url_to_purl(dn_loc, self.package_manager_name)
-            self.purl_dict[f'{oss_name}({oss_version})'] = purl
+            oss_item.name = f"{groupid}:{artifactid}"
+            oss_item.download_location = f"{self.dn_url}{groupid}/{artifactid}/{version}"
+            oss_item.homepage = f"{self.dn_url}{groupid}/{artifactid}"
+            dep_item.purl = get_url_to_purl(oss_item.download_location, self.package_manager_name)
+            purl_dict[f'{oss_item.name}({oss_item.version})'] = dep_item.purl
 
             licenses = d.find("licenses")
             if len(licenses):
@@ -234,26 +236,24 @@ class Maven(PackageManager):
                 for key_license in licenses.iter("license"):
                     if key_license.findtext("name") is not None:
                         license_names.append(key_license.findtext("name").replace(",", ""))
-                license_name = ', '.join(license_names)
-            else:
-                # Case that doesn't include License tag value.
-                license_name = ''
+                oss_item.license = ', '.join(license_names)
+
+            dep_key = f"{oss_item.name}({version})"
 
-            dep_key = f"{oss_name}({version})"
-            comment_list = []
-            deps_list = []
             if self.direct_dep:
                 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)
-        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

fosslight_dependency/package_manager/Npm.py

@@ -12,6 +12,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)
 node_modules = 'node_modules'
@@ -148,25 +150,25 @@ class Npm(PackageManager):
         with open(f_name, 'r', encoding='utf8') as json_file:
             json_data = json.load(json_file)
 
-        sheet_list = []
-        comment = ''
         _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_name = self.package_manager_name + ":" + oss_init_name
+            oss_item.name = self.package_manager_name + ":" + oss_init_name
 
             if d[_licenses]:
                 license_name = d[_licenses]
             else:
                 license_name = ''
 
-            oss_version = d['version']
+            oss_item.version = d['version']
             package_path = d['path']
 
             private_pkg = False
@@ -174,45 +176,48 @@ class Npm(PackageManager):
                 if d[_private]:
                     private_pkg = True
 
-            homepage = self.dn_url + oss_init_name
-            dn_loc = f"{self.dn_url}{oss_init_name}/v/{oss_version}"
-            purl = get_url_to_purl(dn_loc, self.package_manager_name)
-            self.purl_dict[f'{oss_init_name}({oss_version})'] = purl
+            oss_item.homepage = self.dn_url + oss_init_name
+            dn_loc = f"{self.dn_url}{oss_init_name}/v/{oss_item.version}"
+            dep_item.purl = get_url_to_purl(dn_loc, 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 = ''
 
-            comment_list = []
-            deps_list = []
+            oss_item.download_location = dn_loc
+
             if private_pkg:
-                homepage = dn_loc
-                comment_list.append('private')
-            if self.package_name == f'{oss_init_name}({oss_version})':
-                comment_list.append('root package')
+                oss_item.homepage = oss_item.download_location
+                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_version})' in self.relation_tree[self.package_name]:
-                    comment_list.append('direct')
+                if f'{oss_init_name}({oss_item.version})' in self.relation_tree[self.package_name]:
+                    oss_item.comment = 'direct'
                 else:
-                    comment_list.append('transitive')
+                    oss_item.comment = 'transitive'
 
-                if f'{oss_init_name}({oss_version})' in self.relation_tree:
-                    deps_list.extend(self.relation_tree[f'{oss_init_name}({oss_version})'])
+                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})']
 
             manifest_file_path = os.path.join(package_path, const.SUPPORT_PACKAE.get(self.package_manager_name))
             multi_license, license_comment, multi_flag = check_multi_license(license_name, manifest_file_path)
 
-            comment = ','.join(comment_list)
             if multi_flag:
-                comment = f'{comment}, {license_comment}'
+                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)
-            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
+            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 check_multi_license(license_name, manifest_file_path):

fosslight_dependency/package_manager/Nuget.py

@@ -13,6 +13,8 @@ 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.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -37,7 +39,7 @@ class Nuget(PackageManager):
     def parse_oss_information(self, f_name):
         tmp_license_txt_file_name = 'tmp_license.txt'
         with open(f_name, 'r', encoding='utf8') as input_fp:
-            sheet_list = []
+            purl_dict = {}
             package_list = []
             if self.packageReference:
                 package_list = self.get_package_info_in_packagereference(input_fp)
@@ -46,14 +48,13 @@ class Nuget(PackageManager):
 
         for oss_origin_name, oss_version in package_list:
             try:
-                oss_name = f'{self.package_manager_name}:{oss_origin_name}'
+                dep_item = DependencyItem()
+                oss_item = OssItem()
+                oss_item.name = f'{self.package_manager_name}:{oss_origin_name}'
+                oss_item.version = oss_version
 
-                comment_list = []
-                dn_loc = ''
-                homepage = ''
                 license_name = ''
-
-                response = requests.get(f'{self.nuget_api_url}{oss_origin_name}/{oss_version}/{oss_origin_name}.nuspec')
+                response = requests.get(f'{self.nuget_api_url}{oss_origin_name}/{oss_item.version}/{oss_origin_name}.nuspec')
                 if response.status_code == 200:
                     root = fromstring(response.text)
                     xmlns = ''
@@ -66,7 +67,7 @@ class Nuget(PackageManager):
                     if license_name_id is not None:
                         license_name, license_comment = self.check_multi_license(license_name_id.text)
                         if license_comment != '':
-                            comment_list.append(license_comment)
+                            oss_item.comment = license_comment
                     else:
                         license_url = nupkg_metadata.find(f'{xmlns}licenseUrl')
                         if license_url is not None:
@@ -82,45 +83,47 @@ class Nuget(PackageManager):
                                     license_name = license_name_with_license_scanner
                                 else:
                                     license_name = license_url.text
+                    oss_item.license = license_name
                     repo_id = nupkg_metadata.find(f'{xmlns}repository')
                     if repo_id is not None:
-                        dn_loc = repo_id.get("url")
+                        oss_item.download_location = repo_id.get("url")
                     else:
                         proj_url_id = nupkg_metadata.find(f'{xmlns}projectUrl')
                         if proj_url_id is not None:
-                            dn_loc = proj_url_id.text
-                    homepage = f'{self.dn_url}{oss_origin_name}'
-                    if dn_loc == '':
-                        dn_loc = f'{homepage}/{oss_version}'
+                            oss_item.download_location = proj_url_id.text
+                    oss_item.homepage = f'{self.dn_url}{oss_origin_name}'
+                    if oss_item.download_location == '':
+                        oss_item.download_location = f'{oss_item.homepage}/{oss_item.version}'
                     else:
-                        if dn_loc.endswith('.git'):
-                            dn_loc = dn_loc[:-4]
-                    purl = get_url_to_purl(f'{homepage}/{oss_version}', self.package_manager_name)
+                        if oss_item.download_location.endswith('.git'):
+                            oss_item.download_location = oss_item.download_location[:-4]
+                    dep_item.purl = get_url_to_purl(f'{oss_item.homepage}/{oss_item.version}', self.package_manager_name)
                 else:
-                    comment_list.append('Fail to response for nuget api')
-                    purl = f'pkg:nuget/{oss_origin_name}@{oss_version}'
-                self.purl_dict[f'{oss_origin_name}({oss_version})'] = purl
+                    oss_item.comment = 'Fail to response for nuget api'
+                    dep_item.purl = f'pkg:nuget/{oss_origin_name}@{oss_item.version}'
+                purl_dict[f'{oss_origin_name}({oss_item.version})'] = dep_item.purl
 
-                deps_list = []
                 if self.direct_dep and self.packageReference:
                     if oss_origin_name in self.direct_dep_list:
-                        comment_list.append('direct')
+                        oss_item.comment = 'direct'
                     else:
-                        comment_list.append('transitive')
+                        oss_item.comment = 'transitive'
 
-                    if f'{oss_origin_name}({oss_version})' in self.relation_tree:
-                        deps_list.extend(self.relation_tree[f'{oss_origin_name}({oss_version})'])
+                    if f'{oss_origin_name}({oss_item.version})' in self.relation_tree:
+                        dep_item.depends_on_raw = self.relation_tree[f'{oss_origin_name}({oss_item.version})']
 
-                comment = ','.join(comment_list)
-                sheet_list.append([purl, oss_name, 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"Failed to parse oss information: {e}")
-        sheet_list = self.change_dep_to_purl(sheet_list)
+        if self.direct_dep:
+            self.dep_items = change_dependson_to_purl(purl_dict, self.dep_items)
+
         if os.path.isfile(tmp_license_txt_file_name):
             os.remove(tmp_license_txt_file_name)
 
-        return sheet_list
+        return
 
     def get_package_list_in_packages_config(self, input_fp):
         package_list = []

fosslight_dependency/package_manager/Pub.py

@@ -14,6 +14,8 @@ 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.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
 
 logger = logging.getLogger(constant.LOGGER_NAME)
 
@@ -104,28 +106,29 @@ class Pub(PackageManager):
     def parse_oss_information(self, f_name):
         tmp_license_txt_file_name = 'tmp_license.txt'
         json_data = ''
-        comment = ''
 
         with open(f_name, 'r', encoding='utf8') as pub_file:
             json_f = json.load(pub_file)
 
         try:
-            sheet_list = []
+            purl_dict = {}
 
             for json_data in json_f:
+                dep_item = DependencyItem()
+                oss_item = OssItem()
                 oss_origin_name = json_data['name']
                 if oss_origin_name not in self.total_dep_list:
                     continue
-                oss_name = f"{self.package_manager_name}:{oss_origin_name}"
-                oss_version = json_data['version']
-                homepage = json_data['homepage']
-                if homepage is None:
-                    homepage = json_data['repository']
-                if homepage is None:
-                    homepage = ''
-                dn_loc = f"{self.dn_url}{oss_origin_name}/versions/{oss_version}"
-                purl = get_url_to_purl(dn_loc, self.package_manager_name)
-                self.purl_dict[f'{oss_origin_name}({oss_version})'] = purl
+                oss_item.name = f"{self.package_manager_name}:{oss_origin_name}"
+                oss_item.version = json_data['version']
+                oss_item.homepage = json_data['homepage']
+                if oss_item.homepage is None:
+                    oss_item.homepage = json_data['repository']
+                if oss_item.homepage is None:
+                    oss_item.homepage = ''
+                oss_item.download_location = f"{self.dn_url}{oss_origin_name}/versions/{oss_item.version}"
+                dep_item.purl = get_url_to_purl(oss_item.download_location, self.package_manager_name)
+                purl_dict[f'{oss_origin_name}({oss_item.version})'] = dep_item.purl
                 license_txt = json_data['license']
 
                 tmp_license_txt = open(tmp_license_txt_file_name, 'w', encoding='utf-8')
@@ -137,36 +140,33 @@ class Pub(PackageManager):
                                                                                   tmp_license_txt_file_name)
 
                 if license_name_with_license_scanner != "":
-                    license_name = license_name_with_license_scanner
-                else:
-                    license_name = ''
+                    oss_item.license = license_name_with_license_scanner
 
-                comment_list = []
-                deps_list = []
                 if self.direct_dep:
                     if oss_origin_name not in self.total_dep_list:
                         continue
-                    if self.package_name == f'{oss_origin_name}({oss_version})':
-                        comment_list.append('root package')
+                    if self.package_name == f'{oss_origin_name}({oss_item.version})':
+                        oss_item.comment = 'root package'
                     else:
                         if json_data['isDirectDependency']:
-                            comment_list.append('direct')
+                            oss_item.comment = 'direct'
                         else:
-                            comment_list.append('transitive')
+                            oss_item.comment = 'transitive'
+
+                    if f'{oss_origin_name}({oss_item.version})' in self.relation_tree:
+                        dep_item.depends_on_raw = self.relation_tree[f'{oss_origin_name}({oss_item.version})']
 
-                    if f'{oss_origin_name}({oss_version})' in self.relation_tree:
-                        deps_list.extend(self.relation_tree[f'{oss_origin_name}({oss_version})'])
-                comment = ','.join(comment_list)
-                sheet_list.append([purl, oss_name, 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.error(f"Fail to parse pub oss information: {e}")
-        sheet_list = self.change_dep_to_purl(sheet_list)
+        if self.direct_dep:
+            self.dep_items = change_dependson_to_purl(purl_dict, self.dep_items)
 
         if os.path.isfile(tmp_license_txt_file_name):
             os.remove(tmp_license_txt_file_name)
 
-        return sheet_list
+        return
 
     def parse_no_dev_command_file(self, pub_deps):
         for line in pub_deps.split('\n'):