easybuild-framework 5.1.2__tar.gz → 5.2.0__tar.gz

{easybuild_framework-5.1.2/easybuild_framework.egg-info → easybuild_framework-5.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: easybuild-framework
-Version: 5.1.2
+Version: 5.2.0
 Summary: The EasyBuild framework supports the creation of custom easyblocks that implement support for installing particular (groups of) software packages.
 Home-page: https://easybuild.io
 Author: EasyBuild community
@@ -20,6 +20,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Build Tools
 License-File: LICENSE
 Dynamic: author

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/RELEASE_NOTES

@@ -4,6 +4,60 @@ For more detailed information, please see the git log.
 These release notes can also be consulted at https://docs.easybuild.io/release-notes .
 
 
+v5.2.0 (23 Dec 2025)
+--------------------
+
+feature release
+
+- new features:
+  - add support for NVHPC toolchain with nvidia-compilers, NVHPCX, NVBLAS, and NVScaLAPACK (#4927, #5073)
+  - add support for LLVM-based toolchains `lfoss` and `lmpflf` (+ subtoolchains `llvm-compilers`, `lfbf`, `lompi`, `lmpich`) (#4914)
+- various other enhancements, including:
+  - add support for `--disable-robot` (#4781)
+  - make specifying `exts_defaultclass` optional (#4800)
+  - retry fetching source file for extensions from PyPI with alternative filename (with `-` replaced with `_` in extension name) (#4943)
+  - handle `post_install_patches` in GitHub uploads (#5016)
+  - take into account alternative name `post_install_patches` when checking checksums (#5017)
+  - improve test report formatting (#5018)
+  - add `--keep-going` option to fail at the end not at first failing installation + use proper exit code as determined by `main` function (#5022)
+  - add templates for source with just version numbers (like `VERSION_TAR_GZ` and `V_VERSION_TAR_GZ`) (#5025)
+  - add templates for patch versions (#5028)
+  - add `search_path_vars_headers` and `search_path_vars_linker` properties to `Toolchain` (#5031)
+  - print total runtime of all builds (#5032)
+  - unset `$PROMPT_COMMAND` in `cmd.sh` shell (#5034)
+  - add `runtime_only` options to `EasyConfig.dependency_names` method (#5044)
+  - remove superflous `module list` call in `ModulesTool.load` (#5046)
+  - add backtrace to logged exception (#5047)
+  - add support for both `$VAR` and `${VAR}` variable formats in `modextravars` (#5049)
+  - show more readable error message when uploading gist or posting comment failed (#5056)
+  - set `$___EASYBUILD___` environment variable to '`EasyBuild`' to indicate that you're in an EasyBuild session (#5058)
+  - vendor a copy of `tomli` in `easybuild.tools.tomllib` (#5063)
+  - allow `f` suffix in CUDA compute capabilities (#5067)
+  - vendor copy of tomli-w 1.2.0, use it to implement `dump_toml` function in `easybuild.tools.filetools` (#5071)
+- various bug fixes, including:
+  - pass correct `-march` option on RISC-V systems when `optarch` toolchain option is enabled (#5029)
+  - pass dependencies to `toolchain.prepare` when setting up build environment for extensions (#5023, #5041)
+  - also pick up on toolchain components in `Toolchain._add_dependency_variables` (#5042, #5048)
+  - don't append empty component to `start_dir` in `EasyBlock.guess_start_dir` (#5057)
+- enhancements and fixes for test suite:
+  - also with test Python 3.14 (#4992)
+  - fix `test_gitrepo` in case global Git configuration is not in place (#5013)
+  - introduce `saved_env` context manager for restoring environment in tests (#5015)
+  - add decorator to ignore PR test failures due to rate limit (#5019)
+  - also run tests with Lmod 9.0 (#5026)
+  - enable flake8-comprehension code style check and fix issues (#5043)
+  - disable trace output by default in tests (#5053)
+  - add back CI for Python 3.6 by using `pyenv` (#5064)
+  - fix `test_github_det_commit_status` by using more recent commits (#5066)
+  - fix ignoring of URLError in `test_copy_ec_from_commit` (#5077)
+- other changes:
+  - deprecate support for running EasyBuild with Python < 3.9 (#4966)
+  - make command environment of shell commands more discoverable in the log (#4999, #5078)
+  - don't show command string again when showing in which folder it runs (#5003)
+  - remove escaping when converting `EasyBuildError` to a string (#5009)
+  - add example hook for updating OpenSSL 1.x dependency to 3.x (#5035)
+
+
 v5.1.2 (26 Sept 2025)
 ---------------------
 

easybuild_framework-5.2.0/contrib/hooks/bumpOpenSSL.py

@@ -0,0 +1,26 @@
+from easybuild.framework.easyconfig.constants import EASYCONFIG_CONSTANTS
+
+
+def parse_hook(ec, *args, **kwargs):
+    """
+    EasyBuild parse hook for EL9+ compatibility
+    """
+    # looks like [('zlib', '1.2.13'), ('OpenSSL', '1.1', '', {'name': 'system', 'version': 'system'})]
+    raw_deps = ec['dependencies'] if 'dependencies' in ec else []
+
+    # Check if OpenSSL is in any dependency tuple's first element
+    openssl_found = any(dep[0] == 'OpenSSL' for dep in raw_deps)
+
+    # if found, replace its version - second element in the tuple with '3'.
+    if openssl_found:
+        print(f"[openssl1->3 hook] OpenSSL found in dependencies of {ec['name']}, replacing with OpenSSL 3")
+        for i, dep in enumerate(raw_deps):
+            if dep[0] == 'OpenSSL' and dep[1] == '1.1':
+                raw_deps[i] = ('OpenSSL', '3', '', EASYCONFIG_CONSTANTS['SYSTEM'][0])
+                break
+
+    else:
+        # no need to do anything
+        return
+
+    ec['dependencies'] = raw_deps

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/base/exceptions.py

@@ -91,6 +91,7 @@ class LoggedException(Exception):
         if args:
             msg = msg % args
 
+        backtrace = []
         if self.LOC_INFO_TOP_PKG_NAMES is not None:
             # determine correct frame to fetch location information from
             frames_up = 1
@@ -101,19 +102,30 @@ class LoggedException(Exception):
             if self.INCLUDE_LOCATION:
                 # figure out where error was raised from
                 # current frame: this constructor, one frame above: location where LoggedException was created/raised
-                frameinfo = inspect.getouterframes(inspect.currentframe())[frames_up]
-
-                # determine short location of Python module where error was raised from,
-                # i.e. starting with an entry from LOC_INFO_TOP_PKG_NAMES
-                path_parts = frameinfo[1].split(os.path.sep)
-                if path_parts[0] == '':
-                    path_parts[0] = os.path.sep
-                top_indices = [path_parts.index(n) for n in self.LOC_INFO_TOP_PKG_NAMES if n in path_parts]
-                relpath = os.path.join(*path_parts[max(top_indices or [0]):])
+                frames = inspect.getouterframes(inspect.currentframe())[frames_up:]
+                backtrace = []
+                for frame in frames:
+                    # determine short location of Python module where error was raised from,
+                    # i.e. starting with an entry from LOC_INFO_TOP_PKG_NAMES
+                    path_parts = frame[1].split(os.path.sep)
+                    if path_parts[0] == '':
+                        path_parts[0] = os.path.sep
+                    try:
+                        top_idx = max(path_parts.index(n) for n in self.LOC_INFO_TOP_PKG_NAMES if n in path_parts)
+                    except ValueError:
+                        # If none found (outside PKG) stop backtrace if we have at least 1 entry
+                        if backtrace:
+                            break
+                        relpath = frame[1]
+                    else:
+                        relpath = os.path.join(*path_parts[top_idx:])
+                    backtrace.append(f'{relpath}:{frame[2]} in {frame[3]}')
 
                 # include location info at the end of the message
                 # for example: "Nope, giving up (at easybuild/tools/somemodule.py:123 in some_function)"
-                msg = "%s (at %s:%s in %s)" % (msg, relpath, frameinfo[2], frameinfo[3])
+                msg = f"{msg} (at {backtrace[0]})"
+
+        super().__init__(msg)
 
         logger = kwargs.get('logger', None)
         # try to use logger defined in caller's environment
@@ -123,6 +135,6 @@ class LoggedException(Exception):
             if logger is None:
                 logger = self.LOGGER_MODULE.getLogger()
 
+        if backtrace:
+            msg += '\nCallstack:\n\t' + '\n\t'.join(backtrace)
         getattr(logger, self.LOGGING_METHOD_NAME)(msg)
-
-        super().__init__(msg)

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/base/fancylogger.py

@@ -435,7 +435,7 @@ def thread_name():
     """
     returns the current threads name
     """
-    return threading.currentThread().getName()
+    return threading.current_thread().name
 
 
 def getLogger(name=None, fname=False, clsname=False, fancyrecord=None):
@@ -577,8 +577,8 @@ def logToFile(filename, enable=True, filehandler=None, name=None, max_bytes=MAX_
         'mode': 'a',
         'maxBytes': max_bytes,
         'backupCount': backup_count,
+        'encoding': 'utf-8',
     }
-    handleropts['encoding'] = 'utf-8'
     # logging to a file is going to create the file later on, so let's try to be helpful and create the path if needed
     directory = os.path.dirname(filename)
     if not os.path.exists(directory):
@@ -783,7 +783,7 @@ def getAllExistingLoggers():
     """
     # not-so-well documented manager (in 2.6 and later)
     # return list of (name,logger) tuple
-    return [x for x in logging.Logger.manager.loggerDict.items()] + [(logging.root.name, logging.root)]
+    return list(logging.Logger.manager.loggerDict.items()) + [(logging.root.name, logging.root)]
 
 
 def getAllNonFancyloggers():

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/base/generaloption.py

@@ -185,6 +185,8 @@ class ExtOption(CompleterOption):
            - set default to None if no option passed,
            - set to default if option without value passed,
            - set to value if option with value passed
+         - store_or_False: Same as store_or_None, but set to False instead of None
+           - Additionally supports --disable-
 
         Types:
           - strlist, strtuple : convert comma-separated string in a list resp. tuple of strings
@@ -196,14 +198,15 @@ class ExtOption(CompleterOption):
 
     ENABLE = 'enable'  # do nothing
     DISABLE = 'disable'  # inverse action
+    STORE_OR_FALSE = 'store_or_False'
 
     EXTOPTION_EXTRA_OPTIONS = ('date', 'datetime', 'regex', 'add', 'add_first', 'add_flex',)
-    EXTOPTION_STORE_OR = ('store_or_None', 'help')  # callback type
+    EXTOPTION_STORE_OR = ('store_or_None', STORE_OR_FALSE, 'help')  # callback type
     EXTOPTION_LOG = ('store_debuglog', 'store_infolog', 'store_warninglog',)
     EXTOPTION_HELP = ('shorthelp', 'confighelp', 'help')
 
     ACTIONS = Option.ACTIONS + EXTOPTION_EXTRA_OPTIONS + EXTOPTION_STORE_OR + EXTOPTION_LOG + EXTOPTION_HELP
-    STORE_ACTIONS = Option.STORE_ACTIONS + EXTOPTION_EXTRA_OPTIONS + EXTOPTION_LOG + ('store_or_None',)
+    STORE_ACTIONS = Option.STORE_ACTIONS + EXTOPTION_EXTRA_OPTIONS + EXTOPTION_LOG + ('store_or_None', STORE_OR_FALSE)
     TYPED_ACTIONS = Option.TYPED_ACTIONS + EXTOPTION_EXTRA_OPTIONS + EXTOPTION_STORE_OR
     ALWAYS_TYPED_ACTIONS = Option.ALWAYS_TYPED_ACTIONS + EXTOPTION_EXTRA_OPTIONS
 
@@ -232,7 +235,9 @@ class ExtOption(CompleterOption):
                 """Callback for supporting options with optional values."""
                 # see http://stackoverflow.com/questions/1229146/parsing-empty-options-in-python
                 # ugly code, optparse is crap
-                if parser.rargs and not parser.rargs[0].startswith('-'):
+                if option.store_or == self.STORE_OR_FALSE and opt_str.startswith("--%s-" % self.DISABLE):
+                    val = False
+                elif parser.rargs and not parser.rargs[0].startswith('-'):
                     val = option.check_value(opt_str, parser.rargs.pop(0))
                 else:
                     val = kwargs.get('orig_default', None)
@@ -250,11 +255,7 @@ class ExtOption(CompleterOption):
                 'orig_default': copy.deepcopy(self.default),
             }
             self.action = 'callback'  # act as callback
-
-            if self.store_or in self.EXTOPTION_STORE_OR:
-                self.default = None
-            else:
-                self.log.raiseException("_set_attrs: unknown store_or %s" % self.store_or, exception=ValueError)
+            self.default = False if self.action == self.STORE_OR_FALSE else None
 
     def process(self, opt, value, values, parser):
         """Handle option-as-value issues before actually processing option."""
@@ -1219,6 +1220,8 @@ class GeneralOption:
                 if action in self.parser.option_class.BOOLEAN_ACTIONS:
                     args.append("--%s-%s" % (self.parser.option_class.ENABLE, opt_name))
                     args.append("--%s-%s" % (self.parser.option_class.DISABLE, opt_name))
+                elif action == self.parser.option_class.STORE_OR_FALSE:
+                    args.append("--%s-%s" % (self.parser.option_class.DISABLE, opt_name))
 
             # force passed_kwargs as final nameds
             nameds.update(passed_kwargs)

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/base/testing.py

@@ -201,6 +201,15 @@ class TestCase(OrigTestCase):
         """Return output captured from stderr until now."""
         return sys.stderr.getvalue()
 
+    @contextmanager
+    def mocked_stdout(self):
+        """Context manager to mock stdout"""
+        self.mock_stdout(True)
+        try:
+            yield sys.stdout
+        finally:
+            self.mock_stdout(False)
+
     @contextmanager
     def mocked_stdout_stderr(self, mock_stdout=True, mock_stderr=True):
         """Context manager to mock stdout and stderr"""
@@ -221,6 +230,16 @@ class TestCase(OrigTestCase):
             if mock_stderr:
                 self.mock_stderr(False)
 
+    @contextmanager
+    def saved_env(self):
+        """Context manager to reset environment to state when it was entered"""
+        orig_env = os.environ.copy()
+        try:
+            yield
+        finally:
+            os.environ.clear()
+            os.environ.update(orig_env)
+
     def tearDown(self):
         """Cleanup after running a test."""
         self.mock_stdout(False)

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/base/wrapper.py

@@ -39,7 +39,7 @@ class WrapperMeta(type):
         # create proxies for wrapped object's double-underscore attributes
         type.__init__(cls, name, bases, dct)
         if cls.__wraps__:
-            ignore = set("__%s__" % n for n in cls.__ignore__.split())
+            ignore = {"__%s__" % n for n in cls.__ignore__.split()}
             for name in dir(cls.__wraps__):
                 if name.startswith("__"):
                     if name not in ignore and name not in dct:

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/framework/easyblock.py

@@ -42,6 +42,7 @@ Authors:
 * Caspar van Leeuwen (SURF)
 * Jan Andre Reuter (Juelich Supercomputing Centre)
 * Jasper Grimm (UoY)
+* Alex Domingo (Vrije Universiteit Brussel)
 """
 import concurrent
 import copy
@@ -730,9 +731,13 @@ class EasyBlock:
 
                         # if no sources are specified via 'sources', fall back to 'source_tmpl'
                         src_fn = ext_options.get('source_tmpl')
+                        is_pypi_source = False
                         if src_fn is None:
                             # use default template for name of source file if none is specified
                             src_fn = '%(name)s-%(version)s.tar.gz'
+                            if len(source_urls) == 1 and PYPI_PKG_URL_PATTERN in source_urls[0]:
+                                # allow retrying with alternative download_filename
+                                is_pypi_source = True
                         elif not isinstance(src_fn, str):
                             error_msg = "source_tmpl value must be a string! (found value of type '%s'): %s"
                             raise EasyBuildError(error_msg, type(src_fn).__name__, src_fn)
@@ -742,7 +747,17 @@ class EasyBlock:
                         if fetch_files:
                             src_path = self.obtain_file(src_fn, extension=True, urls=source_urls,
                                                         force_download=force_download,
-                                                        download_instructions=download_instructions)
+                                                        download_instructions=download_instructions,
+                                                        warning_only=is_pypi_source)
+                            if not src_path and is_pypi_source:
+                                # retry with alternative download_filename
+                                alt_name = resolve_template('%(name)s', template_values).replace("-", "_")
+                                src_version = resolve_template('%(version)s', template_values)
+                                alt_download_fn = f'{alt_name}-{src_version}.tar.gz'
+                                src_path = self.obtain_file(src_fn, extension=True, urls=source_urls,
+                                                            force_download=force_download,
+                                                            download_instructions=download_instructions,
+                                                            download_filename=alt_download_fn)
                             if src_path:
                                 ext_src.update({'src': src_path})
                             else:
@@ -2126,7 +2141,8 @@ class EasyBlock:
                     self.log.debug("List of loaded modules: %s", self.modules_tool.list())
                     # don't reload modules for toolchain, there is no need
                     # since they will be loaded already by the fake module
-                    ext.toolchain.prepare(onlymod=self.cfg['onlytcmod'], silent=True, loadmod=False,
+                    ext.toolchain.prepare(onlymod=self.cfg['onlytcmod'], deps=self.cfg.dependencies(),
+                                          silent=True, loadmod=False,
                                           rpath_filter_dirs=self.rpath_filter_dirs,
                                           rpath_include_dirs=self.rpath_include_dirs,
                                           rpath_wrappers_dir=self.rpath_wrappers_dir)
@@ -2288,7 +2304,8 @@ class EasyBlock:
                         with self.fake_module_environment(with_build_deps=True):
                             # don't reload modules for toolchain, there is no
                             # need since they will be loaded by the fake module
-                            ext.toolchain.prepare(onlymod=self.cfg['onlytcmod'], silent=True, loadmod=False,
+                            ext.toolchain.prepare(onlymod=self.cfg['onlytcmod'], deps=self.cfg.dependencies(),
+                                                  silent=True, loadmod=False,
                                                   rpath_filter_dirs=self.rpath_filter_dirs,
                                                   rpath_include_dirs=self.rpath_include_dirs,
                                                   rpath_wrappers_dir=self.rpath_wrappers_dir)
@@ -2366,7 +2383,7 @@ class EasyBlock:
                 # make sure start_dir subdir exists (cfr. check below)
                 mkdir(os.path.join(topdir, start_dir), parents=True)
 
-            abs_start_dir = os.path.join(topdir, start_dir)
+            abs_start_dir = os.path.join(topdir, start_dir) if start_dir else topdir
             if topdir.endswith(start_dir) and not os.path.exists(abs_start_dir):
                 self.cfg['start_dir'] = topdir
             else:
@@ -2743,7 +2760,8 @@ class EasyBlock:
         try:
             sources = ent.get('sources', [])
             data_sources = ent.get('data_sources', [])
-            patches = ent.get('patches', []) + ent.get('postinstallpatches', [])
+            patches = ent.get('patches', []) + ent.get(ALTERNATIVE_EASYCONFIG_PARAMETERS['post_install_patches'],
+                                                       ent.get('post_install_patches', []))
             checksums = ent.get('checksums', [])
         except EasyBuildError:
             if isinstance(ent, EasyConfig):
@@ -3009,9 +3027,21 @@ class EasyBlock:
             self.modules_tool.load(extra_modules)
 
         # Setup CUDA cache if required. If we don't do this, CUDA will use the $HOME for its cache files
-        if get_software_root('CUDA') or get_software_root('CUDAcore'):
+        if get_software_root('CUDA') or get_software_root('CUDAcore') or get_software_root('nvidia-compilers'):
             self.set_up_cuda_cache()
 
+        # Set CUDA compute capabilities from default value in nvidia-compiler/NVHPC toolchains
+        if get_software_root('nvidia-compilers'):
+            cuda_cc_cfg = self.cfg.get('cuda_compute_capabilities')
+            cuda_cc_opt = build_option('cuda_compute_capabilities')
+            cuda_cc_nvhpc = os.getenv('EBNVHPCCUDACC', None)
+            if not cuda_cc_cfg and not cuda_cc_opt and cuda_cc_nvhpc:
+                self.cfg['cuda_compute_capabilities'] = cuda_cc_nvhpc.split(',')
+                self.log.info(
+                    "Updated empty 'cuda_compute_capabilities' option with default CUDA compute capability "
+                    f"defined in nvidia-compilers: {self.cfg['cuda_compute_capabilities']}"
+                )
+
         # guess directory to start configure/build/install process in, and move there
         if start_dir:
             self.guess_start_dir()
@@ -3076,8 +3106,10 @@ class EasyBlock:
             # proper way: derive module path from specified class name
             default_class = exts_defaultclass
             default_class_modpath = get_module_path(default_class, generic=True)
+        elif exts_defaultclass is None:
+            default_class = default_class_modpath = None
         else:
-            error_msg = "Improper default extension class specification, should be string: %s (%s)"
+            error_msg = "Improper default extension class specification, should be string or None: %s (%s)"
             raise EasyBuildError(error_msg, exts_defaultclass, type(exts_defaultclass))
 
         exts_cnt = len(self.exts)
@@ -3129,8 +3161,11 @@ class EasyBlock:
                                          "for extension %s: %s",
                                          class_name, mod_path, ext_name, err)
 
-            # fallback attempt: use default class
+            # fallback attempt: use default class if any
             if inst is None:
+                if not default_class:
+                    raise EasyBuildError("ERROR: No default extension class set for %s and no explicit or custom "
+                                         "easyblock found for extension %s", self.name, ext_name)
                 try:
                     cls = get_class_for(default_class_modpath, default_class)
                     self.log.debug("Obtained class %s for installing extension %s", cls, ext_name)
@@ -3170,10 +3205,6 @@ class EasyBlock:
 
         self.prepare_for_extensions()
 
-        # we really need a default class
-        if not self.cfg['exts_defaultclass'] and install:
-            raise EasyBuildError("ERROR: No default extension class set for %s", self.name)
-
         if fetch:
             self.update_exts_progress_bar("fetching extension sources/patches")
             self.exts = self.collect_exts_file_info(fetch_files=True)

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/framework/easyconfig/default.py

@@ -189,7 +189,7 @@ DEFAULT_CONFIG = {
     # EXTENSIONS easyconfig parameters
     'exts_download_dep_fail': [False, "Fail if downloaded dependencies are detected for extensions", EXTENSIONS],
     'exts_classmap': [{}, "Map of extension name to class for handling build and installation.", EXTENSIONS],
-    'exts_defaultclass': [None, "List of module for and name of the default extension class", EXTENSIONS],
+    'exts_defaultclass': [None, "Name of default easyblock for extensions", EXTENSIONS],
     'exts_default_options': [{}, "List of default options for extensions", EXTENSIONS],
     'exts_filter': [None, ("Extension filter details: template for cmd and input to cmd "
                            "(templates for ext_name, ext_version and src)."), EXTENSIONS],

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/framework/easyconfig/easyconfig.py

@@ -261,7 +261,7 @@ def det_subtoolchain_version(current_tc, subtoolchain_names, optional_toolchains
 
     for subtoolchain_name in subtoolchain_names:
 
-        uniq_subtc_versions = set([subtc['version'] for subtc in cands if subtc['name'] == subtoolchain_name])
+        uniq_subtc_versions = {subtc['version'] for subtc in cands if subtc['name'] == subtoolchain_name}
 
         # system toolchain: bottom of the hierarchy
         if is_system_toolchain(subtoolchain_name):
@@ -318,8 +318,8 @@ def get_toolchain_hierarchy(parent_toolchain, incl_capabilities=False):
     # obtain list of all possible subtoolchains
     _, all_tc_classes = search_toolchain('')
     subtoolchains = {tc_class.NAME: getattr(tc_class, 'SUBTOOLCHAIN', None) for tc_class in all_tc_classes}
-    optional_toolchains = set(tc_class.NAME for tc_class in all_tc_classes if getattr(tc_class, 'OPTIONAL', False))
-    composite_toolchains = set(tc_class.NAME for tc_class in all_tc_classes if len(tc_class.__bases__) > 1)
+    optional_toolchains = {tc_class.NAME for tc_class in all_tc_classes if getattr(tc_class, 'OPTIONAL', False)}
+    composite_toolchains = {tc_class.NAME for tc_class in all_tc_classes if len(tc_class.__bases__) > 1}
 
     # the parent toolchain is at the top of the hierarchy,
     # we need a copy so that adding capabilities (below) doesn't affect the original object
@@ -682,7 +682,7 @@ class EasyConfig:
         # For easyconfig parameters that are dictionaries, input value must also be a dictionary
         if isinstance(self[key], dict) and not isinstance(value, dict):
             msg = "Can't update configuration value for %s, because the attempted"
-            msg += "update value (%s), is not a dictionary (type: %s)."
+            msg += " update value (%s), is not a dictionary (type: %s)."
             raise EasyBuildError(msg, key, value, type(value))
 
         # Grab current parameter value so we can modify it
@@ -1219,14 +1219,16 @@ class EasyConfig:
 
         return retained_deps
 
-    def dependency_names(self, build_only=False):
+    def dependency_names(self, build_only=False, runtime_only=False):
         """
         Return a set of names of all (direct) dependencies after filtering.
         Iterable builddependencies are flattened when not iterating.
 
         :param build_only: only return build dependencies, discard others
+        :param runtime_only: only return runtime dependencies, discard others
         """
-        return {dep['name'] for dep in self.dependencies(build_only=build_only) if dep['name']}
+        return {dep['name'] for dep in self.dependencies(build_only=build_only, runtime_only=runtime_only)
+                if dep['name']}
 
     def builddependencies(self):
         """
@@ -1279,7 +1281,7 @@ class EasyConfig:
                 else:
                     self.log.debug("Found easyconfig for toolchain %s version %s: %s", tcname, tcversion, tc_ecfile)
                     tc_ec = process_easyconfig(tc_ecfile)[0]
-                    tcdeps = tc_ec['ec'].dependencies()
+                    tcdeps = tc_ec['ec'].dependencies(runtime_only=True)
                     self.log.debug("Toolchain dependencies based on easyconfig: %s", tcdeps)
 
             self._toolchain = get_toolchain(self['toolchain'], self['toolchainopts'],

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/framework/easyconfig/templates.py

@@ -33,14 +33,14 @@ Authors:
 * Fotis Georgatos (Uni.Lu, NTUA)
 * Kenneth Hoste (Ghent University)
 """
-import re
+import os
 import platform
+import re
 
 from easybuild.base import fancylogger
 from easybuild.tools.build_log import EasyBuildError
-from easybuild.tools.systemtools import get_shared_lib_ext, pick_dep_version
 from easybuild.tools.config import build_option
-
+from easybuild.tools.systemtools import get_shared_lib_ext, pick_dep_version
 
 _log = fancylogger.getLogger('easyconfig.templates', fname=False)
 
@@ -50,9 +50,12 @@ TEMPLATE_NAMES_EASYCONFIG = {
     'nameletter': 'First letter of software name',
     'toolchain_name': 'Toolchain name',
     'toolchain_version': 'Toolchain version',
+    'version_major_minor_patch': "Major.Minor.Patch version",
     'version_major_minor': "Major.Minor version",
     'version_major': 'Major version',
+    'version_minor_patch': 'Minor.Patch version',
     'version_minor': 'Minor version',
+    'version_patch': 'Patch version',
 }
 # derived from EasyConfig._config
 TEMPLATE_NAMES_CONFIG = [
@@ -85,6 +88,10 @@ TEMPLATE_SOFTWARE_VERSIONS = {
     'Python': 'py',
     'R': 'r',
 }
+TEMPLATE_CUDA_VERSION_NVHPC = [
+    'nvidia_compilers',
+    'NVHPC',
+]
 # template values which are only generated dynamically
 TEMPLATE_NAMES_DYNAMIC = {
     'arch': 'System architecture (e.g. x86_64, aarch64, ppc64le, ...)',
@@ -97,6 +104,7 @@ TEMPLATE_NAMES_DYNAMIC = {
                                  "--cuda-compute-capabilities configuration option or "
                                  "via cuda_compute_capabilities easyconfig parameter",
     'cuda_cc_cmake': 'List of CUDA compute capabilities suitable for use with $CUDAARCHS in CMake 3.18+',
+    'cuda_cc_nvhpc': 'List of CUDA compute capabilities suitable for use with -gpu option in NVHPC compilers',
     'cuda_cc_space_sep': 'Space-separated list of CUDA compute capabilities',
     'cuda_cc_space_sep_no_period':
     "Space-separated list of CUDA compute capabilities, without periods (e.g. '80 90').",
@@ -204,9 +212,12 @@ ALTERNATIVE_EASYCONFIG_TEMPLATES = {
     'r_short_ver': 'rshortver',
     'r_ver': 'rver',
     'toolchain_ver': 'toolchain_version',
+    'ver_maj_min_patch': 'version_major_minor_patch',
     'ver_maj_min': 'version_major_minor',
     'ver_maj': 'version_major',
+    'ver_min_patch': 'version_minor_patch',
     'ver_min': 'version_minor',
+    'ver_patch': 'version_patch',
     'version_prefix': 'versionprefix',
     'version_suffix': 'versionsuffix',
 }
@@ -270,7 +281,10 @@ for ext in EXTENSIONS:
     TEMPLATE_CONSTANTS.update({
         'SOURCE_%s' % suffix: ('%(name)s-%(version)s.' + ext, "Source .%s bundle" % ext),
         'SOURCELOWER_%s' % suffix: ('%(namelower)s-%(version)s.' + ext, "Source .%s bundle with lowercase name" % ext),
+        'VERSION_%s' % suffix: ('%(version)s.' + ext, "Source filename <version>.%s common at GitHub" % ext),
+        'V_VERSION_%s' % suffix: ('v%(version)s.' + ext, "Source filename v<version>.%s common at GitHub" % ext),
     })
+
 for pyver in ('py2.py3', 'py2', 'py3'):
     if pyver == 'py2.py3':
         desc = 'Python 2 & Python 3'
@@ -343,11 +357,16 @@ def template_constant_dict(config, ignore=None, toolchain=None):
                     minor = version[1]
                     template_values['version_minor'] = minor
                     template_values['version_major_minor'] = '.'.join([major, minor])
+                    if len(version) > 2:
+                        patch = version[2]
+                        template_values['version_patch'] = patch
+                        template_values['version_minor_patch'] = '.'.join([minor, patch])
+                        template_values['version_major_minor_patch'] = '.'.join([major, minor, patch])
                 except IndexError:
                     # if there is no minor version, skip it
                     pass
                 # only go through this once
-                ignore.extend(['version_major', 'version_minor', 'version_major_minor'])
+                ignore.extend(name for name in TEMPLATE_NAMES_EASYCONFIG if name.startswith('version_'))
 
         elif name.endswith('letter'):
             # parse first letters
@@ -429,6 +448,17 @@ def template_constant_dict(config, ignore=None, toolchain=None):
                     template_values['%sminver' % pref] = dep_version_parts[1]
                 template_values['%sshortver' % pref] = '.'.join(dep_version_parts[:2])
 
+    # step 2.1: CUDA templates in NVHPC
+    if toolchain is not None and hasattr(toolchain, 'name') and toolchain.name in TEMPLATE_CUDA_VERSION_NVHPC:
+        cuda_version = os.getenv("EBNVHPCCUDAVER", None)
+        if cuda_version:
+            cuda_version_parts = cuda_version.split('.')
+            template_values['cudaver'] = cuda_version
+            template_values['cudamajver'] = cuda_version_parts[0]
+            if len(cuda_version_parts) > 1:
+                template_values['cudaminver'] = cuda_version_parts[1]
+            template_values['cudashortver'] = '.'.join(cuda_version_parts[:2])
+
     # step 3: add remaining from config
     for name in TEMPLATE_NAMES_CONFIG:
         if name in ignore:
@@ -475,6 +505,7 @@ def template_constant_dict(config, ignore=None, toolchain=None):
         template_values['cuda_cc_space_sep_no_period'] = ' '.join(cc.replace('.', '') for cc in cuda_cc)
         template_values['cuda_cc_semicolon_sep'] = ';'.join(cuda_cc)
         template_values['cuda_cc_cmake'] = ';'.join(cc.replace('.', '') for cc in cuda_cc)
+        template_values['cuda_cc_nvhpc'] = ','.join(f"cc{cc.replace('.', '')}" for cc in cuda_cc)
         int_values = [cc.replace('.', '') for cc in cuda_cc]
         template_values['cuda_int_comma_sep'] = ','.join(int_values)
         template_values['cuda_int_space_sep'] = ' '.join(int_values)

{easybuild_framework-5.1.2 → easybuild_framework-5.2.0}/easybuild/framework/easyconfig/types.py

@@ -541,7 +541,7 @@ def _to_checksum(checksum, list_level=0, allow_dict=True):
                 # When we already are in a tuple no further recursion is allowed -> set list_level very high
                 return tuple(_to_checksum(x, list_level=99, allow_dict=allow_dict) for x in checksum)
             else:
-                return list(_to_checksum(x, list_level=list_level+1, allow_dict=allow_dict) for x in checksum)
+                return [_to_checksum(x, list_level=list_level+1, allow_dict=allow_dict) for x in checksum]
     elif isinstance(checksum, dict) and allow_dict:
         return {key: _to_checksum(value, allow_dict=False) for key, value in checksum.items()}