Merge pull request #78 from fosslight/develop

Apply f-string format

Author: dd-jy

src/fosslight_dependency/_analyze_dependency.py

@@ -47,7 +47,7 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
     elif package_manager_name == const.GO:
         package_manager = Go(input_dir, output_dir)
     else:
-        logger.error("Not supported package manager name: " + package_manager_name)
+        logger.error(f"Not supported package manager name: {package_manager_name}")
         ret = False
         return ret, package_sheet_list
 
@@ -56,17 +56,17 @@ def analyze_dependency(package_manager_name, input_dir, output_dir, pip_activate
     ret = package_manager.run_plugin()
     if ret:
         for f_name in package_manager.input_package_list_file:
-            logger.info("Parse oss information with file: " + str(f_name))
+            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))
             else:
-                logger.error('Failed to open input file:' + str(f_name))
+                logger.error(f"Failed to open input file: {f_name}")
                 ret = False
 
     if ret:
-        logger.warning("### Complete to analyze: " + package_manager_name)
+        logger.warning(f"### Complete to analyze: {package_manager_name}")
     else:
-        logger.error("### Fail to analyze: " + package_manager_name)
+        logger.error(f"### Fail to analyze: {package_manager_name}")
 
     return ret, package_sheet_list

src/fosslight_dependency/_package_manager.py

@@ -40,7 +40,7 @@ def __init__(self, package_manager_name, dn_url, input_dir, output_dir):
         self.license_scanner_bin = check_license_scanner(self.platform)
 
     def run_plugin(self):
-        logger.info('This package manager(' + self.package_manager_name + ') skips the step to run plugin.')
+        logger.info(f"This package manager({self.package_manager_name}) skips the step to run plugin.")
         return True
 
     def append_input_package_list_file(self, input_package_file):
@@ -140,11 +140,11 @@ def check_and_run_license_scanner(platform, license_scanner_bin, file_dir):
             license_name = ""
         else:
             if platform == const.LINUX:
-                run_license_scanner = license_scanner_bin + " " + file_dir + " > " + tmp_output_file_name
+                run_license_scanner = f"{license_scanner_bin} {file_dir} > {tmp_output_file_name}"
             elif platform == const.MACOS:
-                run_license_scanner = license_scanner_bin + " identify " + file_dir + " > " + tmp_output_file_name
+                run_license_scanner = f"{license_scanner_bin} identify {file_dir} > {tmp_output_file_name}"
             elif platform == const.WINDOWS:
-                run_license_scanner = license_scanner_bin + " identify " + file_dir + " > " + tmp_output_file_name
+                run_license_scanner = f"{license_scanner_bin} identify {file_dir} > {tmp_output_file_name}"
             else:
                 run_license_scanner = ''
 
@@ -175,7 +175,7 @@ def check_and_run_license_scanner(platform, license_scanner_bin, file_dir):
                 license_name = ""
 
     except Exception as ex:
-        logger.error("Failed to run license scan binary." + str(ex))
+        logger.error(f"Failed to run license scan binary. {ex}")
         license_name = ""
 
     return license_name

src/fosslight_dependency/package_manager/Carthage.py

@@ -86,14 +86,14 @@ def parse_oss_information(self, f_name):
                                     g = connect_github(self.github_token)
                                 license_name = get_github_license(g, oss_path, self.platform, self.license_scanner_bin)
                             except Exception as e:
-                                logger.warning("Failed to get license with github api:" + str(e))
+                                logger.warning(f"Failed to get license with github api: {e}")
                                 license_name == ''
 
                     sheet_list.append([const.SUPPORT_PACKAE.get(self.package_manager_name),
                                       oss_name, oss_version, license_name, dn_loc, homepage, '', '', ''])
 
                 except Exception as e:
-                    logger.warning("Failed to parse oss information:" + str(e))
+                    logger.warning(f"Failed to parse oss information: {e}")
 
         return sheet_list
 

src/fosslight_dependency/package_manager/Cocoapods.py

@@ -78,14 +78,14 @@ def parse_oss_information(self, f_name):
                     search_oss_name = ""
                     for alphabet_oss in pod_oss[0]:
                         if not alphabet_oss.isalnum():
