pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)

for variant in current_spec.variants.values():

# Variant does not exist at all

summary = (

f"Setting a preference for the '{pkg_name}' package to the "

f"non-existing variant '{variant.name}'"

continue

# Variant cannot accept this value

try:

except Exception:

summary = (

f"Setting the variant '{variant.name}' of the '{pkg_name}' package "

errors = []

for pkg_name in pkgs:

pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)

module = pkg_cls.module

has_builders_in_package_py = any(

getattr(module, name, False) for name in builder_cls_names

# check variants

dependency_variants = dep.spec.variants

try:

except Exception as e:

summary = (

f"{pkg_name}: wrong variant used for dependency in 'depends_on()'"

)

if isinstance(e, KeyError):

error_msg = (

f"variant {str(e).strip()} does not exist in package {dep_name}"

)

errors.append(

error_cls(summary=summary, details=[error_msg, f"in {filename}"])

@package_directives

def _ensure_variant_defaults_are_parsable(pkgs, error_cls):

"""Ensures that variant defaults are present and parsable from cli"""

return errors

errors = []

for pkg_name in pkgs:

pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)

return errors

def _analyze_variants_in_directive(pkg, constraint, directive, error_cls):

errors = []

return errors

for dname in dnames

)

for when, providers, details in _error_items(pkg_cls.provided):

errors.extend(

variant = variant or name

msg = '"{0}" is not a variant of "{1}"'

raise KeyError(msg.format(variant, self.pkg.name))

# Create a list of pairs. Each pair includes a configuration

# option and whether or not that option is activated

# BoolValuedVariant carry information about a single option.

# Nonetheless, for uniformity of treatment we'll package them

# in an iterable of one element.

else:

# "feature_values" is used to track values which correspond to

# features which can be enabled or disabled as understood by the

# package's build system. It excludes values which have special

# meanings and do not correspond to features (e.g. "none")

# For each allowed value in the list of values

for option_value, activated in options:

if variant is None:

variant = cmake_var.lower()

raise KeyError('"{0}" is not a variant of "{1}"'.format(variant, self.pkg.name))

if variant not in self.pkg.spec.variants:

default=default,

values=_values,

description="the build system generator to use",

)

for x in not_used:

conflicts(f"generator={x}")

if variant is None:

variant = cmake_var.lower()

raise KeyError('"{0}" is not a variant of "{1}"'.format(variant, self.pkg.name))

if variant not in self.pkg.spec.variants:

# Get and list all the variants that differ from the default.

variants = []

for var_name, variant in spec.variants.items():

continue

variants.append(str(variant))

variants.sort()

variants = " ".join(variants)

out.write("\n")

def _print_variants_header(pkg):

"""output variants"""

color.cprint("")

color.cprint(section_title("Variants:"))

# Calculate the max length of the "name [default]" part of the variant display

# This lets us know where to print variant values.

max_name_default_len = max(

color.clen(_fmt_name_and_default(variant))

)

def print_variants_grouped_by_when(pkg):

indent = 4

padded_values = max_name_default_len + 4

start_indent = indent

def print_variants_by_name(pkg):

max_name_default_len += 4

indent = 4

def print_variants(pkg, args):

variant_strs = list()

for name, value in entry["parameters"].items():

# TODO: also ensure that the variant value is valid?

tty.debug(

"Omitting variant {0} for entry {1}/{2}".format(

name, entry["name"], entry["hash"][:7]

"redistribute",

]

_patch_order_index = 0

def _execute_variant(pkg):

when_spec = _make_when_spec(when)

if not re.match(spack.spec.IDENTIFIER_RE, name):

directive = "variant"

msg = "Invalid variant name in {0}: '{1}'"

raise DirectiveError(directive, msg.format(pkg.name, name))

)

return _execute_variant

else:

all_by_name.setdefault(name, []).append(value)

return dict(sorted(all_by_name.items()))

"""Get sorted names from dicts keyed by when/name."""

all_names = set()

for when, by_name in when_indexed_dictionary.items():

return sorted(all_names)

class RedistributionMixin:

"""Logic for determining whether a Package is source/binary

redistributable.

provided: Dict["spack.spec.Spec", Set["spack.spec.Spec"]]

provided_together: Dict["spack.spec.Spec", List[Set[str]]]

patches: Dict["spack.spec.Spec", List["spack.patch.Patch"]]

languages: Dict["spack.spec.Spec", Set[str]]

#: By default, packages are not virtual

def dependencies_by_name(cls, when: bool = False):

return _by_name(cls.dependencies, when=when)

@classmethod

def possible_dependencies(

cls,

# Only return variants that are actually supported by the package

pkg_cls = spack.repo.PATH.get_pkg_class(pkg_name)

def is_spec_buildable(spec):

import spack.util.libc

import spack.util.path

import spack.util.timer

import spack.version as vn

import spack.version.git_ref_lookup

from spack import traverse

@contextmanager

"""Context manager to temporarily set the name of a spec"""

old_name = spec.name

spec.name = name

try:

self.default_targets: List = []

self.compiler_version_constraints: Set = set()

self.post_facts: List = []

self.reusable_and_possible: ConcreteSpecsByHash = ConcreteSpecsByHash()

def conflict_rules(self, pkg):

for when_spec, conflict_specs in pkg.conflicts.items():

when_spec_msg = "conflict constraint %s" % str(when_spec)

for conflict_spec, conflict_msg in conflict_specs:

conflict_spec = spack.spec.Spec(conflict_spec)

spec_for_msg = spack.spec.Spec(pkg.name)

conflict_spec_msg = f"conflict is triggered when {str(spec_for_msg)}"

conflict_spec_id = self.condition(

)

self.gen.fact(

fn.pkg_fact(

condition_msg = f"{pkg.name} needs the {', '.join(sorted(languages))} language"

if when_spec != spack.spec.Spec():

condition_msg += f" when {when_spec}"

for language in sorted(languages):

self.gen.fact(fn.pkg_fact(pkg.name, fn.language(condition_id, language)))

self.gen.newline()

self.gen.newline()

self._effect_cache.clear()

)

else:

def _get_condition_id(

self,

self,

required_spec: spack.spec.Spec,

imposed_spec: Optional[spack.spec.Spec] = None,

msg: Optional[str] = None,

context: Optional[ConditionContext] = None,

):

Arguments:

required_spec: the constraints that triggers this condition

imposed_spec: the constraints that are imposed when this condition is triggered

msg: description of the condition

context: if provided, indicates how to modify the clause-sets for the required/imposed

specs based on the type of constraint they are generated for (e.g. `depends_on`)

Returns:

int: id of the condition created by this function

"""

raise ValueError(f"Must provide a name for anonymous condition: '{required_spec}'")

if not context:

context = ConditionContext()

context.transform_imposed = remove_node

# Check if we can emit the requirements before updating the condition ID counter.

# In this way, if a condition can't be emitted but the exception is handled in the

# caller, we won't emit partial facts.

continue

msg = f"{pkg.name} provides {vpkg} when {when}"

self.gen.fact(

fn.pkg_fact(when.name, fn.provider_condition(condition_id, vpkg.name))

)

for when, sets_of_virtuals in pkg.provided_together.items():

condition_id = self.condition(

)

for set_id, virtuals_together in enumerate(sets_of_virtuals):

for name in virtuals_together:

context.transform_required = track_dependencies

context.transform_imposed = dependency_holds

self.gen.newline()

if rule.condition != spack.spec.Spec():

msg = f"condition to activate requirement {requirement_grp_id}"

try:

except Exception as e:

if rule.kind != RequirementKind.DEFAULT:

raise RuntimeError(

member_id = self.condition(

required_spec=when_spec,

imposed_spec=spec,

msg=f"{input_spec} is a requirement for package {pkg_name}",

context=context,

)

if pkg_name == "all":

continue

continue

# This package is not among possible dependencies

for variant_name in sorted(preferred_variants):

variant = preferred_variants[variant_name]

# perform validation of the variant and values

try:

tty.debug(

f"[SETUP]: rejected {str(variant)} as a preference for {pkg_name}: {str(e)}"

)

continue

self.gen.fact(

fn.variant_default_value_from_packages_yaml(pkg_name, variant.name, value)

)

# variants

for vname, variant in sorted(spec.variants.items()):

clauses.append(f.variant_value(spec.name, vname, value))

if variant.propagate:

clauses.append(f.propagate(spec.name, fn.variant_value(vname, value)))

# compiler and compiler version

if spec.compiler:

clauses.append(f.node_compiler(spec.name, spec.compiler.name))

def define_variant_values(self):

"""Validate variant values from the command line.

"""

def register_concrete_spec(self, spec, possible):

# tell the solver about any installed packages that could

self.gen.h2("Package preferences: %s" % pkg)

self.preferred_variants(pkg)

self.gen.h1("Develop specs")

# Inject dev_path from environment

for ds in dev_specs:

def h2(self, header: str) -> None:

self.title(header, "-")

def newline(self):

self.asp_problem.append("\n")

"""

return NodeArgument(id="0", pkg=pkg)

self._result = None

self._command_line_specs = specs

# Pass in as arguments reusable specs and plug them in

# from this dictionary during reconstruction

def hash(self, node, h):

if node not in self._specs:

def node_target(self, node, target):

self._arch(node).target = target

)

def version(self, node, version):

self._specs[node].versions = vn.VersionList([vn.Version(version)])

tty.warn(f'using "{node.pkg}@{version}" which is a deprecated version')

@staticmethod

"""Ensure attributes are evaluated in the correct order.

hash attributes are handled first, since they imply entire concrete specs

assert spec.variants["dev_path"].value == path, error_msg

else:

assert spec.satisfies(dev_info["spec"])

%-----------------------------------------------------------------------------

% Variant semantics

%-----------------------------------------------------------------------------

% a variant cannot be set if it is not a variant on the package

error(100, "Cannot set variant '{0}' for package '{1}' because the variant condition cannot be satisfied for the given spec", Variant, Package)

% a variant cannot take on a value if it is not a variant of the package

error(100, "Cannot set variant '{0}' for package '{1}' because the variant condition cannot be satisfied for the given spec", Variant, Package)

% at most one variant value for single-valued variants.

error(100, "'{0}' required multiple values for single-valued variant '{1}'", Package, Variant)

:- attr("node", node(ID, Package)),

build(node(ID, Package)),

2 { attr("variant_value", node(ID, Package), Variant, Value) }.

error(100, "No valid value for variant '{1}' of package '{0}'", Package, Variant)

% if a variant is set to anything, it is considered 'set'.

attr("variant_set", PackageNode, Variant) :- attr("variant_set", PackageNode, Variant, _).

% have been built w/different variants from older/different package versions.

error(10, "'Spec({1}={2})' is not a valid value for '{0}' variant '{1}'", Package, Variant, Value)

:- attr("variant_value", node(ID, Package), Variant, Value),

build(node(ID, Package)).

error(100, "{0} variant '{1}' cannot have values '{2}' and '{3}' as they come from disjoint value sets", Package, Variant, Value1, Value2)

:- attr("variant_value", node(ID, Package), Variant, Value1),

attr("variant_value", node(ID, Package), Variant, Value2),

Set1 < Set2, % see[1]

build(node(ID, Package)).

% specified in an external, we score it as if it was a default value.

variant_not_default(node(ID, Package), Variant, Value)

:- attr("variant_value", node(ID, Package), Variant, Value),

% variants set explicitly on the CLI don't count as non-default

not attr("variant_set", node(ID, Package), Variant, Value),

% variant values forced by propagation don't count as non-default

not external_with_variant_set(node(ID, Package), Variant, Value),

attr("node", node(ID, Package)).

% A default variant value that is not used

variant_default_not_used(node(ID, Package), Variant, Value)

not attr("variant_value", node(ID, Package), Variant, Value),

not propagate(node(ID, Package), variant_value(Variant, _)),

attr("node", node(ID, Package)).

external(node(NodeID, Package)),

attr("node", node(NodeID, Package)).

% Treat 'none' in a special way - it cannot be combined with other

% values even if the variant is multi-valued

error(100, "{0} variant '{1}' cannot have values '{2}' and 'none'", Package, Variant, Value)

Value != "none",

build(node(X, Package)).

% suppress warnings about this atom being unset. It's only set if some

% spec or some package sets it, and without this, clingo will give

% warnings like 'info: atom does not occur in any rule head'.

#defined variant_default_value/3.

#defined variant_default_value_from_packages_yaml/3.

%-----------------------------------------------------------------------------

% Propagation semantics

%----

% If a variant is propagated, and can be accepted, set its value

% If a variant is propagated, we cannot have extraneous values

variant_is_propagated(PackageNode, Variant) :-

not attr("variant_set", PackageNode, Variant).

:- variant_is_propagated(PackageNode, Variant),

not propagate(PackageNode, variant_value(Variant, Value)).

%----

#show attr/3.

#show attr/4.

#show attr/5.

% names of optimization criteria

#show opt_criterion/2.

#show condition_requirement/4.

#show condition_requirement/5.

#show condition_requirement/6.

#show build/1.

#show external/1.

#show external_version/3.

#show condition_nodes/3.

#show trigger_node/3.

#show imposed_nodes/3.

% debug

%=============================================================================

% This logic program adds detailed error messages to Spack's concretizer

%=============================================================================

#program error_messages.

pkg_fact(TriggerPkg, condition_effect(Cause, EID)),

condition_holds(Cause, node(CID, TriggerPkg)).

% At most one variant value for single-valued variants

error(0, "'{0}' required multiple values for single-valued variant '{1}'\n Requested 'Spec({1}={2})' and 'Spec({1}={3})'", Package, Variant, Value1, Value2, startcauses, Cause1, X, Cause2, X)

:- attr("node", node(X, Package)),

build(node(X, Package)),

attr("variant_value", node(X, Package), Variant, Value1),

imposed_constraint(EID1, "variant_set", Package, Variant, Value1),

#defined error/4.

#defined error/5.

#defined error/6.

#defined attr/2.

#defined attr/3.

#defined attr/4.

#defined imposed_constraint/4.

#defined imposed_constraint/5.

#defined imposed_constraint/6.

#defined condition_requirement/3.

#defined condition_requirement/4.

#defined condition_requirement/5.

#defined external/1.

#defined trigger_and_effect/3.

#defined build/1.

#defined provider/2.

#defined external_version/3.

package_cls = spack.repo.PATH.get_pkg_class(new_spec.name)

if change_spec.versions and not change_spec.versions == vn.any_version:

new_spec.versions = change_spec.versions

new_spec.variants.substitute(value)

else:

else:

if change_spec.compiler:

new_spec.compiler = change_spec.compiler

if change_spec.compiler_flags:

return

pkg_cls = spec.package_class

# reserved names are variants that may be set on any package

# but are not necessarily recorded by the package's class

not_existing = set(spec.variants) - (set(pkg_variants) | set(vt.reserved_names))

if not_existing:

def constrain(self, other, deps=True):

"""Intersect self with other in-place. Return True if self changed, False otherwise.

Returns:

bool: True or False

"""

def copy(self) -> "VariantMap":

clone = VariantMap(self.spec)

def substitute_abstract_variants(spec: Spec):

"""Uses the information in `spec.package` to turn any variant that needs

This method is best effort. All variants that can be substituted will be

substituted before any error is raised.

Args:

spec: spec on which to operate the substitution

"""

# in $spack/lib/spack/spack/spec_list.py

for name, v in spec.variants.items():

if name == "dev_path":

spec.variants.substitute(vt.SingleValuedVariant(name, v._original_value))

continue

elif name in vt.reserved_names:

continue

continue

new_variant = pkg_variant.make_variant(v._original_value)

spec.variants.substitute(new_variant)

def parse_with_version_concrete(spec_like: Union[str, Spec], compiler: bool = False):

)

class UnsupportedPropagationError(spack.error.SpecError):

"""Raised when propagation (==) is used with reserved variant names."""

cflag = concrete.compiler_flags[flag]

assert set(aflag) <= set(cflag)

assert name in concrete.variants

for flag in concrete.compiler_flags.valid_compiler_flags():

],

)

