fosslight-dependency 3.0.7__py3-none-any.whl → 4.1.30__py3-none-any.whl

fosslight_dependency/cli.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2020 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import sys
+import argparse
+import shutil
+import fosslight_dependency.constant as const
+from fosslight_dependency._help import print_version, print_help_msg
+from fosslight_dependency.run_dependency_scanner import run_dependency_scanner, _PKG_NAME
+
+
+def get_terminal_size():
+    size = shutil.get_terminal_size()
+    return size.lines
+
+
+def paginate_file(file_path):
+    lines_per_page = get_terminal_size() - 1
+    with open(file_path, 'r', encoding='utf8') as file:
+        lines = file.readlines()
+
+    for i in range(0, len(lines), lines_per_page):
+        os.system('clear' if os.name == 'posix' else 'cls')
+        print(''.join(lines[i: i + lines_per_page]))
+        if i + lines_per_page < len(lines):
+            input("Press Enter to see the next page...")
+
+
+def main():
+    package_manager = ''
+    input_dir = ''
+    output_dir = ''
+    path_to_exclude = []
+    pip_activate_cmd = ''
+    pip_deactivate_cmd = ''
+    output_custom_dir = ''
+    app_name = const.default_app_name
+    github_token = ''
+    format = []
+    graph_path = ''
+    graph_size = (600, 600)
+    direct = True
+    recursive = False
+
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument('-h', '--help', action='store_true', required=False)
+    parser.add_argument('-v', '--version', action='store_true', required=False)
+    parser.add_argument('-m', '--manager', nargs=1, type=str, default='', required=False)
+    parser.add_argument('-p', '--path', nargs=1, type=str, required=False)
+    parser.add_argument('-e', '--exclude', nargs='*', required=False, default=[])
+    parser.add_argument('-o', '--output', nargs=1, type=str, required=False)
+    parser.add_argument('-a', '--activate', nargs=1, type=str, default='', required=False)
+    parser.add_argument('-d', '--deactivate', nargs=1, type=str, default='', required=False)
+    parser.add_argument('-c', '--customized', nargs=1, type=str, required=False)
+    parser.add_argument('-n', '--appname', nargs=1, type=str, required=False)
+    parser.add_argument('-t', '--token', nargs=1, type=str, required=False)
+    parser.add_argument('-f', '--format', nargs="*", type=str, required=False)
+    parser.add_argument('--graph-path', nargs=1, type=str, required=False)
+    parser.add_argument('--graph-size', nargs=2, type=int, metavar=("WIDTH", "HEIGHT"), required=False)
+    parser.add_argument('--direct', choices=('true', 'false'), default='True', required=False)
+    parser.add_argument('--notice', action='store_true', required=False)
+    parser.add_argument('-r', '--recursive', action='store_true', required=False)
+
+    args = parser.parse_args()
+
+    if args.help:  # -h option
+        print_help_msg()
+
+    if args.version:  # -v option
+        print_version(_PKG_NAME)
+
+    if args.manager:  # -m option
+        package_manager = ''.join(args.manager)
+    if args.path:  # -p option
+        input_dir = ''.join(args.path)
+    if args.exclude:  # -e option
+        path_to_exclude = args.exclude
+    if args.output:  # -o option
+        output_dir = ''.join(args.output)
+    if args.activate:  # -a option
+        pip_activate_cmd = ''.join(args.activate)
+    if args.deactivate:  # -d option
+        pip_deactivate_cmd = ''.join(args.deactivate)
+    if args.customized:  # -c option
+        output_custom_dir = ''.join(args.customized)
+    if args.appname:  # -n option
+        app_name = ''.join(args.appname)
+    if args.token:  # -t option
+        github_token = ''.join(args.token)
+    if args.format:  # -f option
+        format = list(args.format)
+    if args.graph_path:
+        graph_path = ''.join(args.graph_path)
+    if args.graph_size:
+        graph_size = args.graph_size
+    if args.direct:  # --direct option
+        if args.direct == 'true' or args.direct == 'True':
+            direct = True
+        elif args.direct == 'false' or args.direct == 'False':
+            direct = False
+    if args.notice:  # --notice option
+        try:
+            base_path = sys._MEIPASS
+        except Exception:
+            base_path = os.path.dirname(__file__)
+
+        data_path = os.path.join(base_path, 'LICENSES')
+        print(f"*** {_PKG_NAME} open source license notice ***")
+        for ff in os.listdir(data_path):
+            source_file = os.path.join(data_path, ff)
+            destination_file = os.path.join(base_path, ff)
+            paginate_file(source_file)
+            shutil.copyfile(source_file, destination_file)
+        sys.exit(0)
+    if args.recursive:  # -r option
+        recursive = True
+
+    run_dependency_scanner(package_manager, input_dir, output_dir, pip_activate_cmd, pip_deactivate_cmd,
+                           output_custom_dir, app_name, github_token, format, direct, path_to_exclude,
+                           graph_path, graph_size, recursive)
+
+
+if __name__ == '__main__':
+    main()