-                            search_oss_name += "\\\\" + alphabet_oss
+                            search_oss_name += f"\\\\{alphabet_oss}"
                         else:
                             search_oss_name += alphabet_oss
 
-                    command = 'pod spec which --regex ' + '^' + search_oss_name + '$'
+                    command = f"pod spec which --regex ^{search_oss_name}$"
                     spec_which = os.popen(command).readline()
                     if spec_which.startswith('[!]'):
-                        logger.error("This command(" + command + ") returns an error")
+                        logger.error(f"This command({command}) returns an error")
                         return ''
 
                     file_path = spec_which.rstrip().split(os.path.sep)
@@ -100,7 +100,7 @@ def parse_oss_information(self, f_name):
                 sheet_list.append([const.SUPPORT_PACKAE.get(self.package_manager_name),
                                   oss_name, oss_version, license_name, dn_loc, homepage, '', '', ''])
             except Exception as e:
-                logger.warning('It failed to get ' + pod_oss[0] + ': ' + str(e))
+                logger.warning(f"It failed to get {pod_oss[0]}:{e}")
                 logger.warning(traceback.format_exc())
 
         return sheet_list
@@ -110,9 +110,9 @@ def get_oss_in_podspec(self, spec_file_path):
             json_data = json.load(json_file)
 
             oss_origin_name = json_data['name']
-            oss_name = self.package_manager_name + ":" + oss_origin_name
+            oss_name = f"{self.package_manager_name}:{oss_origin_name}"
             oss_version = json_data['version']
-            homepage = self.dn_url + 'pods/' + oss_origin_name
+            homepage = f"{self.dn_url}pods/{oss_origin_name}"
 
             if not isinstance(json_data['license'], str):
                 if 'type' in json_data['license']:

src/fosslight_dependency/package_manager/Go.py

@@ -35,11 +35,11 @@ def run_plugin(self):
         ret = True
 
         logger.info("Execute 'go list -m all' to obtain package info.")
-        cmd = "go list -m all > " + self.tmp_file_name
+        cmd = f"go list -m all > {self.tmp_file_name}"
 
         ret_cmd = subprocess.call(cmd, shell=True)
         if ret_cmd != 0:
-            logger.error("Failed to make the result: " + cmd)
+            logger.error(f"Failed to make the result: {cmd}")
             ret = False
 
         self.append_input_package_list_file(self.tmp_file_name)
@@ -54,12 +54,12 @@ def parse_oss_information(self, f_name):
                 re_result = re.findall(r'(\S+)\s?(\S*)', line)
                 try:
                     package_path = re_result[0][0]
-                    oss_name = self.package_manager_name + ":" + package_path
+                    oss_name = f"{self.package_manager_name}:{package_path}"
                     oss_version = re_result[0][1]
 
                     tmp_dn_loc = self.dn_url + package_path
                     if oss_version:
-                        dn_loc = tmp_dn_loc + '@' + oss_version
+                        dn_loc = f"{tmp_dn_loc}@{oss_version}"
                     else:
                         dn_loc = tmp_dn_loc
 
@@ -74,9 +74,8 @@ def parse_oss_information(self, f_name):
                                 urlopen_success = True
                                 if dn_loc_i == tmp_dn_loc:
                                     if oss_version:
-                                        comment = 'Cannot connect ' \
-                                                  + dn_loc \
-                                                  + ', so use the latest version page to get the license, homepage.'
+                                        comment = f'Cannot connect {dn_loc}, \
+                                                    so use the latest version page to get the license, homepage.'
                                     dn_loc = tmp_dn_loc
                                 break
                         except Exception:
@@ -95,7 +94,7 @@ def parse_oss_information(self, f_name):
                             homepage = repository_data.find('a')['href']
 
                 except Exception as e:
