Fix indent

Author: Flamefire

test/framework/build_log.py

@@ -151,7 +151,7 @@ def test_easybuildlog(self):
         self.assertRaisesRegex(EasyBuildError, r"DEPRECATED \(since .*: kaput", log.deprecated, "kaput", older_ver)
         self.assertRaisesRegex(EasyBuildError, r"DEPRECATED \(since .*: 2>1", log.deprecated, "2>1", '2.0', '1.0')
         self.assertRaisesRegex(EasyBuildError, r"DEPRECATED \(since .*: 2>1", log.deprecated, "2>1", '2.0',
-                              max_ver='1.0')
+                               max_ver='1.0')
 
         # wipe log so we can reuse it
         write_file(tmplog, '')
@@ -435,7 +435,7 @@ def test_init_logging(self):
 
     def test_raise_nosupport(self):
         self.assertRaisesRegex(EasyBuildError, 'NO LONGER SUPPORTED since v42: foobar;',
-                              raise_nosupport, 'foobar', 42)
+                               raise_nosupport, 'foobar', 42)
 
 
 def suite(loader=None):

test/framework/containers.py

@@ -381,10 +381,10 @@ def test_end2end_dockerfile(self):
 
         error_pattern = "Unsupported container config 'not-supported'"
         self.assertRaisesRegex(EasyBuildError,
-                              error_pattern,
-                              self.run_main,
-                              base_args + ['--container-config=not-supported'],
-                              raise_error=True)
+                               error_pattern,
+                               self.run_main,
+                               base_args + ['--container-config=not-supported'],
+                               raise_error=True)
 
         for cont_base in ['ubuntu:20.04', 'centos:7']:
             stdout, stderr = self.run_main(base_args + ['--container-config=%s' % cont_base])
@@ -398,10 +398,10 @@ def test_end2end_dockerfile(self):
         error_pattern = "Container recipe at %s/containers/Dockerfile.toy-0.0 already exists, " \
                         "not overwriting it without --force" % self.test_prefix
         self.assertRaisesRegex(EasyBuildError,
-                              error_pattern,
-                              self.run_main,
-                              base_args + ['--container-config=centos:7'],
-                              raise_error=True)
+                               error_pattern,
+                               self.run_main,
+                               base_args + ['--container-config=centos:7'],
+                               raise_error=True)
 
         remove_file(os.path.join(self.test_prefix, 'containers', 'Dockerfile.toy-0.0'))
 

test/framework/easyblock.py

@@ -1972,7 +1972,7 @@ def test_fetch_sources(self):
         eb.src = []
         error_msg = r"DEPRECATED \(since v4.0\).*Using a 2-element list/tuple.*"
         self.assertRaisesRegex(EasyBuildError, error_msg, eb.fetch_sources,
-                              [('toy-0.0_gzip.patch.gz', "gunzip %s")], checksums=[])
+                               [('toy-0.0_gzip.patch.gz', "gunzip %s")], checksums=[])
 
         # unknown dict keys in sources are reported
         sources[0]['nosuchkey'] = 'foobar'
@@ -2212,7 +2212,7 @@ def test_obtain_file(self):
         error_pattern = "Couldn't find file 'toy-0.0.tar.gz' anywhere, and downloading it is disabled"
         with self.mocked_stdout_stderr():
             self.assertRaisesRegex(EasyBuildError, error_pattern, eb.obtain_file,
-                                  toy_tarball, urls=urls, alt_location='alt_toy', no_download=True)
+                                   toy_tarball, urls=urls, alt_location='alt_toy', no_download=True)
 
         # 'downloading' a file to (first) alternative sourcepath works
         with self.mocked_stdout_stderr():

test/framework/easyconfig.py

@@ -444,7 +444,7 @@ def test_extra_options(self):
         # test extra mandatory parameters
         extra_vars.update({'mandatory_key': ['default', 'another mandatory key', easyconfig.MANDATORY]})
         self.assertRaisesRegex(EasyBuildError, r"mandatory parameters not provided",
-                              EasyConfig, self.eb_file, extra_options=extra_vars)
+                               EasyConfig, self.eb_file, extra_options=extra_vars)
 
         self.contents += '\nmandatory_key = "value"'
         self.prep()
@@ -1719,7 +1719,7 @@ def test_build_options(self):
         self.prep()
         eb = EasyConfig(self.eb_file, validate=False)
         self.assertRaisesRegex(EasyBuildError, "Build option lists for iterated build should have same length",
-                              eb.validate)
+                               eb.validate)
 
         # list with a single element is OK, is treated as a string
         installopts = ['FOO=foo']