fosslight_dependency/constant.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+import os
+
+# System platform name
+WINDOWS = 'Windows'
+LINUX = 'Linux'
+MACOS = 'Darwin'
+
+# Package manager name
+PYPI = 'pypi'
+NPM = 'npm'
+MAVEN = 'maven'
+GRADLE = 'gradle'
+PUB = 'pub'
+COCOAPODS = 'cocoapods'
+ANDROID = 'android'
+SWIFT = 'swift'
+CARTHAGE = 'carthage'
+GO = 'go'
+NUGET = 'nuget'
+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',
+    COCOAPODS: 'Podfile.lock',
+    ANDROID: 'build.gradle',
+    SWIFT: 'Package.resolved',
+    CARTHAGE: 'Cartfile.resolved',
+    GO: 'go.mod',
+    NUGET: ['packages.config', os.path.join('obj', 'project.assets.json'), 'Directory.Packages.props'],
+    HELM: 'Chart.yaml',
+    UNITY: os.path.join('Library', 'PackageManager', 'ProjectCache'),
+    CARGO: 'Cargo.toml'
+}
+
+SUGGESTED_PACKAGE = {
+    'Podfile': COCOAPODS,
+    'Package.swift': SWIFT,
+    'Cartfile': CARTHAGE
+}
+
+# default android app name
+default_app_name = 'app'

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

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+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.get_pom_license import get_license_from_pom
+from fosslight_util.oss_item import OssItem
+
+logger = logging.getLogger(constant.LOGGER_NAME)
+
+
+class Android(PackageManager):
+    package_manager_name = const.ANDROID
+
+    plugin_output_file = 'android_dependency_output.txt'
+    app_name = const.default_app_name
+    input_file_name = ''
+    plugin_auto_run = False
+
+    def __init__(self, input_dir, output_dir, app_name):
+        super().__init__(self.package_manager_name, '', input_dir, output_dir)
+        if app_name:
+            self.app_name = app_name
+        self.input_file_name = self.check_input_path()
+        self.append_input_package_list_file(self.input_file_name)
+
+    def __del__(self):
+        if self.plugin_auto_run:
+            if os.path.isfile(self.input_file_name):
+                os.remove(self.input_file_name)
+
+    def check_input_path(self):
+        if os.path.isfile(self.plugin_output_file):
+            return self.plugin_output_file
+        else:
+            return os.path.join(self.app_name, self.plugin_output_file)
+
+    def parse_oss_information(self, f_name):
+        with open(f_name, 'r', encoding='utf8') as input_fp:
+            purl_dict = {}
+            for i, line in enumerate(input_fp.readlines()):
+                dep_item = DependencyItem()
+                oss_item = OssItem()
+                split_str = line.strip().split("\t")
+                if i < 2:
+                    continue
+
+                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
+                if not oss_item.license:
+                    license_names = get_license_from_pom(oss_item.name.split(':')[0],
+                                                         oss_item.name.split(':')[1],
+                                                         oss_item.version)
+                    if license_names:
+                        oss_item.license = license_names
+
+                dep_item.purl = get_url_to_purl(oss_item.download_location, 'maven')
+                purl_dict[f'{oss_item.name}({oss_item.version})'] = dep_item.purl
+
+                if self.direct_dep:
+                    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:
+                        oss_item.comment = 'direct'
+                    else:
+                        oss_item.comment = 'transitive'
+                    try:
+                        if dep_key in self.relation_tree:
+                            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}")
+
+                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/Cargo.py

