From 6e828206b6d2b415952455edd85d8f033b90a514 Mon Sep 17 00:00:00 2001 From: Todd Gamblin Date: Tue, 31 Dec 2019 16:23:19 -0800 Subject: refactor: cleanup imports in spec.py The imports in `spec.py` are getting to be pretty unwieldy. - [x] Remove all of the `import from` style imports and replace them with `import` or `import as` - [x] Remove a number names that were exported by `spack.spec` that weren't even in `spack.spec` --- lib/spack/spack/cmd/__init__.py | 8 +- lib/spack/spack/concretize.py | 2 +- lib/spack/spack/provider_index.py | 4 +- lib/spack/spack/spec.py | 287 ++++++++++++------------- lib/spack/spack/test/concretize.py | 4 +- lib/spack/spack/test/concretize_preferences.py | 19 +- lib/spack/spack/test/install.py | 3 +- lib/spack/spack/test/spec_semantics.py | 6 +- lib/spack/spack/test/spec_syntax.py | 3 +- 9 files changed, 167 insertions(+), 169 deletions(-) (limited to 'lib') diff --git a/lib/spack/spack/cmd/__init__.py b/lib/spack/spack/cmd/__init__.py index 8034968d2a..ef620c112b 100644 --- a/lib/spack/spack/cmd/__init__.py +++ b/lib/spack/spack/cmd/__init__.py @@ -19,13 +19,13 @@ from llnl.util.tty.color import colorize from llnl.util.filesystem import working_dir import spack.config +import spack.error import spack.extensions import spack.paths import spack.spec import spack.store import spack.util.spack_json as sjson import spack.util.string -from spack.error import SpackError # cmd has a submodule called "list" so preserve the python list module @@ -150,15 +150,15 @@ def parse_specs(args, **kwargs): except spack.spec.SpecParseError as e: msg = e.message + "\n" + str(e.string) + "\n" msg += (e.pos + 2) * " " + "^" - raise SpackError(msg) + raise spack.error.SpackError(msg) - except spack.spec.SpecError as e: + except spack.error.SpecError as e: msg = e.message if e.long_message: msg += e.long_message - raise SpackError(msg) + raise spack.error.SpackError(msg) def elide_list(line_list, max_num=10): diff --git a/lib/spack/spack/concretize.py b/lib/spack/spack/concretize.py index 1eafe8484e..8814d03d06 100644 --- a/lib/spack/spack/concretize.py +++ b/lib/spack/spack/concretize.py @@ -74,7 +74,7 @@ class Concretizer(object): if spec.virtual: candidates = spack.repo.path.providers_for(spec) if not candidates: - raise spack.spec.UnsatisfiableProviderSpecError( + raise spack.error.UnsatisfiableProviderSpecError( candidates[0], spec) # Find nearest spec in the DAG (up then down) that has prefs. diff --git a/lib/spack/spack/provider_index.py b/lib/spack/spack/provider_index.py index 0df3d83e0e..9bf4af8911 100644 --- a/lib/spack/spack/provider_index.py +++ b/lib/spack/spack/provider_index.py @@ -135,7 +135,7 @@ class ProviderIndex(object): for lspec, rspec in iproduct(lmap, rmap): try: constrained = lspec.constrained(rspec) - except spack.spec.UnsatisfiableSpecError: + except spack.error.UnsatisfiableSpecError: continue # lp and rp are left and right provider specs. @@ -144,7 +144,7 @@ class ProviderIndex(object): try: const = lp_spec.constrained(rp_spec, deps=False) result.setdefault(constrained, set()).add(const) - except spack.spec.UnsatisfiableSpecError: + except spack.error.UnsatisfiableSpecError: continue return result diff --git a/lib/spack/spack/spec.py b/lib/spack/spack/spec.py index e0ccd6cb77..363638c7ea 100644 --- a/lib/spack/spack/spec.py +++ b/lib/spack/spack/spec.py @@ -81,18 +81,16 @@ import sys import collections import hashlib import itertools +import operator import os import re import six - -from operator import attrgetter import ruamel.yaml as yaml -from llnl.util.filesystem import find_headers, find_libraries, is_exe -from llnl.util.lang import key_ordering, HashableMap, ObjectWrapper, dedupe -from llnl.util.lang import check_kwargs, memoized -from llnl.util.tty.color import cwrite, colorize, cescape, get_color_when +import llnl.util.filesystem as fs +import llnl.util.lang as lang +import llnl.util.tty.color as clr import llnl.util.tty as tty import spack.paths @@ -103,48 +101,34 @@ import spack.dependency as dp import spack.error import spack.hash_types as ht import spack.parse +import spack.provider_index import spack.repo import spack.store +import spack.util.crypto +import spack.util.executable +import spack.util.module_cmd as md +import spack.util.prefix import spack.util.spack_json as sjson import spack.util.spack_yaml as syaml - -from spack.util.module_cmd import get_path_from_module, load_module -from spack.error import NoLibrariesError, NoHeadersError -from spack.error import SpecError, UnsatisfiableSpecError -from spack.provider_index import ProviderIndex -from spack.util.crypto import prefix_bits -from spack.util.executable import Executable -from spack.util.prefix import Prefix -from spack.util.spack_yaml import syaml_dict -from spack.util.string import comma_or -from spack.variant import MultiValuedVariant, AbstractVariant -from spack.variant import BoolValuedVariant, substitute_abstract_variants -from spack.variant import VariantMap, UnknownVariantError -from spack.variant import DuplicateVariantError -from spack.variant import UnsatisfiableVariantSpecError -from spack.version import VersionList, VersionRange, Version, ver -from ruamel.yaml.error import MarkedYAMLError +import spack.util.string +import spack.variant as vt +import spack.version as vn __all__ = [ 'Spec', 'parse', - 'SpecError', 'SpecParseError', 'DuplicateDependencyError', - 'DuplicateVariantError', 'DuplicateCompilerSpecError', 'UnsupportedCompilerError', - 'UnknownVariantError', 'DuplicateArchitectureError', 'InconsistentSpecError', 'InvalidDependencyError', 'NoProviderError', 'MultipleProviderError', - 'UnsatisfiableSpecError', 'UnsatisfiableSpecNameError', 'UnsatisfiableVersionSpecError', 'UnsatisfiableCompilerSpecError', - 'UnsatisfiableVariantSpecError', 'UnsatisfiableCompilerFlagSpecError', 'UnsatisfiableArchitectureSpecError', 'UnsatisfiableProviderSpecError', @@ -183,7 +167,7 @@ _separators = '[\\%s]' % '\\'.join(color_formats.keys()) #: Versionlist constant so we don't have to build a list #: every time we call str() -_any_version = VersionList([':']) +_any_version = vn.VersionList([':']) default_format = '{name}{@version}' default_format += '{%compiler.name}{@compiler.version}{compiler_flags}' @@ -202,15 +186,15 @@ def colorize_spec(spec): # ignore compiler versions (color same as compiler) sep = match.group(0) if self.last == '%' and sep == '@': - return cescape(sep) + return clr.cescape(sep) self.last = sep - return '%s%s' % (color_formats[sep], cescape(sep)) + return '%s%s' % (color_formats[sep], clr.cescape(sep)) - return colorize(re.sub(_separators, insert_color(), str(spec)) + '@.') + return clr.colorize(re.sub(_separators, insert_color(), str(spec)) + '@.') -@key_ordering +@lang.key_ordering class ArchSpec(object): def __init__(self, spec_or_platform_tuple=(None, None, None)): """ Architecture specification a package should be built with. @@ -444,11 +428,11 @@ class ArchSpec(object): return self.platform and self.os and self.target def to_dict(self): - d = syaml_dict([ + d = syaml.syaml_dict([ ('platform', self.platform), ('platform_os', self.os), ('target', self.target.to_dict_or_value())]) - return syaml_dict([('arch', d)]) + return syaml.syaml_dict([('arch', d)]) @staticmethod def from_dict(d): @@ -487,7 +471,7 @@ class ArchSpec(object): return string in str(self) or string in self.target -@key_ordering +@lang.key_ordering class CompilerSpec(object): """The CompilerSpec field represents the compiler or range of compiler versions that a package should be built with. CompilerSpecs have a @@ -516,8 +500,8 @@ class CompilerSpec(object): elif nargs == 2: name, version = args self.name = name - self.versions = VersionList() - self.versions.add(ver(version)) + self.versions = vn.VersionList() + self.versions.add(vn.ver(version)) else: raise TypeError( @@ -558,7 +542,7 @@ class CompilerSpec(object): @property def version(self): if not self.concrete: - raise SpecError("Spec is not concrete: " + str(self)) + raise spack.error.SpecError("Spec is not concrete: " + str(self)) return self.versions[0] def copy(self): @@ -571,15 +555,15 @@ class CompilerSpec(object): return (self.name, self.versions) def to_dict(self): - d = syaml_dict([('name', self.name)]) + d = syaml.syaml_dict([('name', self.name)]) d.update(self.versions.to_dict()) - return syaml_dict([('compiler', d)]) + return syaml.syaml_dict([('compiler', d)]) @staticmethod def from_dict(d): d = d['compiler'] - return CompilerSpec(d['name'], VersionList.from_dict(d)) + return CompilerSpec(d['name'], vn.VersionList.from_dict(d)) def __str__(self): out = self.name @@ -592,7 +576,7 @@ class CompilerSpec(object): return str(self) -@key_ordering +@lang.key_ordering class DependencySpec(object): """DependencySpecs connect two nodes in the DAG, and contain deptypes. @@ -640,7 +624,7 @@ _valid_compiler_flags = [ 'cflags', 'cxxflags', 'fflags', 'ldflags', 'ldlibs', 'cppflags'] -class FlagMap(HashableMap): +class FlagMap(lang.HashableMap): def __init__(self, spec): super(FlagMap, self).__init__() @@ -698,7 +682,7 @@ class FlagMap(HashableMap): for key in sorted_keys) + cond_symbol -class DependencyMap(HashableMap): +class DependencyMap(lang.HashableMap): """Each spec has a DependencyMap containing specs for its dependencies. The DependencyMap is keyed by name. """ @@ -725,8 +709,8 @@ def _command_default_handler(descriptor, spec, cls): """ path = os.path.join(spec.prefix.bin, spec.name) - if is_exe(path): - return Executable(path) + if fs.is_exe(path): + return spack.util.executable.Executable(path) else: msg = 'Unable to locate {0} command in {1}' raise RuntimeError(msg.format(spec.name, spec.prefix.bin)) @@ -750,13 +734,14 @@ def _headers_default_handler(descriptor, spec, cls): Raises: NoHeadersError: If no headers are found """ - headers = find_headers('*', root=spec.prefix.include, recursive=True) + headers = fs.find_headers('*', root=spec.prefix.include, recursive=True) if headers: return headers else: msg = 'Unable to locate {0} headers in {1}' - raise NoHeadersError(msg.format(spec.name, spec.prefix.include)) + raise spack.error.NoHeadersError( + msg.format(spec.name, spec.prefix.include)) def _libs_default_handler(descriptor, spec, cls): @@ -801,12 +786,13 @@ def _libs_default_handler(descriptor, spec, cls): ([False] if ('~shared' in spec) else [True, False]) for shared in search_shared: - libs = find_libraries(name, spec.prefix, shared=shared, recursive=True) + libs = fs.find_libraries( + name, spec.prefix, shared=shared, recursive=True) if libs: return libs msg = 'Unable to recursively locate {0} libraries in {1}' - raise NoLibrariesError(msg.format(spec.name, spec.prefix)) + raise spack.error.NoLibrariesError(msg.format(spec.name, spec.prefix)) class ForwardQueryToPackage(object): @@ -920,7 +906,7 @@ class ForwardQueryToPackage(object): raise AttributeError(msg.format(cls_name, self.attribute_name)) -class SpecBuildInterface(ObjectWrapper): +class SpecBuildInterface(lang.ObjectWrapper): command = ForwardQueryToPackage( 'command', default_handler=_command_default_handler @@ -952,7 +938,7 @@ class SpecBuildInterface(ObjectWrapper): ) -@key_ordering +@lang.key_ordering class Spec(object): #: Cache for spec's prefix, computed lazily in the corresponding property @@ -985,8 +971,8 @@ class Spec(object): # init an empty spec that matches anything. self.name = None - self.versions = VersionList(':') - self.variants = VariantMap(self) + self.versions = vn.VersionList(':') + self.variants = vt.VariantMap(self) self.architecture = None self.compiler = None self.external_path = None @@ -1088,9 +1074,9 @@ class Spec(object): # map to '+foo' and '~foo' respectively. As such they need a # BoolValuedVariant instance. if str(value).upper() == 'TRUE' or str(value).upper() == 'FALSE': - self.variants[name] = BoolValuedVariant(name, value) + self.variants[name] = vt.BoolValuedVariant(name, value) else: - self.variants[name] = AbstractVariant(name, value) + self.variants[name] = vt.AbstractVariant(name, value) def _set_architecture(self, **kwargs): """Called by the parser to set the architecture.""" @@ -1256,7 +1242,7 @@ class Spec(object): depth = kwargs.get('depth', False) key_fun = kwargs.get('key', id) if isinstance(key_fun, six.string_types): - key_fun = attrgetter(key_fun) + key_fun = operator.attrgetter(key_fun) yield_root = kwargs.get('root', True) cover = kwargs.get('cover', 'nodes') direction = kwargs.get('direction', 'children') @@ -1340,7 +1326,7 @@ class Spec(object): @property def prefix(self): if not self._concrete: - raise SpecError("Spec is not concrete: " + str(self)) + raise spack.error.SpecError("Spec is not concrete: " + str(self)) if self._prefix is None: upstream, record = spack.store.db.query_by_spec_hash( @@ -1353,7 +1339,7 @@ class Spec(object): @prefix.setter def prefix(self, value): - self._prefix = Prefix(value) + self._prefix = spack.util.prefix.Prefix(value) def _spec_hash(self, hash): """Utility method for computing different types of Spec hashes. @@ -1481,7 +1467,7 @@ class Spec(object): Arguments: hash (SpecHashDescriptor) type of hash to generate. """ - d = syaml_dict() + d = syaml.syaml_dict() if self.versions: d.update(self.versions.to_dict()) @@ -1495,7 +1481,7 @@ class Spec(object): if self.namespace: d['namespace'] = self.namespace - params = syaml_dict( + params = syaml.syaml_dict( sorted( v.yaml_entry() for _, v in self.variants.items() ) @@ -1524,15 +1510,15 @@ class Spec(object): deps = self.dependencies_dict(deptype=hash.deptype) if deps: - d['dependencies'] = syaml_dict([ + d['dependencies'] = syaml.syaml_dict([ (name, - syaml_dict([ + syaml.syaml_dict([ ('hash', dspec.spec._cached_hash(hash)), ('type', sorted(str(s) for s in dspec.deptypes))]) ) for name, dspec in sorted(deps.items()) ]) - return syaml_dict([(self.name, d)]) + return syaml.syaml_dict([(self.name, d)]) def to_dict(self, hash=ht.dag_hash): """Create a dictionary suitable for writing this spec to YAML or JSON. @@ -1607,7 +1593,7 @@ class Spec(object): node[s.name]['build_hash'] = s.build_hash() node_list.append(node) - return syaml_dict([('spec', node_list)]) + return syaml.syaml_dict([('spec', node_list)]) def to_record_dict(self): """Return a "flat" dictionary with name and hash as top-level keys. @@ -1628,7 +1614,7 @@ class Spec(object): But is otherwise the same as ``to_node_dict()``. """ - dictionary = syaml_dict() + dictionary = syaml.syaml_dict() dictionary["name"] = self.name dictionary["hash"] = self.dag_hash() dictionary.update(self.to_node_dict()[self.name]) @@ -1652,7 +1638,7 @@ class Spec(object): spec._build_hash = node.get('build_hash', None) if 'version' in node or 'versions' in node: - spec.versions = VersionList.from_dict(node) + spec.versions = vn.VersionList.from_dict(node) if 'arch' in node: spec.architecture = ArchSpec.from_dict(node) @@ -1667,11 +1653,11 @@ class Spec(object): if name in _valid_compiler_flags: spec.compiler_flags[name] = value else: - spec.variants[name] = MultiValuedVariant.from_node_dict( + spec.variants[name] = vt.MultiValuedVariant.from_node_dict( name, value) elif 'variants' in node: for name, value in node['variants'].items(): - spec.variants[name] = MultiValuedVariant.from_node_dict( + spec.variants[name] = vt.MultiValuedVariant.from_node_dict( name, value ) for name in FlagMap.valid_compiler_flags(): @@ -1700,7 +1686,7 @@ class Spec(object): patches = node['patches'] if len(patches) > 0: mvar = spec.variants.setdefault( - 'patches', MultiValuedVariant('patches', ()) + 'patches', vt.MultiValuedVariant('patches', ()) ) mvar.value = patches # FIXME: Monkey patches mvar to store patches order @@ -1738,7 +1724,8 @@ class Spec(object): # new format: elements of dependency spec are keyed. dag_hash, deptypes = elt['hash'], elt['type'] else: - raise SpecError("Couldn't parse dependency types in spec.") + raise spack.error.SpecError( + "Couldn't parse dependency types in spec.") yield dep_name, dag_hash, list(deptypes) @@ -1907,7 +1894,7 @@ class Spec(object): # dependencies are the following elements. dep_list = [Spec.from_node_dict(node) for node in nodes] if not dep_list: - raise SpecError("YAML spec contains no nodes.") + raise spack.error.SpecError("YAML spec contains no nodes.") deps = dict((spec.name, spec) for spec in dep_list) spec = dep_list[0] @@ -1936,7 +1923,7 @@ class Spec(object): try: data = yaml.load(stream) return Spec.from_dict(data) - except MarkedYAMLError as e: + except yaml.error.MarkedYAMLError as e: raise syaml.SpackYAMLError("error parsing YAML spec:", str(e)) @staticmethod @@ -2032,7 +2019,8 @@ class Spec(object): a problem. """ # Make an index of stuff this spec already provides - self_index = ProviderIndex(self.traverse(), restrict=True) + self_index = spack.provider_index.ProviderIndex( + self.traverse(), restrict=True) changed = False done = False @@ -2072,7 +2060,7 @@ class Spec(object): # constraints. copy.normalize(force=True) break - except SpecError: + except spack.error.SpecError: # On error, we'll try the next replacement. continue @@ -2133,7 +2121,8 @@ class Spec(object): normalize() for more details on this. """ if not self.name: - raise SpecError("Attempting to concretize anonymous spec") + raise spack.error.SpecError( + "Attempting to concretize anonymous spec") if self._concrete: return @@ -2214,9 +2203,9 @@ class Spec(object): if id(spec) not in spec_to_patches: continue - patches = list(dedupe(spec_to_patches[id(spec)])) + patches = list(lang.dedupe(spec_to_patches[id(spec)])) mvar = spec.variants.setdefault( - 'patches', MultiValuedVariant('patches', ()) + 'patches', vt.MultiValuedVariant('patches', ()) ) mvar.value = tuple(p.sha256 for p in patches) # FIXME: Monkey patches mvar to store patches order @@ -2234,9 +2223,9 @@ class Spec(object): compiler = spack.compilers.compiler_for_spec( s.compiler, s.architecture) for mod in compiler.modules: - load_module(mod) + md.load_module(mod) - s.external_path = get_path_from_module(s.external_module) + s.external_path = md.get_path_from_module(s.external_module) # Mark everything in the spec as concrete, as well. self._mark_concrete() @@ -2336,7 +2325,7 @@ class Spec(object): return flat_deps - except UnsatisfiableSpecError as e: + except spack.error.UnsatisfiableSpecError as e: # Here, the DAG contains two instances of the same package # with inconsistent constraints. Users cannot produce # inconsistent specs like this on the command line: the @@ -2369,7 +2358,7 @@ class Spec(object): """ conditions = self.package_class.dependencies[name] - substitute_abstract_variants(self) + vt.substitute_abstract_variants(self) # evaluate when specs to figure out constraints on the dependency. dep = None for when_spec, dependency in conditions.items(): @@ -2378,7 +2367,7 @@ class Spec(object): dep = dp.Dependency(self.name, Spec(name), type=()) try: dep.merge(dependency) - except UnsatisfiableSpecError as e: + except spack.error.UnsatisfiableSpecError as e: e.message = ( "Conflicting conditional dependencies for spec" "\n\n\t{0}\n\n" @@ -2468,7 +2457,7 @@ class Spec(object): if provider: dep = provider else: - index = ProviderIndex([dep], restrict=True) + index = spack.provider_index.ProviderIndex([dep], restrict=True) items = list(spec_deps.items()) for name, vspec in items: if not vspec.virtual: @@ -2498,7 +2487,7 @@ class Spec(object): # merge package/vdep information into spec try: changed |= spec_deps[dep.name].constrain(dep) - except UnsatisfiableSpecError as e: + except spack.error.UnsatisfiableSpecError as e: fmt = 'An unsatisfiable {0}'.format(e.constraint_type) fmt += ' constraint has been detected for spec:' fmt += '\n\n{0}\n\n'.format(spec_deps[dep.name].tree(indent=4)) @@ -2585,7 +2574,8 @@ class Spec(object): detection, to ensure that the spec is actually a DAG. """ if not self.name: - raise SpecError("Attempting to normalize anonymous spec") + raise spack.error.SpecError( + "Attempting to normalize anonymous spec") # Set _normal and _concrete to False when forced if force: @@ -2615,7 +2605,7 @@ class Spec(object): # Initialize index of virtual dependency providers if # concretize didn't pass us one already - provider_index = ProviderIndex( + provider_index = spack.provider_index.ProviderIndex( [s for s in all_spec_deps.values()], restrict=True) # traverse the package DAG and fill out dependencies according @@ -2663,9 +2653,9 @@ class Spec(object): not_existing = set(spec.variants) - ( set(pkg_variants) | set(spack.directives.reserved_names)) if not_existing: - raise UnknownVariantError(spec, not_existing) + raise vt.UnknownVariantError(spec, not_existing) - substitute_abstract_variants(spec) + vt.substitute_abstract_variants(spec) def constrain(self, other, deps=True): """Merge the constraints of other with self. @@ -2679,7 +2669,7 @@ class Spec(object): if self.satisfies(other): return False else: - raise UnsatisfiableSpecError( + raise spack.error.UnsatisfiableSpecError( self, other, 'constrain a concrete spec' ) @@ -2700,7 +2690,7 @@ class Spec(object): for v in [x for x in other.variants if x in self.variants]: if not self.variants[v].compatible(other.variants[v]): - raise UnsatisfiableVariantSpecError( + raise vt.UnsatisfiableVariantSpecError( self.variants[v], other.variants[v] ) @@ -2928,8 +2918,10 @@ class Spec(object): return False # For virtual dependencies, we need to dig a little deeper. - self_index = ProviderIndex(self.traverse(), restrict=True) - other_index = ProviderIndex(other.traverse(), restrict=True) + self_index = spack.provider_index.ProviderIndex( + self.traverse(), restrict=True) + other_index = spack.provider_index.ProviderIndex( + other.traverse(), restrict=True) # This handles cases where there are already providers for both vpkgs if not self_index.satisfies(other_index): @@ -2954,7 +2946,7 @@ class Spec(object): return [spec for spec in self.traverse() if spec.virtual] @property - @memoized + @lang.memoized def patches(self): """Return patch objects for any patch sha256 sums on this Spec. @@ -2965,7 +2957,7 @@ class Spec(object): patches from install directories, but it probably should. """ if not self.concrete: - raise SpecError("Spec is not concrete: " + str(self)) + raise spack.error.SpecError("Spec is not concrete: " + str(self)) if 'patches' not in self.variants: return [] @@ -3135,7 +3127,8 @@ class Spec(object): @property def version(self): if not self.versions.concrete: - raise SpecError("Spec version is not concrete: " + str(self)) + raise spack.error.SpecError( + "Spec version is not concrete: " + str(self)) return self.versions[0] def __getitem__(self, name): @@ -3375,10 +3368,10 @@ class Spec(object): out = six.StringIO() def write(s, c=None): - f = cescape(s) + f = clr.cescape(s) if c is not None: f = color_formats[c] + f + '@.' - cwrite(f, stream=out, color=color) + clr.cwrite(f, stream=out, color=color) def write_attribute(spec, attribute, color): current = spec @@ -3445,7 +3438,7 @@ class Spec(object): 'Attempted to format private attribute' ) else: - if isinstance(current, VariantMap): + if isinstance(current, vt.VariantMap): # subscript instead of getattr for variant names current = current[part] else: @@ -3463,7 +3456,7 @@ class Spec(object): m = 'Attempted to format attribute %s.' % attribute m += 'Spec.%s has no attribute %s' % (parent, part) raise SpecFormatStringError(m) - if isinstance(current, VersionList): + if isinstance(current, vn.VersionList): if current == _any_version: # We don't print empty version lists return @@ -3609,10 +3602,10 @@ class Spec(object): named_str = fmt = '' def write(s, c=None): - f = cescape(s) + f = clr.cescape(s) if c is not None: f = color_formats[c] + f + '@.' - cwrite(f, stream=out, color=color) + clr.cwrite(f, stream=out, color=color) iterator = enumerate(format_string) for i, c in iterator: @@ -3807,7 +3800,7 @@ class Spec(object): def tree(self, **kwargs): """Prints out this spec and its dependencies, tree-formatted with indentation.""" - color = kwargs.pop('color', get_color_when()) + color = kwargs.pop('color', clr.get_color_when()) depth = kwargs.pop('depth', False) hashes = kwargs.pop('hashes', False) hlen = kwargs.pop('hashlen', None) @@ -3819,7 +3812,7 @@ class Spec(object): show_types = kwargs.pop('show_types', False) deptypes = kwargs.pop('deptypes', 'all') recurse_dependencies = kwargs.pop('recurse_dependencies', True) - check_kwargs(kwargs, self.tree) + lang.check_kwargs(kwargs, self.tree) out = "" for d, dep_spec in self.traverse_edges( @@ -3836,16 +3829,17 @@ class Spec(object): if status_fn: status = status_fn(node) if node.package.installed_upstream: - out += colorize("@g{[^]} ", color=color) + out += clr.colorize("@g{[^]} ", color=color) elif status is None: - out += colorize("@K{ - } ", color=color) # not installed + out += clr.colorize("@K{ - } ", color=color) # !installed elif status: - out += colorize("@g{[+]} ", color=color) # installed + out += clr.colorize("@g{[+]} ", color=color) # installed else: - out += colorize("@r{[-]} ", color=color) # missing + out += clr.colorize("@r{[-]} ", color=color) # missing if hashes: - out += colorize('@K{%s} ', color=color) % node.dag_hash(hlen) + out += clr.colorize( + '@K{%s} ', color=color) % node.dag_hash(hlen) if show_types: types = set() @@ -4157,17 +4151,17 @@ class SpecParser(spack.parse.Parser): while self.next: if self.accept(AT): vlist = self.version_list() - spec.versions = VersionList() + spec.versions = vn.VersionList() for version in vlist: spec._add_version(version) elif self.accept(ON): name = self.variant() - spec.variants[name] = BoolValuedVariant(name, True) + spec.variants[name] = vt.BoolValuedVariant(name, True) elif self.accept(OFF): name = self.variant() - spec.variants[name] = BoolValuedVariant(name, False) + spec.variants[name] = vt.BoolValuedVariant(name, False) elif self.accept(PCT): spec._set_compiler(self.compiler()) @@ -4223,16 +4217,16 @@ class SpecParser(spack.parse.Parser): end = self.token.value elif start: # No colon, but there was a version. - return Version(start) + return vn.Version(start) else: # No colon and no id: invalid version. self.next_token_error("Invalid version specifier") if start: - start = Version(start) + start = vn.Version(start) if end: - end = Version(end) - return VersionRange(start, end) + end = vn.Version(end) + return vn.VersionRange(start, end) def version_list(self): vlist = [] @@ -4247,13 +4241,13 @@ class SpecParser(spack.parse.Parser): compiler = CompilerSpec.__new__(CompilerSpec) compiler.name = self.token.value - compiler.versions = VersionList() + compiler.versions = vn.VersionList() if self.accept(AT): vlist = self.version_list() for version in vlist: compiler._add_version(version) else: - compiler.versions = VersionList(':') + compiler.versions = vn.VersionList(':') return compiler def check_identifier(self, id=None): @@ -4309,10 +4303,10 @@ def base32_prefix_bits(hash_string, bits): % (bits, hash_string)) hash_bytes = base64.b32decode(hash_string, casefold=True) - return prefix_bits(hash_bytes, bits) + return spack.util.crypto.prefix_bits(hash_bytes, bits) -class SpecParseError(SpecError): +class SpecParseError(spack.error.SpecError): """Wrapper for ParseError for when we're parsing specs.""" def __init__(self, parse_error): super(SpecParseError, self).__init__(parse_error.message) @@ -4320,40 +4314,41 @@ class SpecParseError(SpecError): self.pos = parse_error.pos -class DuplicateDependencyError(SpecError): +class DuplicateDependencyError(spack.error.SpecError): """Raised when the same dependency occurs in a spec twice.""" -class DuplicateCompilerSpecError(SpecError): +class DuplicateCompilerSpecError(spack.error.SpecError): """Raised when the same compiler occurs in a spec twice.""" -class UnsupportedCompilerError(SpecError): +class UnsupportedCompilerError(spack.error.SpecError): """Raised when the user asks for a compiler spack doesn't know about.""" def __init__(self, compiler_name): super(UnsupportedCompilerError, self).__init__( "The '%s' compiler is not yet supported." % compiler_name) -class DuplicateArchitectureError(SpecError): +class DuplicateArchitectureError(spack.error.SpecError): """Raised when the same architecture occurs in a spec twice.""" -class InconsistentSpecError(SpecError): +class InconsistentSpecError(spack.error.SpecError): """Raised when two nodes in the same spec DAG have inconsistent constraints.""" -class InvalidDependencyError(SpecError): +class InvalidDependencyError(spack.error.SpecError): """Raised when a dependency in a spec is not actually a dependency of the package.""" def __init__(self, pkg, deps): self.invalid_deps = deps super(InvalidDependencyError, self).__init__( - 'Package {0} does not depend on {1}'.format(pkg, comma_or(deps))) + 'Package {0} does not depend on {1}'.format( + pkg, spack.util.string.comma_or(deps))) -class NoProviderError(SpecError): +class NoProviderError(spack.error.SpecError): """Raised when there is no package that provides a particular virtual dependency. """ @@ -4363,7 +4358,7 @@ class NoProviderError(SpecError): self.vpkg = vpkg -class MultipleProviderError(SpecError): +class MultipleProviderError(spack.error.SpecError): """Raised when there is no package that provides a particular virtual dependency. """ @@ -4376,42 +4371,42 @@ class MultipleProviderError(SpecError): self.providers = providers -class UnsatisfiableSpecNameError(UnsatisfiableSpecError): +class UnsatisfiableSpecNameError(spack.error.UnsatisfiableSpecError): """Raised when two specs aren't even for the same package.""" def __init__(self, provided, required): super(UnsatisfiableSpecNameError, self).__init__( provided, required, "name") -class UnsatisfiableVersionSpecError(UnsatisfiableSpecError): +class UnsatisfiableVersionSpecError(spack.error.UnsatisfiableSpecError): """Raised when a spec version conflicts with package constraints.""" def __init__(self, provided, required): super(UnsatisfiableVersionSpecError, self).__init__( provided, required, "version") -class UnsatisfiableCompilerSpecError(UnsatisfiableSpecError): +class UnsatisfiableCompilerSpecError(spack.error.UnsatisfiableSpecError): """Raised when a spec comiler conflicts with package constraints.""" def __init__(self, provided, required): super(UnsatisfiableCompilerSpecError, self).__init__( provided, required, "compiler") -class UnsatisfiableCompilerFlagSpecError(UnsatisfiableSpecError): +class UnsatisfiableCompilerFlagSpecError(spack.error.UnsatisfiableSpecError): """Raised when a spec variant conflicts with package constraints.""" def __init__(self, provided, required): super(UnsatisfiableCompilerFlagSpecError, self).__init__( provided, required, "compiler_flags") -class UnsatisfiableArchitectureSpecError(UnsatisfiableSpecError): +class UnsatisfiableArchitectureSpecError(spack.error.UnsatisfiableSpecError): """Raised when a spec architecture conflicts with package constraints.""" def __init__(self, provided, required): super(UnsatisfiableArchitectureSpecError, self).__init__( provided, required, "architecture") -class UnsatisfiableProviderSpecError(UnsatisfiableSpecError): +class UnsatisfiableProviderSpecError(spack.error.UnsatisfiableSpecError): """Raised when a provider is supplied but constraints don't match a vpkg requirement""" def __init__(self, provided, required): @@ -4421,14 +4416,14 @@ class UnsatisfiableProviderSpecError(UnsatisfiableSpecError): # TODO: get rid of this and be more specific about particular incompatible # dep constraints -class UnsatisfiableDependencySpecError(UnsatisfiableSpecError): +class UnsatisfiableDependencySpecError(spack.error.UnsatisfiableSpecError): """Raised when some dependency of constrained specs are incompatible""" def __init__(self, provided, required): super(UnsatisfiableDependencySpecError, self).__init__( provided, required, "dependency") -class AmbiguousHashError(SpecError): +class AmbiguousHashError(spack.error.SpecError): def __init__(self, msg, *specs): spec_fmt = '{namespace}.{name}{@version}{%compiler}{compiler_flags}' spec_fmt += '{variants}{arch=architecture}{/hash:7}' @@ -4437,21 +4432,21 @@ class AmbiguousHashError(SpecError): super(AmbiguousHashError, self).__init__(msg + specs_str) -class InvalidHashError(SpecError): +class InvalidHashError(spack.error.SpecError): def __init__(self, spec, hash): super(InvalidHashError, self).__init__( "The spec specified by %s does not match provided spec %s" % (hash, spec)) -class NoSuchHashError(SpecError): +class NoSuchHashError(spack.error.SpecError): def __init__(self, hash): super(NoSuchHashError, self).__init__( "No installed spec matches the hash: '%s'" % hash) -class SpecFilenameError(SpecError): +class SpecFilenameError(spack.error.SpecError): """Raised when a spec file name is invalid.""" @@ -4459,7 +4454,7 @@ class NoSuchSpecFileError(SpecFilenameError): """Raised when a spec file doesn't exist.""" -class RedundantSpecError(SpecError): +class RedundantSpecError(spack.error.SpecError): def __init__(self, spec, addition): super(RedundantSpecError, self).__init__( "Attempting to add %s to spec %s which is already concrete." @@ -4467,7 +4462,7 @@ class RedundantSpecError(SpecError): % (addition, spec)) -class SpecFormatStringError(SpecError): +class SpecFormatStringError(spack.error.SpecError): """Called for errors in Spec format strings.""" @@ -4479,7 +4474,7 @@ class SpecFormatSigilError(SpecFormatStringError): super(SpecFormatSigilError, self).__init__(msg) -class ConflictsInSpecError(SpecError, RuntimeError): +class ConflictsInSpecError(spack.error.SpecError, RuntimeError): def __init__(self, spec, matches): message = 'Conflicts in concretized spec "{0}"\n'.format( spec.short_spec @@ -4507,10 +4502,10 @@ class ConflictsInSpecError(SpecError, RuntimeError): super(ConflictsInSpecError, self).__init__(message, long_message) -class SpecDependencyNotFoundError(SpecError): +class SpecDependencyNotFoundError(spack.error.SpecError): """Raised when a failure is encountered writing the dependencies of a spec.""" -class SpecDeprecatedError(SpecError): +class SpecDeprecatedError(spack.error.SpecError): """Raised when a spec concretizes to a deprecated spec or dependency.""" diff --git a/lib/spack/spack/test/concretize.py b/lib/spack/spack/test/concretize.py index 5575d160a5..72092a956f 100644 --- a/lib/spack/spack/test/concretize.py +++ b/lib/spack/spack/test/concretize.py @@ -11,9 +11,9 @@ import spack.concretize import spack.repo from spack.concretize import find_spec, NoValidVersionError +from spack.error import SpecError from spack.package_prefs import PackagePrefs -from spack.spec import Spec, CompilerSpec -from spack.spec import ConflictsInSpecError, SpecError +from spack.spec import Spec, CompilerSpec, ConflictsInSpecError from spack.version import ver from spack.test.conftest import MockPackage, MockPackageMultiRepo import spack.compilers diff --git a/lib/spack/spack/test/concretize_preferences.py b/lib/spack/spack/test/concretize_preferences.py index d1057c5d7c..0d0d870506 100644 --- a/lib/spack/spack/test/concretize_preferences.py +++ b/lib/spack/spack/test/concretize_preferences.py @@ -11,6 +11,7 @@ import spack.repo import spack.util.spack_yaml as syaml from spack.config import ConfigScope, ConfigError from spack.spec import Spec +from spack.version import Version @pytest.fixture() @@ -119,16 +120,16 @@ class TestConcretizePreferences(object): """ update_packages('mpileaks', 'version', ['2.3']) spec = concretize('mpileaks') - assert spec.version == spack.spec.Version('2.3') + assert spec.version == Version('2.3') update_packages('mpileaks', 'version', ['2.2']) spec = concretize('mpileaks') - assert spec.version == spack.spec.Version('2.2') + assert spec.version == Version('2.2') def test_preferred_versions_mixed_version_types(self): update_packages('mixedversions', 'version', ['2.0']) spec = concretize('mixedversions') - assert spec.version == spack.spec.Version('2.0') + assert spec.version == Version('2.0') def test_preferred_providers(self): """Test preferred providers of virtual packages are @@ -146,35 +147,35 @@ class TestConcretizePreferences(object): """"Test packages with some version marked as preferred=True""" spec = Spec('preferred-test') spec.concretize() - assert spec.version == spack.spec.Version('0.2.15') + assert spec.version == Version('0.2.15') # now add packages.yaml with versions other than preferred # ensure that once config is in place, non-preferred version is used update_packages('preferred-test', 'version', ['0.2.16']) spec = Spec('preferred-test') spec.concretize() - assert spec.version == spack.spec.Version('0.2.16') + assert spec.version == Version('0.2.16') def test_develop(self): """Test concretization with develop-like versions""" spec = Spec('develop-test') spec.concretize() - assert spec.version == spack.spec.Version('0.2.15') + assert spec.version == Version('0.2.15') spec = Spec('develop-test2') spec.concretize() - assert spec.version == spack.spec.Version('0.2.15') + assert spec.version == Version('0.2.15') # now add packages.yaml with develop-like versions # ensure that once config is in place, develop-like version is used update_packages('develop-test', 'version', ['develop']) spec = Spec('develop-test') spec.concretize() - assert spec.version == spack.spec.Version('develop') + assert spec.version == Version('develop') update_packages('develop-test2', 'version', ['0.2.15.develop']) spec = Spec('develop-test2') spec.concretize() - assert spec.version == spack.spec.Version('0.2.15.develop') + assert spec.version == Version('0.2.15.develop') def test_no_virtuals_in_packages_yaml(self): """Verify that virtuals are not allowed in packages.yaml.""" diff --git a/lib/spack/spack/test/install.py b/lib/spack/spack/test/install.py index ebbc540abb..8877e785d3 100644 --- a/lib/spack/spack/test/install.py +++ b/lib/spack/spack/test/install.py @@ -10,6 +10,7 @@ import shutil from llnl.util.filesystem import mkdirp, touch, working_dir from spack.package import InstallError, PackageBase, PackageStillNeededError +import spack.error import spack.patch import spack.repo import spack.store @@ -136,7 +137,7 @@ def test_installed_dependency_request_conflicts( dependency_hash = dependency.dag_hash() dependent = Spec( 'conflicting-dependent ^/' + dependency_hash) - with pytest.raises(spack.spec.UnsatisfiableSpecError): + with pytest.raises(spack.error.UnsatisfiableSpecError): dependent.concretize() diff --git a/lib/spack/spack/test/spec_semantics.py b/lib/spack/spack/test/spec_semantics.py index e4292ec7b0..b55fa27ae1 100644 --- a/lib/spack/spack/test/spec_semantics.py +++ b/lib/spack/spack/test/spec_semantics.py @@ -6,11 +6,11 @@ import sys import pytest -from spack.spec import Spec, UnsatisfiableSpecError, SpecError -from spack.spec import substitute_abstract_variants -from spack.spec import SpecFormatSigilError, SpecFormatStringError +from spack.error import SpecError, UnsatisfiableSpecError +from spack.spec import Spec, SpecFormatSigilError, SpecFormatStringError from spack.variant import InvalidVariantValueError, UnknownVariantError from spack.variant import MultipleValuesInExclusiveVariantError +from spack.variant import substitute_abstract_variants import spack.architecture import spack.directives diff --git a/lib/spack/spack/test/spec_syntax.py b/lib/spack/spack/test/spec_syntax.py index 3a208c98b2..a5f7b6fdb0 100644 --- a/lib/spack/spack/test/spec_syntax.py +++ b/lib/spack/spack/test/spec_syntax.py @@ -17,9 +17,10 @@ from spack.parse import Token from spack.spec import Spec from spack.spec import SpecParseError, RedundantSpecError from spack.spec import AmbiguousHashError, InvalidHashError, NoSuchHashError -from spack.spec import DuplicateArchitectureError, DuplicateVariantError +from spack.spec import DuplicateArchitectureError from spack.spec import DuplicateDependencyError, DuplicateCompilerSpecError from spack.spec import SpecFilenameError, NoSuchSpecFileError +from spack.variant import DuplicateVariantError # Sample output for a complex lexing. -- cgit v1.2.3-70-g09d2