def test_conditional_variants_fail(self, bad_spec):

_ = Spec("conditional-variant-pkg" + bad_spec).concretized()

@pytest.mark.parametrize(

)

def test_error_message_for_inconsistent_variants(self, spec_str):

s = Spec(spec_str)

s.concretize()

@pytest.mark.regression("22533")

'libelf cflags="-O3" cppflags="-Wall"',

'libelf cflags="-O3" cppflags="-Wall"',

),

],

)

def test_abstract_specs_can_constrain_each_other(self, lhs, rhs, expected):

@pytest.mark.regression("13124")

def test_error_message_unknown_variant(self):

s = Spec("mpileaks +unknown")

s.concretize()

@pytest.mark.regression("18527")

assert new_spec.compiler_flags["cflags"] == ["-O2"]

assert new_spec.compiler_flags["cxxflags"] == ["-O1"]

@pytest.mark.parametrize(

"spec_str,specs_in_dag",

[

import pytest

import spack.error

import spack.variant

from spack.variant import (

BoolValuedVariant,

DuplicateVariantError,

InconsistentValidationError,

)

# Valid vspec, shouldn't raise

vspec = a.make_variant("bar")

# Multiple values are not allowed

with pytest.raises(MultipleValuesInExclusiveVariantError):

# Inconsistent vspec

vspec.name = "FOO"

with pytest.raises(InconsistentValidationError):

# Valid multi-value vspec

a.multi = True

vspec = a.make_variant("bar,baz")

# Add an invalid value

vspec.value = "bar,baz,barbaz"

with pytest.raises(InvalidVariantValueError):

def test_callable_validator(self):

def validator(x):

a = Variant("foo", default=1024, description="", values=validator, multi=False)

vspec = a.make_default()

vspec.value = 2056

vspec.value = "foo"

with pytest.raises(InvalidVariantValueError):

def test_representation(self):

a = Variant(

)

assert a.allowed_values == "bar, baz, foobar"

class TestVariantMapTest:

# Value with invalid type

with pytest.raises(TypeError):

a["foo"] = 2

with pytest.raises(KeyError):

a["bar"] = MultiValuedVariant("foo", "bar")

# Check that all the three types of variants are accepted

a["foo"] = BoolValuedVariant("foo", True)

a["bar"] = SingleValuedVariant("bar", "baz")

a["foobar"] = MultiValuedVariant("foobar", "a, b, c, d, e")

# Check substitution of a key that exists

a["foo"] = BoolValuedVariant("foo", True)

a.substitute(SingleValuedVariant("foo", "bar"))

with pytest.raises(KeyError):

a.substitute(BoolValuedVariant("bar", True))

# foo=bar foobar=fee feebar=foo

a["foo"] = MultiValuedVariant("foo", "bar")

a["foobar"] = SingleValuedVariant("foobar", "fee")

a["feebar"] = SingleValuedVariant("feebar", "foo")

# foo=bar,baz foobar=fee shared=True

b["foo"] = MultiValuedVariant("foo", "bar, baz")

b["foobar"] = SingleValuedVariant("foobar", "fee")

b["shared"] = BoolValuedVariant("shared", True)

assert not b.satisfies(a)

# foo=bar,baz foobar=fee feebar=foo shared=True

c["foo"] = MultiValuedVariant("foo", "bar, baz")

c["foobar"] = SingleValuedVariant("foobar", "fee")

c["feebar"] = SingleValuedVariant("feebar", "foo")

assert a.constrain(b)

assert a == c

a["foo"] = BoolValuedVariant("foo", True)

a["bar"] = SingleValuedVariant("bar", "baz")

a["foobar"] = MultiValuedVariant("foobar", "a, b, c, d, e")

c = a.copy()

assert a == c

c["foo"] = MultiValuedVariant("foo", "bar, baz")

c["foobar"] = SingleValuedVariant("foobar", "fee")

c["feebar"] = SingleValuedVariant("feebar", "foo")

c["shared"] = BoolValuedVariant("shared", True)

assert str(c) == "+shared feebar=foo foo=bar,baz foobar=fee"

def test_disjoint_set_initialization_errors():

# Constructing from non-disjoint sets should raise an exception

several_arbitrary_values = ("doe", "re", "mi")

# "*" case

wild_output = wild_var.make_variant(several_arbitrary_values)

# str case

str_output = str_var.make_variant(several_arbitrary_values)

# equivalence each instance already validated

assert str_output.value == wild_output.value

variants both in packages and in specs.

"""

import collections.abc

import functools

import inspect

import itertools

import re

import llnl.util.lang as lang

import llnl.util.tty.color

import spack.error as error

import spack.parser

#: These are variant names used by Spack internally; packages can't use them

reserved_names = [

special_variant_values = [None, "none", "*"]

class Variant:

"""

def __init__(

self,

):

"""Initialize a package variant.

Args:

"""

self.name = name

self.default = default

self.values = None

if values == "*":

# wildcard is a special case to make it easy to say any value is ok

elif isinstance(values, type):

# supplying a type means any value *of that type*

self.single_value_validator = values

else:

# Otherwise, assume values is the set of allowed explicit values

self.multi = multi

self.group_validator = validator

self.sticky = sticky

"""Validate a variant spec against this package variant. Raises an

exception if any error is found.

Args:

Raises:

InconsistentValidationError: if ``vspec.name != self.name``

if self.name != vspec.name:

raise InconsistentValidationError(vspec, self)

# If the value is exclusive there must be at most one

if not self.multi and len(value) != 1:

# Check and record the values that are not allowed

# Validate the group of values if needed

if self.group_validator is not None and value != ("*",):

@property

def allowed_values(self):

"""

return self.make_variant(self.default)

"""Factory that creates a variant holding the value passed as

a parameter.

MultiValuedVariant or SingleValuedVariant or BoolValuedVariant:

instance of the proper variant

"""

@property

if self.multi:

elif self.values == (True, False):

return (

)

def implicit_variant_conversion(method):

"""Converts other to type(self) and calls method(self, other)

return convert

"""Flatten instances of _ConditionalVariantValues for internal representation"""

if isinstance(values, DisjointSetsOfValues):

return values

for item in values:

if isinstance(item, _ConditionalVariantValues):

flattened.extend(item)

return tuple(flattened)

@lang.lazy_lexicographic_ordering

class AbstractVariant:

"""A variant that has not yet decided who it wants to be. It behaves like

values.

"""

self.name = name

self.propagate = propagate

# Invokes property setter

self.value = value

@staticmethod

"""Reconstruct a variant from a node dict."""

if isinstance(value, list):

# read multi-value variants in and be faithful to the YAML

return SingleValuedVariant(name, value)

"""Returns a key, value tuple suitable to be an entry in a yaml dict.

Returns:

tuple: (name, value_representation)

"""

@property

"""Returns a tuple of strings containing the values stored in

the variant.

return self._value

@value.setter

self._value_setter(value)

# Store the original value

self._original_value = value

# Store a tuple of CSV string representations

# Tuple is necessary here instead of list because the

# values need to be hashed

for val in special_variant_values:

if val in value and len(value) > 1:

# to a set

self._value = tuple(sorted(set(value)))

yield self.name

"""Returns an instance of a variant equivalent to self

Returns:

return type(self)(self.name, self._original_value, self.propagate)

@implicit_variant_conversion

"""Returns true if ``other.name == self.name``, because any value that

other holds and is not in self yet **could** be added.

# (`foo=bar` will never satisfy `baz=bar`)

return other.name == self.name

"""Returns True if there are variant matching both self and other, False otherwise."""

if isinstance(other, (SingleValuedVariant, BoolValuedVariant)):

return other.intersects(self)

return other.name == self.name

"""Returns True if self and other are compatible, False otherwise.

As there is no semantic check, two VariantSpec are compatible if

return self.intersects(other)

@implicit_variant_conversion

"""Modify self to match all the constraints for other if both

instances are multi-valued. Returns True if self changed,

False otherwise.

old_value = self.value

# If we constraint wildcard by another value, just take value

if "*" in values and len(values) > 1:

values.remove("*")

return old_value != self.value

return f"{type(self).__name__}({repr(self.name)}, {repr(self._original_value)})"

delim = "==" if self.propagate else "="

return f"{self.name}{delim}{values}"

"""A variant that can hold multiple values at once."""

@implicit_variant_conversion

"""Returns true if ``other.name == self.name`` and ``other.value`` is

a strict subset of self. Does not try to validate.

# allow prefix find on patches

if self.name == "patches":

# Otherwise we want all the values in `other` to be also in `self`

"""Add another value to this multi-valued variant."""

# Special-case patches to not print the full 64 character sha256

if self.name == "patches":

else:

delim = "==" if self.propagate else "="

return f"{self.name}{delim}{spack.parser.quote_if_needed(values_str)}"

class SingleValuedVariant(AbstractVariant):

"""A variant that can hold multiple values, but one at a time."""

# Treat the value as a multi-valued variant

super()._value_setter(value)

# Then check if there's only a single value

@implicit_variant_conversion

abstract_sat = super().satisfies(other)

return abstract_sat and (

self.value == other.value or other.value == "*" or self.value == "*"

)

return self.satisfies(other)

return self.satisfies(other)

@implicit_variant_conversion

if self.name != other.name:

raise ValueError("variants must have the same name")

raise UnsatisfiableVariantSpecError(other.value, self.value)

return False

return item == self.value

return self.name, self.value

class BoolValuedVariant(SingleValuedVariant):

"""A variant that can hold either True or False.

BoolValuedVariant can also hold the value '*', for coerced

comparisons between ``foo=*`` and ``+foo`` or ``~foo``."""

# Check the string representation of the value and turn

# it to a boolean

if str(value).upper() == "TRUE":

msg += "a value that does not represent a bool"

raise ValueError(msg.format(self.name))

return item is self.value

if self.propagate:

# The class below inherit from Sequence to disguise as a tuple and comply

class Value:

"""Conditional value that might be used in variants."""

self.value = value

self.when = when

def __repr__(self):

def __str__(self):

return str(self.value)

return self.value < other.value

class _ConditionalVariantValues(lang.TypedMutableSequence):

"""A list, just with a different type"""

"""Conditional values that can be used in variant declarations."""

return _ConditionalVariantValues([Value(x, when=when) for x in values])

class UnknownVariantError(error.SpecError):

"""Raised when an unknown variant occurs in a spec."""

super().__init__(msg)

class InconsistentValidationError(error.SpecError):

only one.

"""

super().__init__(msg.format(variant, pkg_info))

class InvalidVariantValueError(error.SpecError):

class UnsatisfiableVariantSpecError(error.UnsatisfiableSpecError):