@@ -0,0 +1,144 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import logging
+import json
+import re
+import subprocess
+import fosslight_util.constant as constant
+import fosslight_dependency.constant as const
+from fosslight_dependency._package_manager import PackageManager
+from fosslight_dependency._package_manager import get_url_to_purl
+from fosslight_dependency.dependency_item import DependencyItem, change_dependson_to_purl
+from fosslight_util.oss_item import OssItem
+logger = logging.getLogger(constant.LOGGER_NAME)
+
+
+class Cargo(PackageManager):
+    package_manager_name = const.CARGO
+
+    dn_url = 'https://crates.io/crates/'
+    input_file_name = 'tmp_cargo_fosslight_output.json'
+    tmp_input_file_flag = False
+    cur_path = ''
+    cargo_lock_f = 'Cargo.lock'
+
+    def __init__(self, input_dir, output_dir):
+        super().__init__(self.package_manager_name, self.dn_url, input_dir, output_dir)
+        self.append_input_package_list_file(self.input_file_name)
+
+    def __del__(self):
+        if self.tmp_input_file_flag:
+            os.remove(self.input_file_name)
+
+    def run_plugin(self):
+        if os.path.exists(self.input_file_name):
+            logger.info(f"Found {self.input_file_name}, skip the flutter cmd to analyze dependency.")
+            return True
+
+        if not os.path.exists(const.SUPPORT_PACKAE.get(self.package_manager_name)):
+            logger.error(f"Cannot find the file({const.SUPPORT_PACKAE.get(self.package_manager_name)})")
+            return False
+
+        if os.path.exists(self.cargo_lock_f):
+            cmd = f'cargo metadata --locked --format-version 1 > {self.input_file_name}'
+        else:
+            cmd = f'cargo metadata --format-version 1 > {self.input_file_name}'
+        ret = subprocess.call(cmd, shell=True)
+        if ret != 0:
+            logger.error(f"Failed to run: {cmd}")
+            os.chdir(self.cur_path)
+            return False
+        self.tmp_input_file_flag = True
+        return True
+
+    def parse_oss_information(self, f_name):
+        json_data = ''
+
+        with open(f_name, 'r', encoding='utf8') as cargo_file:
+            json_f = json.load(cargo_file)
+        try:
+            purl_dict = {}
+            workspace_members_key = 'workspace_members'
+            resolve_key = 'resolve'
+            root_key = 'root'
+            nodes_key = 'nodes'
+            workspace_members = []
+            root = ''
+            resolve_node = []
+
+            if workspace_members_key in json_f:
+                workspace_members = json_f[workspace_members_key]
+
+            if resolve_key in json_f:
+                if root_key in json_f[resolve_key]:
+                    root = json_f[resolve_key][root_key]
+                if nodes_key in json_f[resolve_key]:
+                    resolve_node = json_f[resolve_key][nodes_key]
+                if root and resolve_node:
+                    self.direct_dep_list.extend(get_matched_dependencies(root, resolve_node))
+            else:
+                self.direct_dep = False
+                logger.info('Cannot find dependencies relationship (no resolve nodes.)')
+
+            for json_data in json_f['packages']:
+                dep_item = DependencyItem()
+                oss_item = OssItem()
+                pkg_id = json_data['id']
+                oss_origin_name = json_data['name']
+
+                oss_item.name = f"{self.package_manager_name}:{oss_origin_name}"
+                oss_item.version = json_data['version']
+                dn_without_ver = f"{self.dn_url}{oss_origin_name}"
+                oss_item.homepage = json_data['repository']
+                if oss_item.homepage is None:
+                    oss_item.homepage = dn_without_ver
+                dep_item.purl = get_url_to_purl(dn_without_ver, self.package_manager_name, oss_origin_name, oss_item.version)
+                oss_item.download_location = f'{dn_without_ver}/{oss_item.version}'
+                purl_dict[f'{oss_origin_name}({oss_item.version})'] = dep_item.purl
+                if json_data['license'] is not None:
+                    oss_item.license = json_data['license']
+
+                if self.direct_dep:
+                    if pkg_id == root:
+                        oss_item.comment = 'root package'
+                    if pkg_id in workspace_members:
+                        oss_item.comment = 'local package'
+                    if len(self.direct_dep_list) > 0:
+                        if pkg_id != root:
+                            if f'{oss_origin_name}({oss_item.version})' in self.direct_dep_list:
+                                oss_item.comment = 'direct'
+                            else:
+                                oss_item.comment = 'transitive'
+                    dep_item.depends_on_raw.extend(get_matched_dependencies(pkg_id, resolve_node))
+
+                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}")
+        if self.direct_dep:
+            self.dep_items = change_dependson_to_purl(purl_dict, self.dep_items)
+
+        return
+
+
+def get_matched_dependencies(match_id, resolve_node):
+    dependencies_list = []
+    for node in resolve_node:
+        if match_id == node['id']:
+            for dep_pkg in node['dependencies']:
+                try:
+                    match = re.findall(r'^.*#(\S*)@(\S*)', dep_pkg)
+                    dependencies_list.append(f'{match[0][0]}({match[0][1]})')
+                except Exception:
+                    try:
+                        match = re.findall(r'^(\S*)\s(\S*)\s', dep_pkg)
+                        dependencies_list.append(f'{match[0][0]}({match[0][1]})')
+                    except Exception:
+                        logger.info(f'cannot find name and version for dependencies: {match_id}')
+                        pass
+            break
+    return dependencies_list

