spack.solver package

Submodules

spack.solver.asp module

class spack.solver.asp.AspFunction(name, args=None)

Bases: AspObject

symbol(positive=True)

class spack.solver.asp.AspFunctionBuilder

Bases: object

class spack.solver.asp.AspObject

Bases: object

Object representing a piece of ASP code.

spack.solver.asp.DEFAULT_OUTPUT_CONFIGURATION = OutputConfiguration(timers=False, stats=False, out=None, setup_only=False)

Default output configuration for a solve

class spack.solver.asp.DeclaredVersion(version, idx, origin)

Bases: tuple

Named tuple to contain information on declared versions

property idx

Alias for field number 1

property origin

Alias for field number 2

property version

Alias for field number 0

exception spack.solver.asp.InternalConcretizerError(provided, conflicts)

Bases: UnsatisfiableSpecError

Subclass for new constructor signature for new concretizer

class spack.solver.asp.OutputConfiguration(timers, stats, out, setup_only)

Bases: tuple

Data class that contain configuration on what a clingo solve should output.

Parameters

• timers (bool) – Print out coarse timers for different solve phases.

• stats (bool) – Whether to output Clingo’s internal solver statistics.

• out – Optional output stream for the generated ASP program.

• setup_only (bool) – if True, stop after setup and don’t solve (default False).

property out

Alias for field number 2

property setup_only

Alias for field number 3

property stats

Alias for field number 1

property timers

Alias for field number 0

class spack.solver.asp.PyclingoDriver(cores=True)

Bases: object

fact(head)

ASP fact (a rule without a body).

Parameters

head (AspFunction) – ASP function to generate as fact

h1(name)

h2(name)

newline()

solve(setup, specs, reuse=None, output=None, control=None)

Set up the input and solve for dependencies of specs.

Parameters

• setup (SpackSolverSetup) – An object to set up the ASP problem.

• specs (list) – List of Spec objects to solve for.

• reuse (None or list) – list of concrete specs that can be reused

• output (None or OutputConfiguration) – configuration object to set the output of this solve.

• control (clingo.Control) – configuration for the solver. If None, default values will be used

Returns

A tuple of the solve result, the timer for the different phases of the solve, and the internal statistics from clingo.

title(name, char)

class spack.solver.asp.Result(specs, asp=None)

Bases: object

Result of an ASP solve.

format_core(core)

Format an unsatisfiable core for human readability

Returns a list of strings, where each string is the human readable representation of a single fact in the core, including a newline.

Modeled after traceback.format_stack.

format_cores()

List of facts for each core

Separate cores are separated by an empty line Cores are not minimized

format_minimal_cores()

List of facts for each core

Separate cores are separated by an empty line

minimal_cores()

Return a list of subset-minimal unsatisfiable cores.

minimize_core(core)

Return a subset-minimal subset of the core.

Clingo cores may be thousands of lines when two facts are sufficient to ensure unsatisfiability. This algorithm reduces the core to only those essential facts.

raise_if_unsat()

Raise an appropriate error if the result is unsatisfiable.

The error is an InternalConcretizerError, and includes the minimized cores resulting from the solve, formatted to be human readable.

property specs

List of concretized specs satisfying the initial abstract request.

property specs_by_input

property unsolved_specs

List of abstract input specs that were not solved.

class spack.solver.asp.Solver

Bases: object

This is the main external interface class for solving.

It manages solver configuration and preferences in one place. It sets up the solve and passes the setup method to the driver, as well.

Properties of interest:

reuse (bool)

Whether to try to reuse existing installs/binaries

solve(specs, out=None, timers=False, stats=False, tests=False, setup_only=False)

Parameters

• specs (list) – List of Spec objects to solve for.

• out – Optionally write the generate ASP program to a file-like object.

• timers (bool) – Print out coarse fimers for different solve phases.

• stats (bool) – Print out detailed stats from clingo.

• tests (bool or tuple) – If True, concretize test dependencies for all packages. If a tuple of package names, concretize test dependencies for named packages (defaults to False: do not concretize test dependencies).

• setup_only (bool) – if True, stop after setup and don’t solve (default False).

solve_in_rounds(specs, out=None, timers=False, stats=False, tests=False)

Solve for a stable model of specs in multiple rounds.

This relaxes the assumption of solve that everything must be consistent and solvable in a single round. Each round tries to maximize the reuse of specs from previous rounds.

The function is a generator that yields the result of each round.

Parameters

• specs (list) – list of Specs to solve.

• out – Optionally write the generate ASP program to a file-like object.

• timers (bool) – print timing if set to True

• stats (bool) – print internal statistics if set to True

• tests (bool) – add test dependencies to the solve

class spack.solver.asp.SpackSolverSetup(tests=False)

Bases: object

Class to set up and run a Spack concretization solve.

available_compilers()

Facts about available compilers.

build_version_dict(possible_pkgs, specs)

Declare any versions in specs not declared in packages.

compiler_defaults()

Set compiler defaults, given a list of possible compilers.

compiler_supports_os()

condition(required_spec, imposed_spec=None, name=None, msg=None, node=False)

Generate facts for a dependency or virtual provider condition.

Parameters

• required_spec (spack.spec.Spec) – the spec that triggers this condition

• imposed_spec (spack.spec.Spec or None) – the spec with constraints that are imposed when this condition is triggered

• name (str or None) – name for required_spec (required if required_spec is anonymous, ignored if not)

• msg (str or None) – description of the condition

• node (bool) – if False does not emit “node” or “virtual_node” requirements from the imposed spec

Returns

id of the condition created by this function