-                    logging.warning("Fail to parse " + line + ": " + str(e))
+                    logging.warning(f"Fail to parse {line} : {e}")
                     continue
 
                 sheet_list.append([const.SUPPORT_PACKAE.get(self.package_manager_name),

src/fosslight_dependency/package_manager/Gradle.py

@@ -46,7 +46,7 @@ def parse_oss_information(self, f_name):
 
             if name != filename:
                 group_id, artifact_id, oss_ini_version = parse_oss_name_version_in_artifactid(name)
-                oss_name = group_id + ":" + artifact_id
+                oss_name = f"{group_id}:{artifact_id}"
             else:
                 oss_name, oss_ini_version = parse_oss_name_version_in_filename(filename)
                 used_filename = True
@@ -67,8 +67,8 @@ def parse_oss_information(self, f_name):
                 homepage = ''
 
             else:
-                dn_loc = self.dn_url + group_id + "/" + artifact_id + "/" + oss_ini_version
-                homepage = self.dn_url + group_id + "/" + artifact_id
+                dn_loc = f"{self.dn_url}{group_id}/{artifact_id}/{oss_ini_version}"
+                homepage = f"{self.dn_url}{group_id}/{artifact_id}"
 
             sheet_list.append([const.SUPPORT_PACKAE.get(self.package_manager_name),
                               oss_name, oss_version, license_name, dn_loc, homepage, '', '', ''])

src/fosslight_dependency/package_manager/Maven.py

@@ -62,7 +62,7 @@ def add_plugin_in_pom(self, pom_backup):
 
         manifest_file = const.SUPPORT_PACKAE.get(self.package_manager_name)
         if os.path.isfile(manifest_file) != 1:
-            logger.error(manifest_file + " is not existed in this directory.")
+            logger.error(f"{manifest_file} is not existed in this directory.")
             return ret
 
         try:
@@ -87,7 +87,7 @@ def add_plugin_in_pom(self, pom_backup):
 
             tmp_plugin = bs(license_maven_plugin, xml)
 
-            license_maven_plugins = '<plugins>' + license_maven_plugin + '<plugins>'
+            license_maven_plugins = f"<plugins>{license_maven_plugin}<plugins>"
             tmp_plugins = bs(license_maven_plugins, xml)
 
             with open(pom_backup, 'r', encoding='utf8') as f:
@@ -105,7 +105,7 @@ def add_plugin_in_pom(self, pom_backup):
                         ret = True
         except Exception as e:
             ret = False
-            logger.error('Failed to add plugin in pom' + str(e))
+            logger.error(f"Failed to add plugin in pom : {e}")
 
         if ret:
             with open(manifest_file, "w", encoding='utf8') as f_w:
@@ -139,16 +139,16 @@ def run_maven_plugin(self):
                 cmd_mvn = "./mvnw"
         else:
             cmd_mvn = "mvn"
-        cmd = cmd_mvn + " license:aggregate-download-licenses"
+        cmd = f"{cmd_mvn} license:aggregate-download-licenses"
 
         ret = subprocess.call(cmd, shell=True)
         if ret != 0:
-            logger.error("Failed to run maven plugin: " + cmd)
+            logger.error(f"Failed to run maven plugin: {cmd}")
 
-        cmd = cmd_mvn + " dependency:tree > " + dependency_tree_fname
+        cmd = f"{cmd_mvn} dependency:tree > {dependency_tree_fname}"
         ret = subprocess.call(cmd, shell=True)
         if ret != 0:
-            logger.error("Failed to run: " + cmd)
+            logger.error(f"Failed to run: {cmd}")
         else:
             self.parse_dependency_tree(dependency_tree_fname)
             os.remove(dependency_tree_fname)
@@ -162,7 +162,7 @@ def parse_dependency_tree(self, f_name):
                         dependency_key = re_result[0][0] + ':' + re_result[0][1]
                         self.dependency_tree[dependency_key] = re_result[0][2]
                 except Exception as e:
-                    logger.error("Failed to parse dependency tree: " + str(e))
+                    logger.error(f"Failed to parse dependency tree: {e}")
 
     def parse_oss_information(self, f_name):
         with open(f_name, 'r', encoding='utf8') as input_fp:
@@ -179,9 +179,9 @@ def parse_oss_information(self, f_name):
             version = d.findtext("version")
             oss_version = version_refine(version)
 
-            oss_name = groupid + ":" + artifactid
-            dn_loc = self.dn_url + groupid + "/" + artifactid + "/" + version
-            homepage = self.dn_url + groupid + "/" + artifactid
+            oss_name = f"{groupid}:{artifactid}"
+            dn_loc = f"{self.dn_url}{groupid}/{artifactid}/{version}"
+            homepage = f"{self.dn_url}{groupid}/{artifactid}"
 
             licenses = d.find("licenses")
             if len(licenses):
@@ -196,11 +196,11 @@ def parse_oss_information(self, f_name):
 
             try:
                 comment = ''
-                dependency_tree_key = oss_name + ':' + version
+                dependency_tree_key = f"{oss_name}:{version}"
                 if dependency_tree_key in self.dependency_tree.keys():
                     comment = self.dependency_tree[dependency_tree_key]
             except Exception as e:
-                logger.error("Fail to find oss scope in dependency tree: " + str(e))
+                logger.error(f"Fail to find oss scope in dependency tree: {e}")
 
             sheet_list.append([const.SUPPORT_PACKAE.get(self.package_manager_name),
                               oss_name, oss_version, license_name, dn_loc, homepage, '', '', comment])

src/fosslight_dependency/package_manager/Npm.py

@@ -36,7 +36,7 @@ def start_license_checker(self):
         ret = True
         tmp_custom_json = 'custom.json'
         flag_tmp_node_modules = False
-        license_checker_cmd = 'license-checker --production --json --out ' + self.input_file_name
+        license_checker_cmd = f'license-checker --production --json --out {self.input_file_name}'
         custom_path_option = ' --customPath '
         node_modules = 'node_modules'
         npm_install_cmd = 'npm install --prod'
@@ -46,7 +46,7 @@ def start_license_checker(self):
             flag_tmp_node_modules = True
             cmd_ret = subprocess.call(npm_install_cmd, shell=True)
             if cmd_ret != 0:
-                logger.error(npm_install_cmd + " returns an error")
+                logger.error(f"{npm_install_cmd} returns an error")
                 return False
 
         # customized json file for obtaining specific items with license-checker
@@ -55,7 +55,7 @@ def start_license_checker(self):
         cmd = license_checker_cmd + custom_path_option + tmp_custom_json
         cmd_ret = subprocess.call(cmd, shell=True)
         if cmd_ret != 0:
-            logger.error("It returns the error: " + cmd)
+            logger.error(f"It returns the error: {cmd}")
             logger.error("Please check if the license-checker is installed.(sudo npm install -g license-checker)")
             return False
         else:
@@ -96,7 +96,7 @@ def parse_oss_information(self, f_name):
             if d['repository']:
                 dn_loc = d['repository']
             else:
-                dn_loc = self.dn_url + oss_init_name + '/v/' + oss_version
+                dn_loc = f"{self.dn_url}{oss_init_name}/v/{oss_version}"
 
             homepage = self.dn_url + oss_init_name
 

src/fosslight_dependency/package_manager/Pub.py

@@ -39,10 +39,10 @@ def parse_oss_information(self, f_name):
 
             for key in json_data:
                 oss_origin_name = json_data[key]['name']
-                oss_name = self.package_manager_name + ":" + oss_origin_name
+                oss_name = f"{self.package_manager_name}:{oss_origin_name}"
                 oss_version = json_data[key]['version']
                 homepage = json_data[key]['homepage']
-                dn_loc = self.dn_url + oss_origin_name + "/versions/" + oss_version
+                dn_loc = f"{self.dn_url}{oss_origin_name}/versions/{oss_version}"
                 license_txt = json_data[key]['license']
 
                 tmp_license_txt = open(tmp_license_txt_file_name, 'w', encoding='utf-8')
@@ -62,7 +62,7 @@ def parse_oss_information(self, f_name):
                                   oss_name, oss_version, license_name, dn_loc, homepage, '', '', ''])
 
         except Exception as e:
-            logger.error("Fail to parse pub oss information: " + str(e))
+            logger.error(f"Fail to parse pub oss information: {e}")
 
         if os.path.isfile(tmp_license_txt_file_name):
             os.remove(tmp_license_txt_file_name)