fosslight_dependency/package_manager/Carthage.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2021 LG Electronics Inc.
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import re
+import os
+import fosslight_util.constant as constant
+import fosslight_dependency.constant as const
+from fosslight_dependency._package_manager import PackageManager
+from fosslight_dependency._package_manager import connect_github, get_github_license
+from fosslight_dependency._package_manager import get_url_to_purl, check_license_name
+from fosslight_dependency.dependency_item import DependencyItem
+from fosslight_util.oss_item import OssItem
+
+logger = logging.getLogger(constant.LOGGER_NAME)
+
+
+checkout_dir = os.path.join("Carthage", 'Checkouts')
+license_file_regs = ['licen[cs]e[s]?', 'notice[s]?', 'copying*', 'copyright[s]?',
+                     'mit', 'bsd[-]?[0-4]?', 'bsd[-]?[0-4][-]?clause[s]?', 'apache[-,_]?[1-2]?[.,-,_]?[0-2]?',
+                     'unlicen[cs]e', '[a,l]?gpl[-]?[1-3]?[.,-,_]?[0-1]?', 'legal']
+
+
+class Carthage(PackageManager):
+    package_manager_name = const.CARTHAGE
+
+    input_file_name = const.SUPPORT_PACKAE.get(package_manager_name)
+    dn_url = "https://github.com/"
+
+    def __init__(self, input_dir, output_dir, github_token):
+        super().__init__(self.package_manager_name, self.dn_url, input_dir, output_dir)
+        self.github_token = github_token
+        self.append_input_package_list_file(self.input_file_name)
+
+    def parse_oss_information(self, f_name):
+        github = "github"
+        checkout_dir_list = get_checkout_dirname()
+
+        with open(f_name, 'r', encoding='utf8') as input_fp:
+            g = ''
+            if not checkout_dir_list:
+                g = connect_github(self.github_token)
+
+            for i, line in enumerate(input_fp.readlines()):
+                # Cartfile origin : github, git
+                # 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_item.name = self.package_manager_name + ":" + oss_origin_name
+
+                    if repo == github:
+                        oss_item.homepage = self.dn_url + oss_path
+                    else:
+                        oss_item.homepage = oss_path
+                    oss_item.download_location = oss_item.homepage
+                    oss_item.version = re_result[0][2]
+
+                    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
+                    if oss_origin_name in checkout_dir_list:
+                        oss_path_in_checkout = os.path.join(checkout_dir, oss_origin_name)
+                        for filename_in_dir in os.listdir(oss_path_in_checkout):
+                            if find_license:
+                                break
+                            filename_with_checkout_path = os.path.join(oss_path_in_checkout, filename_in_dir)
+                            if os.path.isfile(filename_with_checkout_path):
+                                for license_file_reg in license_file_regs:
+                                    match_result = re.match(license_file_reg, filename_in_dir.lower())
+                                    if match_result is not None:
+                                        license_name = check_license_name(filename_with_checkout_path, True)
+                                        find_license = True
+                                        break
+                    if license_name == '':
+                        if repo == github:
+                            try:
+                                if not g:
+                                    g = connect_github(self.github_token)
+                                license_name = get_github_license(g, oss_path)
+                            except Exception as e:
+                                logger.warning(f"Failed to get license with github api: {e}")
+                                license_name == ''
+                    oss_item.license = license_name
+                    if self.direct_dep_list:
+                        if oss_origin_name in self.direct_dep_list:
+                            oss_item.comment = 'direct'
+                        else:
+                            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
+
+    def parse_direct_dependencies(self):
+        self.direct_dep = True
+        cartfile = 'Cartfile'
+        if os.path.exists(cartfile):
+            with open(cartfile, 'r', encoding='utf8') as input_fp:
+                for i, line in enumerate(input_fp.readlines()):
+                    re_result = re.findall(r'(github|git)[\s]\"(\S*)\"[\s]\"(\S*)\"', line)
+                    try:
+                        oss_path = re_result[0][1]
+                        if oss_path.endswith('.git'):
+                            oss_path = oss_path[:-4]
+                        oss_origin_name = oss_path.split('/')[-1]
+                        self.direct_dep_list.append(oss_origin_name)
+                    except Exception as e:
+                        logger.warning(f"Failed to parse Cartfile: {e}")
+
+
+def get_checkout_dirname():
+    checkout_dir_list = []
+    if os.path.isdir(checkout_dir):
+        for item in os.listdir(checkout_dir):
+            if os.path.isdir(os.path.join(checkout_dir, item)):
+                checkout_dir_list.append(item)
+
+    return checkout_dir_list