Return type

int

conflict_rules(pkg)

define_compiler_version_constraints()

define_concrete_input_specs(specs, possible)

define_target_constraints()

define_variant_values()

Validate variant values from the command line.

Also add valid variant values from the command line to the possible values for a variant.

define_version_constraints()

Define what version_satisfies(…) means in ASP logic.

define_virtual_constraints()

Define versions for constraints on virtuals.

Must be called before define_version_constraints().

emit_facts_from_requirement_rules(rules, virtual=False)

Generate facts to enforce requirements from packages.yaml.

external_packages()

Facts on external packages, as read from packages.yaml

flag_defaults()

generate_possible_compilers(specs)

impose(condition_id, imposed_spec, node=True, name=None, body=False)

literal_specs(specs)

os_defaults(specs)

package_compiler_defaults(pkg)

Facts about packages’ compiler prefs.

package_dependencies_rules(pkg)

Translate ‘depends_on’ directives into ASP logic.

package_provider_rules(pkg)

package_requirement_rules(pkg)

pkg_rules(pkg, tests)

pkg_version_rules(pkg)

Output declared versions of a package.

This uses self.declared_versions so that we include any versions that arise from a spec.

platform_defaults()

preferred_variants(pkg_name)

Facts on concretization preferences, as read from packages.yaml

provider_defaults()

provider_requirements()

setup(driver, specs, reuse=None)

Generate an ASP program with relevant constraints for specs.

This calls methods on the solve driver to set up the problem with facts and rules from all possible dependencies of the input specs, as well as constraints from the specs themselves.

Parameters

• driver (PyclingoDriver) – driver instance of this solve

• specs (list) – list of Specs to solve

• reuse (None or list) – list of concrete specs that can be reused

spec_clauses(*args, **kwargs)

Wrap a call to _spec_clauses() into a try/except block that raises a comprehensible error message in case of failure.

spec_versions(spec)

Return list of clauses expressing spec’s version constraints.

target_defaults(specs)

Add facts about targets and target compatibility.

target_preferences(pkg_name)

target_ranges(spec, single_target_fn)

virtual_preferences(pkg_name, func)

Call func(vspec, provider, i) for each of pkg’s provider prefs.

virtual_providers()

class spack.solver.asp.SpecBuilder(specs, hash_lookup=None)

Bases: object

Class with actions to rebuild a spec from ASP results.

build_specs(function_tuples)

depends_on(pkg, dep, type)

deprecated(pkg, version)

error(priority, msg, *args)

external_spec_selected(pkg, idx)

This means that the external spec and index idx has been selected for this package.

hash(pkg, h)

ignored_attributes = ['opt_criterion']

Attributes that don’t need actions

no_flags(pkg, flag_type)

node(pkg)

node_compiler(pkg, compiler)

node_compiler_version(pkg, compiler, version)

node_flag(pkg, flag_type, flag)

node_flag_compiler_default(pkg)

node_flag_source(pkg, source)

node_os(pkg, os)

node_platform(pkg, platform)

node_target(pkg, target)

reorder_flags()

Order compiler flags on specs in predefined order.

We order flags so that any node’s flags will take priority over those of its dependents. That is, the deepest node in the DAG’s flags will appear last on the compile line, in the order they were specified.

The solver determines wihch flags are on nodes; this routine imposes order afterwards.

static sort_fn(function_tuple)

variant_value(pkg, name, value)

version(pkg, version)

exception spack.solver.asp.UnsatisfiableSpecError(msg)

Bases: UnsatisfiableSpecError

Subclass for new constructor signature for new concretizer

spack.solver.asp.all_compilers_in_config()

spack.solver.asp.ast_getter(*names)

spack.solver.asp.ast_sym(node)

spack.solver.asp.ast_type(node)

spack.solver.asp.bootstrap_clingo()

spack.solver.asp.build_criteria_names(costs, tuples)

Construct an ordered mapping from criteria names to costs.

spack.solver.asp.build_priority_offset = 200

Priority offset for “build” criteria (regular criterio shifted to higher priority for specs we have to build)

spack.solver.asp.check_packages_exist(specs)

Ensure all packages mentioned in specs exist.

spack.solver.asp.check_same_flags(flag_dict_1, flag_dict_2)

Return True if flag dicts contain the same flags regardless of order.

spack.solver.asp.default_clingo_control()

Return a control object with the default settings used in Spack

spack.solver.asp.extend_flag_list(flag_list, new_flags)

Extend a list of flags, preserving order and precedence.

Add new_flags at the end of flag_list. If any flags in new_flags are already in flag_list, they are moved to the end so that they take higher precedence on the compile line.

spack.solver.asp.fixed_priority_offset = 100

Priority offset of “fixed” criteria (those w/o build criteria)

spack.solver.asp.high_fixed_priority_offset = 300

High fixed priority offset for criteria that supersede all build criteria

spack.solver.asp.issequence(obj)

spack.solver.asp.listify(args)

spack.solver.asp.packagize(pkg)

spack.solver.asp.specify(spec)

spack.solver.asp.version_origin_fields = ['spec', 'external', 'packages_yaml', 'package_py', 'installed']

Order of precedence for version origins. Topmost types are preferred.

spack.solver.asp.version_origin_str = {0: 'spec', 1: 'external', 2: 'packages_yaml', 3: 'package_py', 4: 'installed'}

Look up version precedence strings by enum id

spack.solver.asp.version_provenance = VersionProvenance(spec=0, external=1, packages_yaml=2, package_py=3, installed=4)

Enumeration like object to mark version provenance

Module contents