@@ -1930,7 +1930,7 @@ def test_filter_deps(self):
         write_file(ec_file, ec_txt)
 
         self.assertRaisesRegex(EasyBuildError, "Failed to determine minimal toolchain for dep .*",
-                              EasyConfig, ec_file, validate=False)
+                               EasyConfig, ec_file, validate=False)
 
         build_options.update({'filter_deps': ['deptobefiltered']})
         init_config(build_options=build_options)
@@ -3863,18 +3863,18 @@ def test_categorize_files_by_type(self):
         tmpdir = tempfile.mkdtemp()
         non_existing = os.path.join(tmpdir, 'does_not_exist.patch')
         self.assertRaisesRegex(EasyBuildError,
-                              "File %s does not exist" % non_existing,
-                              categorize_files_by_type, [non_existing])
+                               "File %s does not exist" % non_existing,
+                               categorize_files_by_type, [non_existing])
         patch_dir = os.path.join(tmpdir, 'folder.patch')
         os.mkdir(patch_dir)
         self.assertRaisesRegex(EasyBuildError,
-                              "File %s is expected to be a regular file" % patch_dir,
-                              categorize_files_by_type, [patch_dir])
+                               "File %s is expected to be a regular file" % patch_dir,
+                               categorize_files_by_type, [patch_dir])
         invalid_patch = os.path.join(tmpdir, 'invalid.patch')
         copy_file(gzip_ec, invalid_patch)
         self.assertRaisesRegex(EasyBuildError,
-                              "%s is not detected as a valid patch file" % invalid_patch,
-                              categorize_files_by_type, [invalid_patch])
+                               "%s is not detected as a valid patch file" % invalid_patch,
+                               categorize_files_by_type, [invalid_patch])
 
     def test_resolve_template(self):
         """Test resolve_template function."""
@@ -3949,11 +3949,11 @@ def test_det_subtoolchain_version(self):
         cands = [{'name': 'golfc', 'version': '2018a'},
                  {'name': 'golfc', 'version': '2018.01'}]
         self.assertRaisesRegex(EasyBuildError,
-                              "No version found for subtoolchain gompic in dependencies of fosscuda",
-                              det_subtoolchain_version, current_tc, 'gompic', optional_toolchains, cands)
+                               "No version found for subtoolchain gompic in dependencies of fosscuda",
+                               det_subtoolchain_version, current_tc, 'gompic', optional_toolchains, cands)
         self.assertRaisesRegex(EasyBuildError,
-                              "Multiple versions of golfc found in dependencies of toolchain fosscuda: 2018.01, 2018a",
-                              det_subtoolchain_version, current_tc, 'golfc', optional_toolchains, cands)
+                               "Multiple versions of golfc found in dependencies of toolchain fosscuda: 2018.01, 2018a",
+                               det_subtoolchain_version, current_tc, 'golfc', optional_toolchains, cands)
 
         # missing candidate for golfc, ok for optional
         cands = [{'name': 'gompic', 'version': '2018a'}]
@@ -4723,11 +4723,11 @@ def __init__(self, values):
 
         error_msg = 'exts_filter should be a list or tuple'
         self.assertRaisesRegex(EasyBuildError, error_msg, resolve_exts_filter_template,
-                              '[ 1 == 1 ]', {})
+                               '[ 1 == 1 ]', {})
         self.assertRaisesRegex(EasyBuildError, error_msg, resolve_exts_filter_template,
-                              ['[ 1 == 1 ]'], {})
+                               ['[ 1 == 1 ]'], {})
         self.assertRaisesRegex(EasyBuildError, error_msg, resolve_exts_filter_template,
-                              ['[ 1 == 1 ]', 'true', 'false'], {})
+                               ['[ 1 == 1 ]', 'true', 'false'], {})
 
         test_cases = [
             # Minimal case: just name

test/framework/ebconfigobj.py

@@ -86,8 +86,8 @@ def test_ebconfigobj_unusable_default(self):
             configobj_txt = ['[SUPPORTED]', val]
             co = ConfigObj(configobj_txt)
             self.assertRaisesRegex(EasyBuildError,
-                                  r'First\s+(toolchain|version)\s.*?\scan\'t\s+be\s+used\s+as\s+default',
-                                  EBConfigObj, co)
+                                   r'First\s+(toolchain|version)\s.*?\scan\'t\s+be\s+used\s+as\s+default',
+                                   EBConfigObj, co)
 
     def test_squash_simple(self):
         """Test toolchain filter"""
