move EasyConfig.find_dep_version_match to systemtools.pick_dep_version

Author: boegel

easybuild/framework/easyconfig/easyconfig.py

@@ -68,7 +68,7 @@
 from easybuild.tools.module_naming_scheme.utilities import det_hidden_modname, is_valid_module_name
 from easybuild.tools.modules import modules_tool
 from easybuild.tools.py2vs3 import OrderedDict, create_base_metaclass, string_type
-from easybuild.tools.systemtools import check_os_dependency, get_cpu_architecture
+from easybuild.tools.systemtools import check_os_dependency, pick_dep_version
 from easybuild.tools.toolchain.toolchain import SYSTEM_TOOLCHAIN_NAME, is_system_toolchain
 from easybuild.tools.toolchain.toolchain import TOOLCHAIN_CAPABILITIES, TOOLCHAIN_CAPABILITY_CUDA
 from easybuild.tools.toolchain.utilities import get_toolchain, search_toolchain
@@ -1231,31 +1231,6 @@ def get_parsed_multi_deps(self):
 
         return multi_deps
 
-    def find_dep_version_match(self, dep_version):
-        """Identify the correct version for this system from the choices provided. This returns the version to use."""
-        if isinstance(dep_version, string_type):
-            self.log.debug("Version is already a string ('%s'), OK", dep_version)
-            return dep_version
-        elif dep_version is None:
-            self.log.debug("Version is None, OK")
-            return None
-        elif isinstance(dep_version, dict):
-            # figure out matches based on dict keys (after splitting on '=')
-            my_arch_key = 'arch=%s' % get_cpu_architecture()
-            arch_keys = [x for x in dep_version.keys() if x.startswith('arch=')]
-            other_keys = [x for x in dep_version.keys() if x not in arch_keys]
-            if other_keys:
-                raise EasyBuildError("Unexpected keys in version: %s. Only 'arch=' keys are supported", other_keys)
-            if arch_keys:
-                if my_arch_key in dep_version:
-                    ver = dep_version[my_arch_key]
-                    self.log.info("Version selected from %s using key %s: %s", dep_version, my_arch_key, ver)
-                    return ver
-                else:
-                    raise EasyBuildError("No matches for version in %s (looking for %s)", dep_version, my_arch_key)
-
-        raise EasyBuildError("Unknown value type for version: %s", dep_version)
-
     # private method
     def _parse_dependency(self, dep, hidden=False, build_only=False):
         """
@@ -1337,7 +1312,7 @@ def _parse_dependency(self, dep, hidden=False, build_only=False):
             raise EasyBuildError("Dependency %s of unsupported type: %s", dep, type(dep))
 
         # Find the version to use on this system
-        dependency['version'] = self.find_dep_version_match(dependency['version'])
+        dependency['version'] = pick_dep_version(dependency['version'])
 
         if dependency['external_module']:
             # check whether the external module is hidden

easybuild/tools/systemtools.py

@@ -45,6 +45,7 @@
 from easybuild.tools.build_log import EasyBuildError
 from easybuild.tools.config import build_option
 from easybuild.tools.filetools import is_readable, read_file, which
+from easybuild.tools.py2vs3 import string_type
 from easybuild.tools.run import run_cmd
 
 
@@ -864,3 +865,40 @@ def check_python_version():
         raise EasyBuildError("EasyBuild is not compatible (yet) with Python %s", python_ver)
 
     return (python_maj_ver, python_min_ver)
+
+
+def pick_dep_version(dep_version):
+    """
+    Pick the correct dependency version to use for this system.
+    Input can either be:
+    * a string value (or None)
+    * a dict with options to choose from
+
+    Return value is the version to use.
+    """
+    if isinstance(dep_version, string_type):
+        _log.debug("Version is already a string ('%s'), OK", dep_version)
+        result = dep_version
+
+    elif dep_version is None:
+        _log.debug("Version is None, OK")
+        result = None
+
+    elif isinstance(dep_version, dict):
+        # figure out matches based on dict keys (after splitting on '=')
+        my_arch_key = 'arch=%s' % get_cpu_architecture()
+        arch_keys = [x for x in dep_version.keys() if x.startswith('arch=')]
+        other_keys = [x for x in dep_version.keys() if x not in arch_keys]
+        if other_keys:
+            raise EasyBuildError("Unexpected keys in version: %s. Only 'arch=' keys are supported", other_keys)
+        if arch_keys:
+            if my_arch_key in dep_version:
+                result = dep_version[my_arch_key]
+                _log.info("Version selected from %s using key %s: %s", dep_version, my_arch_key, result)
+            else:
+                raise EasyBuildError("No matches for version in %s (looking for %s)", dep_version, my_arch_key)
+
+    else:
+        raise EasyBuildError("Unknown value type for version: %s", dep_version)
+
+    return result

test/framework/systemtools.py

@@ -43,7 +43,7 @@
 from easybuild.tools.systemtools import CPU_FAMILIES, POWER_LE, DARWIN, LINUX, UNKNOWN
 from easybuild.tools.systemtools import CPU_VENDORS, AMD, APM, ARM, CAVIUM, IBM, INTEL
 from easybuild.tools.systemtools import MAX_FREQ_FP, PROC_CPUINFO_FP, PROC_MEMINFO_FP
-from easybuild.tools.systemtools import check_python_version
+from easybuild.tools.systemtools import check_python_version, pick_dep_version
 from easybuild.tools.systemtools import det_parallelism, get_avail_core_count, get_cpu_architecture, get_cpu_family
 from easybuild.tools.systemtools import get_cpu_features, get_cpu_model, get_cpu_speed, get_cpu_vendor
 from easybuild.tools.systemtools import get_gcc_version, get_glibc_version, get_os_type, get_os_name, get_os_version
@@ -837,6 +837,26 @@ def mock_python_ver(py_maj_ver, py_min_ver):
         if sys.version_info[:2] == (2, 6):
             self.assertTrue(stderr.startswith(py26_depr_warning))
 
+    def test_pick_dep_version(self):
+        """Test pick_dep_version function."""
+
+        self.assertEqual(pick_dep_version(None), None)
+        self.assertEqual(pick_dep_version('1.2.3'), '1.2.3')
+
+        dep_ver_dict = {
+            'arch=x86_64': '1.2.3-amd64',
+            'arch=POWER': '1.2.3-ppc64le',
+        }
+
+        st.get_cpu_architecture = lambda: X86_64
+        self.assertEqual(pick_dep_version(dep_ver_dict), '1.2.3-amd64')
+
+        st.get_cpu_architecture = lambda: POWER
+        self.assertEqual(pick_dep_version(dep_ver_dict), '1.2.3-ppc64le')
+
+        error_pattern = "Unknown value type for version"
+        self.assertErrorRegex(EasyBuildError, error_pattern, pick_dep_version, ('1.2.3', '4.5.6'))
+
 
 def suite():
     """ returns all the testcases in this module """