@@ -161,7 +161,7 @@ def test_squash_invalid(self):
             co = ConfigObj(txt)
             cov = EBConfigObj(co)
             self.assertRaisesRegex(EasyBuildError, r'conflict', cov.squash,
-                                  default_version, tc_first['name'], tc_first['version'])
+                                   default_version, tc_first['name'], tc_first['version'])
 
     def test_toolchain_squash_nested(self):
         """Test toolchain filter on nested sections"""

test/framework/filetools.py

@@ -190,9 +190,9 @@ def test_find_glob_pattern(self):
                          os.path.join(tmpdir, 'python3.5m', 'include'))
         self.assertEqual(ft.find_glob_pattern(os.path.join(tmpdir, 'python3.6*'), False), None)
         self.assertRaisesRegex(EasyBuildError, "Was expecting exactly", ft.find_glob_pattern,
-                              os.path.join(tmpdir, 'python3.6*'))
+                               os.path.join(tmpdir, 'python3.6*'))
         self.assertRaisesRegex(EasyBuildError, "Was expecting exactly", ft.find_glob_pattern,
-                              os.path.join(tmpdir, 'python*'))
+                               os.path.join(tmpdir, 'python*'))
 
     def test_encode_class_name(self):
         """Test encoding of class names."""
@@ -360,8 +360,8 @@ def test_checksums(self):
         self.assertTrue(ft.verify_checksum(fp, {os.path.basename(fp): None}))
         faulty_dict = {'wrong-name': known_checksums['sha256']}
         self.assertRaisesRegex(EasyBuildError,
-                              "Missing checksum for " + os.path.basename(fp) + " in .*wrong-name.*",
-                              ft.verify_checksum, fp, faulty_dict)
+                               "Missing checksum for " + os.path.basename(fp) + " in .*wrong-name.*",
+                               ft.verify_checksum, fp, faulty_dict)
 
         # check whether missing checksums are enforced
         build_options = {
@@ -374,7 +374,7 @@ def test_checksums(self):
 
         # Test dictionary-type checksums
         self.assertRaisesRegex(EasyBuildError, "Missing checksum for", ft.verify_checksum,
-                              fp, {os.path.basename(fp): None})
+                               fp, {os.path.basename(fp): None})
         for checksum in [known_checksums[x] for x in ['sha256']]:
             dict_checksum = {os.path.basename(fp): checksum, 'foo': 'baa'}
             self.assertTrue(ft.verify_checksum(fp, dict_checksum))
@@ -881,9 +881,9 @@ def test_symlink_resolve_path(self):
         test_file2 = os.path.join(link_dir, 'test2.txt')
         ft.write_file(test_file, "test123")
         self.assertRaisesRegex(EasyBuildError,
-                              "Trying to symlink %s to %s, but the symlink already exists and points to %s." %
-                              (test_file2, link, test_file),
-                              ft.symlink, test_file2, link)
+                               "Trying to symlink %s to %s, but the symlink already exists and points to %s." %
+                               (test_file2, link, test_file),
+                               ft.symlink, test_file2, link)
 
         # test resolve_path
         self.assertEqual(test_dir, ft.resolve_path(link_dir))
@@ -1436,7 +1436,8 @@ def test_adjust_permissions(self):
         err_msg = "Failed to chmod/chown several paths.*No such file or directory"
         self.assertRaisesRegex(EasyBuildError, err_msg, ft.adjust_permissions, nosuchdir, stat.S_IWOTH)
         nosuchfile = os.path.join(self.test_prefix, 'nosuchfile')
-        self.assertRaisesRegex(EasyBuildError, err_msg, ft.adjust_permissions, nosuchfile, stat.S_IWUSR, recursive=False)
+        self.assertRaisesRegex(EasyBuildError, err_msg, ft.adjust_permissions,
+                               nosuchfile, stat.S_IWUSR, recursive=False)
 
         # try using adjust_permissions on a file not owned by current user,
         # using permissions that are actually already correct;
@@ -1575,11 +1576,11 @@ def test_apply_regex_substitutions(self):
         error_pat = "Nothing found to replace 'Not there' in %s" % testfile
         # Error
         self.assertRaisesRegex(EasyBuildError, error_pat, ft.apply_regex_substitutions, testfile, regex_subs_no_match,
-                              on_missing_match=ERROR)
+                               on_missing_match=ERROR)
         # First matches, but 2nd not
         regex_subs_part_match = [regex_subs[0], ('Not there', 'Not used')]
         self.assertRaisesRegex(EasyBuildError, error_pat, ft.apply_regex_substitutions, testfile, regex_subs_part_match,
-                              on_missing_match=ERROR, match_all=True)
+                               on_missing_match=ERROR, match_all=True)
         # First matched so OK with match_all
         ft.apply_regex_substitutions(testfile, regex_subs_part_match,
                                      on_missing_match=ERROR, match_all=False)
@@ -1846,9 +1847,9 @@ def test_create_patch_info(self):
         self.assertRaisesRegex(EasyBuildError, error_msg, ft.create_patch_info, {'name': 'foo.txt'})
         self.assertRaisesRegex(EasyBuildError, error_msg, ft.create_patch_info, {'name': 'foo.txt', 'random': 'key'})
         self.assertRaisesRegex(EasyBuildError, error_msg, ft.create_patch_info,
-                              {'name': 'foo.txt', 'copy': 'subdir', 'sourcepath': 'subdir'})
+                               {'name': 'foo.txt', 'copy': 'subdir', 'sourcepath': 'subdir'})
         self.assertRaisesRegex(EasyBuildError, error_msg, ft.create_patch_info,
-                              {'name': 'foo.txt', 'copy': 'subdir', 'level': 1})
+                               {'name': 'foo.txt', 'copy': 'subdir', 'level': 1})
         self.assertRaisesRegex(EasyBuildError, error_msg, ft.create_patch_info, ('foo.patch', [1, 2]))
         error_msg = "Unknown patch specification"
         self.assertRaisesRegex(EasyBuildError, error_msg, ft.create_patch_info, ('foo.patch', 1, 'subdir'))
@@ -3974,7 +3975,7 @@ def test_create_unused_dir(self):
         ft.adjust_permissions(readonly_dir, stat.S_IREAD | stat.S_IEXEC, relative=False)
         try:
             self.assertRaisesRegex(EasyBuildError, 'Failed to create directory',
-                                  ft.create_unused_dir, readonly_dir, 'new_folder')
+                                   ft.create_unused_dir, readonly_dir, 'new_folder')
         finally:
             ft.adjust_permissions(readonly_dir, old_perms, relative=False)
 

test/framework/github.py

@@ -656,10 +656,10 @@ def test_github_download_repo_commit(self):
 
         # short commit doesn't work, must be full commit ID
         self.assertRaisesRegex(EasyBuildError, "Specified commit SHA bdcc586 .* is not valid", gh.download_repo,
-                              path=self.test_prefix, commit='bdcc586')
+                               path=self.test_prefix, commit='bdcc586')
 
         self.assertRaisesRegex(EasyBuildError, "Failed to download tarball .* commit", gh.download_repo,
-                              path=self.test_prefix, commit='0000000000000000000000000000000000000000')
+                               path=self.test_prefix, commit='0000000000000000000000000000000000000000')
 
     def test_install_github_token(self):
         """Test for install_github_token function."""

test/framework/module_generator.py

@@ -316,7 +316,7 @@ def test_load(self):
                 expected = "depends-on statements in generated module are not supported by modules tool"
                 with self.mocked_stdout_stderr():
                     self.assertRaisesRegex(EasyBuildError, expected,
-                                          self.modgen.load_module, "mod_name", depends_on=True)
+                                           self.modgen.load_module, "mod_name", depends_on=True)
         else:
             # default: guarded module load (which implies no recursive unloading)
             expected = '\n'.join([
@@ -362,7 +362,7 @@ def test_load(self):
                 expected = "depends_on statements in generated module are not supported by modules tool"
                 with self.mocked_stdout_stderr():
                     self.assertRaisesRegex(EasyBuildError, expected,
-                                          self.modgen.load_module, "mod_name", depends_on=True)
+                                           self.modgen.load_module, "mod_name", depends_on=True)
 
     def test_load_multi_deps(self):
         """Test generated load statement when multi_deps is involved."""
@@ -776,7 +776,7 @@ def append_paths(*args, **kwargs):
 
         self.assertRaisesRegex(EasyBuildError, "Absolute path %s/foo passed to update_paths "
                                               "which only expects relative paths." % self.modgen.app.installdir,
-                              append_paths, "key2", ["bar", "%s/foo" % self.modgen.app.installdir])
+                               append_paths, "key2", ["bar", "%s/foo" % self.modgen.app.installdir])
 
         # check for warning that is printed when same path is added multiple times
         with self.modgen.start_module_creation():
@@ -910,7 +910,7 @@ def prepend_paths(*args, **kwargs):
 
         self.assertRaisesRegex(EasyBuildError, "Absolute path %s/foo passed to update_paths "
                                               "which only expects relative paths." % self.modgen.app.installdir,
-                              prepend_paths, "key2", ["bar", "%s/foo" % self.modgen.app.installdir])
+                               prepend_paths, "key2", ["bar", "%s/foo" % self.modgen.app.installdir])
 
         # check for warning that is printed when same path is added multiple times
         with self.modgen.start_module_creation():