spack.cmd package

exception spack.cmd.CommandNameError(name)

Bases: SpackError

Exception class thrown for impermissible command names

exception spack.cmd.CommandNotFoundError(cmd_name)

Bases: SpackError

Exception class thrown when a requested command is not recognized as such.

exception spack.cmd.MultipleSpecsMatch

Bases: Exception

Raised when multiple specs match a constraint, in a context where this is not allowed.

exception spack.cmd.NoSpecMatches

Bases: Exception

Raised when no spec matches a constraint, in a context where this is not allowed.

exception spack.cmd.PythonNameError(name)

Bases: SpackError

Exception class thrown for impermissible python names

spack.cmd.all_commands()

Get a sorted list of all spack commands.

This will list the lib/spack/spack/cmd directory and find the commands there to construct the list. It does not actually import the python files – just gets the names.

spack.cmd.cmd_name(python_name)

Convert module name (with _) to command name (with -).

spack.cmd.converted_arg_length(arg: str)

spack.cmd.disambiguate_spec(spec: Spec, env: Environment | None, local: bool = False, installed: bool | InstallRecordStatus = True, first: bool = False) → Spec

Given a spec, figure out which installed package it refers to.

Parameters:

• spec – a spec to disambiguate

• env – a spack environment, if one is active, or None if no environment is active

• local – do not search chained spack instances

• installed – install status argument passed to database query.

• first – returns the first matching spec, even if more than one match is found

spack.cmd.disambiguate_spec_from_hashes(spec: Spec, hashes: List[str] | None, local: bool = False, installed: bool | InstallRecordStatus = True, first: bool = False) → Spec

Given a spec and a list of hashes, get concrete spec the spec refers to.

Parameters:

• spec – a spec to disambiguate

• hashes – a set of hashes of specs among which to disambiguate

• local – if True, do not search chained spack instances

• installed – install status argument passed to database query.

• first – returns the first matching spec, even if more than one match is found

spack.cmd.display_specs(specs, args=None, **kwargs)

Display human readable specs with customizable formatting.

Prints the supplied specs to the screen, formatted according to the arguments provided.

Specs are grouped by architecture and compiler, and columnized if possible.

Options can add more information to the default display. Options can be provided either as keyword arguments or as an argparse namespace. Keyword arguments take precedence over settings in the argparse namespace.

Parameters:

• specs (list) – the specs to display

• args (argparse.Namespace or None) – namespace containing formatting arguments

Keyword Arguments:

• paths (bool) – Show paths with each displayed spec

• deps (bool) – Display dependencies with specs

• long (bool) – Display short hashes with specs

• very_long (bool) – Display full hashes with specs (supersedes long)

• namespaces (bool) – Print namespaces along with names

• show_flags (bool) – Show compiler flags with specs

• variants (bool) – Show variants with specs

• indent (int) – indent each line this much

• groups (bool) – display specs grouped by arch/compiler (default True)

• decorator (Callable) – function to call to decorate specs

• all_headers (bool) – show headers even when arch/compiler aren’t defined

• status_fn (Callable) – if provided, prepend install-status info

• output (IO) – A file object to write to. Default is sys.stdout

• specfile_format (bool) – specfile format of the current spec

spack.cmd.display_specs_as_json(specs, deps=False)

Convert specs to a list of json records.

spack.cmd.doc_dedented(function: object) → str | None

Return the docstring with leading indentation removed.

spack.cmd.doc_first_line(function: object) → str | None

Return the first line of the docstring.

spack.cmd.ensure_single_spec_or_die(spec, matching_specs)

spack.cmd.extant_file(f)

Argparse type for files that exist.

spack.cmd.filter_loaded_specs(specs)

Filter a list of specs returning only those that are currently loaded.

spack.cmd.find_environment(args: Namespace) → Environment | None

Find active environment from args or environment variable.

Check for an environment in this order:

1. via spack -e ENV or spack -D DIR (arguments)

2. via a path in the spack.environment.spack_env_var environment variable.

If an environment is found, read it in. If not, return None.

Parameters:

args – argparse namespace with command arguments

Returns: a found environment, or None

spack.cmd.get_command(cmd_name)

Imports the command function associated with cmd_name.

The function’s name is derived from cmd_name using python_name().

Parameters:

cmd_name (str) – name of the command (contains -, not _).

spack.cmd.get_module(cmd_name)

Imports the module for a particular command name and returns it.

Parameters:

cmd_name (str) – name of the command for which to get a module (contains -, not _).

spack.cmd.gray_hash(spec, length)

spack.cmd.group_arguments(args: Sequence[str], *, max_group_size: int = 500, prefix_length: int = 0, max_group_length: int | None = None) → Generator[List[str], None, None]

Splits the supplied list of arguments into groups for passing to CLI tools.

When passing CLI arguments, we need to ensure that argument lists are no longer than the system command line size limit, and we may also need to ensure that groups are no more than some number of arguments long.

This returns an iterator over lists of arguments that meet these constraints. Arguments are in the same order they appeared in the original argument list.

If any argument’s length is greater than the max_group_length, this will raise a ValueError.

Parameters:

• args – list of arguments to split into groups

• max_group_size – max number of elements in any group (default 500)

• prefix_length – length of any additional arguments (including spaces) to be passed before the groups from args; default is 0 characters

• max_group_length – max length of characters that if a group of args is joined by " " On unix, this defaults to SC_ARG_MAX from sysconf. On Windows the default is the max usable for CreateProcess (32,768 chars)

spack.cmd.is_git_repo(path)

spack.cmd.iter_groups(specs, indent, all_headers)

Break a list of specs into groups indexed by arch/compilers.

spack.cmd.matching_spec_from_env(spec)

Returns a concrete spec, matching what is available in the environment. If no matching spec is found in the environment (or if no environment is active), this will return the given spec but concretized.

spack.cmd.matching_specs_from_env(specs)

Same as matching_spec_from_env but respects spec unification rules.

For each spec, if there is a matching spec in the environment it is used. If no matching spec is found, this will return the given spec but concretized in the context of the active environment and other given specs, with unification rules applied.

spack.cmd.parse_specs(args: str | List[str], concretize: bool = False, tests: bool | Iterable[str] = False) → List[Spec]

Convenience function for parsing arguments from specs. Handles common exceptions and dies if there are errors.

spack.cmd.print_how_many_pkgs(specs, pkg_type='', suffix='')

Given a list of specs, this will print a message about how many specs are in that list.

Parameters:

• specs (list) – depending on how many items are in this list, choose the plural or singular form of the word “package”

• pkg_type (str) – the output string will mention this provided category, e.g. if pkg_type is “installed” then the message would be “3 installed packages”

spack.cmd.python_name(cmd_name)

Convert - to _ in command name, to make a valid identifier.

spack.cmd.quote_kvp(string: str) → str

For strings like name=value or name==value, quote and escape the value if needed.

This is a compromise to respect quoting of key-value pairs on the CLI. The shell strips quotes from quoted arguments, so we cannot know exactly how CLI arguments were quoted. To compensate, we re-add quotes around anything staritng with name= or name==, and we assume the rest of the argument is the value. This covers the common cases of passign flags, e.g., cflags="-O2 -g" on the command line.

spack.cmd.remove_options(parser, *options)

Remove some options from a parser.

spack.cmd.require_active_env(parser)

Used by commands to get the active environment.

If an environment is not found, calls parser.error() which prints usage and exits.

Parameters:

parser – the subparser for the command (typically args.subparser)

Returns:

the active environment

Return type:

(spack.environment.Environment)

spack.cmd.require_cmd_name(cname)

Require that the provided name is a valid command name (per cmd_name()). Useful for checking parameters for function prerequisites.

spack.cmd.require_python_name(pname)

Require that the provided name is a valid python name (per python_name()). Useful for checking parameters for function prerequisites.

spack.cmd.spack_is_git_repo()

Ensure that this instance of Spack is a git clone.

Subpackages

• spack.cmd.common package
  • shell_init_instructions()
  • Submodules
  • spack.cmd.common.arguments module
    • add_common_arguments()
  • spack.cmd.common.confirmation module
    • confirm_action()
  • spack.cmd.common.env_utility module
    • AreDepsInstalledVisitor
      • AreDepsInstalledVisitor.accept()
      • AreDepsInstalledVisitor.neighbors()
    • emulate_env_utility()
    • setup_parser()
  • spack.cmd.common.spec_strings module
• spack.cmd.modules package
  • add_loads_arguments()
  • callbacks
  • check_module_set_name()
  • find()
  • loads()
  • modules_cmd()
  • one_spec_or_raise()
  • refresh()
  • rm()
  • setup_parser()
  • Submodules
  • spack.cmd.modules.lmod module
    • add_command()
    • setdefault()
  • spack.cmd.modules.tcl module
    • add_command()
    • setdefault()

Submodules

spack.cmd.add module

spack.cmd.add.add(parser, args)

spack.cmd.add.setup_parser(subparser: ArgumentParser) → None

spack.cmd.arch module

spack.cmd.arch.arch(parser, args)

spack.cmd.arch.display_targets(targets)

Prints a human readable list of the targets passed as argument.

spack.cmd.arch.setup_parser(subparser: ArgumentParser) → None

spack.cmd.audit module

spack.cmd.audit.audit(parser, args)

spack.cmd.audit.configs(parser, args)

spack.cmd.audit.externals(parser, args)

spack.cmd.audit.list(parser, args)

spack.cmd.audit.packages(parser, args)

spack.cmd.audit.packages_https(parser, args)

spack.cmd.audit.setup_parser(subparser: ArgumentParser) → None

spack.cmd.blame module

spack.cmd.blame.blame(parser, args)

spack.cmd.blame.dump_json(rows, last_mod, total_lines, emails)

Dump the blame as a json object to the terminal.

spack.cmd.blame.ensure_full_history(prefix: str, path: str) → None

Ensure the git repository at the prefix has its full history.

Parameters:

• prefix – the root directory of the git repository

• path – the package or file name under consideration (for messages)

spack.cmd.blame.git_prefix(path: str | Path) → Path | None

Return the top level directory if path is under a git repository.

Parameters:

path – path of the item presumably under a git repository

Returns: path to the root of the git repository

spack.cmd.blame.git_supports_unshallow() → bool

spack.cmd.blame.package_repo_root(path: str | Path) → Path | None

Find the appropriate package repository’s git root directory.

Provides a warning for a remote package repository since there is a risk that the blame results are inaccurate.

Parameters:

path – path to an arbitrary file presumably in one of the spack package repos

Returns: path to the package repository’s git root directory or None

spack.cmd.blame.print_table(rows, last_mod, total_lines, emails)

Given a set of rows with authors and lines, print a table.

spack.cmd.blame.setup_parser(subparser: ArgumentParser) → None

spack.cmd.bootstrap module

spack.cmd.bootstrap.LOCAL_MIRROR_DIR

Subdirectory where to create the mirror

spack.cmd.bootstrap.bootstrap(parser, args)

spack.cmd.bootstrap.setup_parser(subparser: ArgumentParser) → None

spack.cmd.build_env module

spack.cmd.build_env.build_env(parser, args)

spack.cmd.buildcache module

exception spack.cmd.buildcache.PackageNotInstalledError(message: str, long_message: str | None = None)

Bases: SpackError

Raised when a spec is not installed but picked to be packaged.

exception spack.cmd.buildcache.PackagesAreNotInstalledError(specs: List[Spec])

Bases: SpackError

Raised when a list of specs is not installed but picked to be packaged.

class spack.cmd.buildcache.ViewUpdateMode(*values)

Bases: Enum

APPEND

CREATE

OVERWRITE

spack.cmd.buildcache.buildcache(parser, args)

spack.cmd.buildcache.check_fn(args: Namespace)

check specs against remote binary mirror(s) to see if any need to be rebuilt

this command uses the process exit code to indicate its result, specifically, if the exit code is non-zero, then at least one of the indicated specs needs to be rebuilt

spack.cmd.buildcache.check_index_fn(args)

Check if a build cache index, manifests, and blobs are consistent

spack.cmd.buildcache.copy_buildcache_entry(cache_entry: URLBuildcacheEntry, destination_url: str)

Download buildcache entry and copy it to the destination_url

spack.cmd.buildcache.download_fn(args)

download buildcache entry from a remote mirror to local folder

this command uses the process exit code to indicate its result, specifically, a non-zero exit code indicates that the command failed to download at least one of the required buildcache components

spack.cmd.buildcache.install_fn(args)

install from a binary package

spack.cmd.buildcache.keys_fn(args)

get public keys available on mirrors

spack.cmd.buildcache.list_fn(args)

list binary packages available from mirrors

spack.cmd.buildcache.manifest_copy(manifest_file_list: List[str], dest_mirror: Mirror | None = None)

Read manifest files containing information about specific specs to copy from source to destination, remove duplicates since any binary package for a given hash should be the same as any other, and copy all files specified in the manifest files.

spack.cmd.buildcache.migrate_fn(args)

perform in-place binary mirror migration (2 to 3)

A mirror can contain both layout version 2 and version 3 simultaneously without interference. This command performs in-place migration of a binary mirror laid out according to version 2, to a binary mirror laid out according to layout version 3. Only indexed specs will be migrated, so consider updating the mirror index before running this command. Re-run the command to migrate any missing items.

The default mode of operation is to perform a signed migration, that is, spack will attempt to verify the signatures on specs, and then re-sign them before migration, using whatever keys are already installed in your key ring. You can migrate a mirror of unsigned binaries (or convert a mirror of signed binaries to unsigned) by providing the --unsigned argument.

By default spack will leave the original mirror contents (in the old layout) in place after migration. You can have spack remove the old contents by providing the --delete-existing argument. Because migrating a mostly-already-migrated mirror should be fast, consider a workflow where you perform a default migration, (i.e. preserve the existing layout rather than deleting it) then evaluate the state of the migrated mirror by attempting to install from it, and finally running the migration again with --delete-existing.

spack.cmd.buildcache.mirror_update_keys(mirror: Mirror)

spack.cmd.buildcache.prune_fn(args)

prune buildcache entries from the mirror

If a keeplist file is provided, performs direct pruning (deletes packages not in keeplist) followed by orphan pruning. If no keeplist is provided, only performs orphan pruning.

spack.cmd.buildcache.push_fn(args)

create a binary package and push it to a mirror

spack.cmd.buildcache.save_specfile_fn(args)

get full spec for dependencies and write them to files in the specified output directory

uses exit code to signal success or failure. an exit code of zero means the command was likely successful. if any errors or exceptions are encountered, or if expected command-line arguments are not provided, then the exit code will be non-zero

spack.cmd.buildcache.setup_parser(subparser: ArgumentParser)

spack.cmd.buildcache.sync_fn(args)

sync binaries (and associated metadata) from one mirror to another

requires an active environment in order to know which specs to sync

spack.cmd.buildcache.update_index(mirror: Mirror, update_keys=False, timer=timer_mod.NULL_TIMER)

spack.cmd.buildcache.update_index_fn(args)

update a buildcache index or index view if extra arguments are provided.

spack.cmd.buildcache.update_view(mirror: Mirror, update_mode: ViewUpdateMode, *sources: str, name: str | None = None, update_keys: bool = False, yes_to_all: bool = False, parser)

update a buildcache view index

spack.cmd.cd module

spack.cmd.cd.cd(parser, args)

spack.cmd.cd.setup_parser(subparser: ArgumentParser) → None

This is for decoration – spack cd is used through spack’s shell support. This allows spack cd to print a descriptive help message when called with -h.

spack.cmd.change module

spack.cmd.change.change(parser, args)

spack.cmd.change.setup_parser(subparser: ArgumentParser) → None

spack.cmd.checksum module

spack.cmd.checksum.add_versions_to_pkg(path: str, version_lines: str) → int

Add new versions to a package.py file. Returns the number of versions added.

spack.cmd.checksum.checksum(parser, args)

spack.cmd.checksum.print_checksum_status(pkg: PackageBase, version_hashes: dict)

Verify checksums present in version_hashes against those present in the package’s instructions.

Parameters:

• pkg (spack.package_base.PackageBase) – A package class for a given package in Spack.

• version_hashes (dict) – A dictionary of the form: version -> checksum.

spack.cmd.checksum.setup_parser(subparser: ArgumentParser) → None

spack.cmd.ci module

spack.cmd.ci.ci(parser, args)

spack.cmd.ci.ci_generate(args)

generate jobs file from a CI-aware spack file

if you want to report the results on CDash, you will need to set the SPACK_CDASH_AUTH_TOKEN before invoking this command. the value must be the CDash authorization token needed to create a build group and register all generated jobs under it

spack.cmd.ci.ci_rebuild(args)

rebuild a spec if it is not on the remote mirror

check a single spec against the remote mirror, and rebuild it from source if the mirror does not contain the hash

spack.cmd.ci.ci_reindex(args)

rebuild the buildcache index for the remote mirror

use the active, gitlab-enabled environment to rebuild the buildcache index for the associated mirror

spack.cmd.ci.ci_reproduce(args)

generate instructions for reproducing the spec rebuild job

artifacts of the provided gitlab pipeline rebuild job’s URL will be used to derive instructions for reproducing the build locally

spack.cmd.ci.ci_verify_versions(args)

validate version checksum & commits between git refs This command takes a from_ref and to_ref arguments and then parses the git diff between the two to determine which packages have been modified verifies the new checksums inside of them.

spack.cmd.ci.deindent(desc)

spack.cmd.ci.setup_parser(subparser: ArgumentParser) → None

spack.cmd.ci.unicode_escape(path: str) → str

Returns transformed path with any unicode characters replaced with their corresponding escapes

spack.cmd.ci.validate_git_versions(pkg: PackageBase, versions: List[StandardVersion]) → bool

Get and test the commit and tag of a package version based on a git repository. :param pkg: Spack package for which to validate a version :param versions: list of package versions to validate

Returns: True if all versions are valid, False if any version is invalid.

spack.cmd.ci.validate_standard_versions(pkg: PackageBase, versions: List[StandardVersion]) → bool

Get and test the checksum of a package version based on a tarball. :param pkg: Spack package for which to validate a version checksum :param versions: list of package versions to validate

Returns: True if all versions are valid, False if any version is invalid.

spack.cmd.clean module

class spack.cmd.clean.AllClean(option_strings, dest, nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None, deprecated=False)

Bases: Action

Activates flags -s -d -f -m -p and -b simultaneously

spack.cmd.clean.clean(parser, args)

spack.cmd.clean.remove_python_cache()

spack.cmd.clean.setup_parser(subparser: ArgumentParser) → None

spack.cmd.commands module

class spack.cmd.commands.BashCompletionWriter(prog: str, out: IO = sys.stdout, aliases: bool = False)

Bases: ArgparseWriter

Write argparse output as bash programmable tab completion.

body(positionals: Sequence, optionals: Sequence[str], subcommands: Sequence[str]) → str

Return the body of the function.

Parameters:

• positionals – List of positional argument tuples (name, choices, nargs, help).

• optionals – List of optional arguments.

• subcommands – List of subcommand parsers.

Returns:

Function body.

end_function(prog: str) → str

Return the syntax needed to end a function definition.

Parameters:

prog – Program name

Returns:

Function definition ending.

format(cmd: Command) → str

Return the string representation of a single node in the parser tree.

Parameters:

cmd – Parsed information about a command or subcommand.

Returns:

String representation of this subcommand.

optionals(optionals: Sequence[str]) → str

Return the syntax for reporting optional flags.

Parameters:

optionals – List of optional arguments.

Returns:

Syntax for optional flags.

positionals(positionals: Sequence) → str

Return the syntax for reporting positional arguments.

Parameters:

positionals – List of positional argument tuples (name, choices, nargs, help).

Returns:

Syntax for positional arguments.

start_function(prog: str) → str

Return the syntax needed to begin a function definition.

Parameters:

prog – Program name.

Returns:

Function definition beginning.

subcommands(subcommands: Sequence[str]) → str

Return the syntax for reporting subcommands.

Parameters:

subcommands – List of subcommand parsers.

Returns:

Syntax for subcommand parsers

class spack.cmd.commands.FishCompletionWriter(prog: str, out: IO = sys.stdout, aliases: bool = False)

Bases: ArgparseWriter

Write argparse output as bash programmable tab completion.

complete(prog: str, positionals: List[Tuple[str, Iterable[Any] | None, int | str | None, str]], optionals: List[Tuple[Sequence[str], List[str], str, int | str | None, str]], subcommands: List[Tuple[ArgumentParser, str, str]]) → str

Return all the completion commands.

Parameters:

• prog – Program name.

• positionals – List of positional arguments.

• optionals – List of optional arguments.

• subcommands – List of subcommand parsers.

Returns:

Completion command.

static complete_head(prog: str, index: int | None = None, nargs: str | int | None = None) → str

Return the head of the completion command.

Parameters:

• prog – Program name.

• index – Index of positional argument.

• nargs – Number of arguments.

Returns:

Head of the completion command.

format(cmd: Command) → str

Return the string representation of a single node in the parser tree.

Parameters:

cmd – Parsed information about a command or subcommand.

Returns:

String representation of a node.

optionals(prog: str, optionals: List[Tuple[Sequence[str], List[str], str, int | str | None, str]]) → str

Return the completion for optional arguments.

Parameters:

• prog – Program name.

• optionals – List of optional arguments.

Returns:

Completion command.

optspecs(prog: str, optionals: List[Tuple[Sequence[str], List[str], str, int | str | None, str]]) → str

Read the optionals and return the command to set optspec.

Parameters:

• prog – Program name.

• optionals – List of optional arguments.

Returns:

Command to set optspec variable.

positionals(prog: str, positionals: List[Tuple[str, Iterable[Any] | None, int | str | None, str]]) → str

Return the completion for positional arguments.

Parameters:

• prog – Program name.

• positionals – List of positional arguments.

Returns:

Completion command.

prog_comment(prog: str) → str

Return a comment line for the command.

subcommands(prog: str, subcommands: List[Tuple[ArgumentParser, str, str]]) → str

Return the completion for subcommands.

Parameters:

• prog – Program name.

• subcommands – List of subcommand parsers.

Returns:

Completion command.

class spack.cmd.commands.SpackArgparseRstWriter(prog: str, out: IO = sys.stdout, aliases: bool = False, documented_commands: Set[str] = set(), rst_levels: Sequence[str] = ['-', '-', '^', '~', ':', '`'])

Bases: ArgparseRstWriter

RST writer tailored for spack documentation.

usage(usage: str) → str

Example usage of a command.

Parameters:

usage – Command usage.

Returns:

Usage of a command.

class spack.cmd.commands.SubcommandWriter(prog: str, out: IO = sys.stdout, aliases: bool = False)

Bases: ArgparseWriter

Write argparse output as a list of subcommands.

format(cmd: Command) → str

Return the string representation of a single node in the parser tree.

Parameters:

cmd – Parsed information about a command or subcommand.

Returns:

String representation of this subcommand.

spack.cmd.commands.bash(args: Namespace, out: IO) → None

Bash tab-completion script.

Parameters:

• args – Command-line arguments.

• out – File object to write to.

spack.cmd.commands.commands(parser: ArgumentParser, args: Namespace) → None

Main function that calls formatter functions.

Parameters:

• parser – Argument parser.

• args – Command-line arguments.

spack.cmd.commands.fish(args, out)

spack.cmd.commands.formatter(func: Callable[[Namespace, IO], None]) → Callable[[Namespace, IO], None]

Decorator used to register formatters.

Parameters:

func – Formatting function.

Returns:

The same function.

spack.cmd.commands.formatters: Dict[str, Callable[[Namespace, IO], None]]

list of command formatters

spack.cmd.commands.get_all_spack_commands(out: IO) → SpackArgumentParser

spack.cmd.commands.names(args: Namespace, out: IO) → None

Simple list of top-level commands.

Parameters:

• args – Command-line arguments.

• out – File object to write to.

spack.cmd.commands.prepend_header(args: Namespace, out: IO) → None

Prepend header text at the beginning of a file.

Parameters:

• args – Command-line arguments.

• out – File object to write to.

spack.cmd.commands.rst(args: Namespace, out: IO) → None

ReStructuredText documentation of subcommands.

Parameters:

• args – Command-line arguments.

• out – File object to write to.

spack.cmd.commands.rst_index(out: IO) → None

Generate an index of all commands.

Parameters:

out – File object to write to.

spack.cmd.commands.setup_parser(subparser: ArgumentParser) → None

Set up the argument parser.

Parameters:

subparser – Preliminary argument parser.

spack.cmd.commands.subcommands(args: Namespace, out: IO) → None

Hierarchical tree of subcommands.

Parameters:

• args – Command-line arguments.

• out – File object to write to.

spack.cmd.commands.update_completion(parser: ArgumentParser, args: Namespace) → None

Iterate through the shells and update the standard completion files.

This is a convenience method to avoid calling this command many times, and to simplify completion update for developers.

Parameters:

• parser – Argument parser.

• args – Command-line arguments.

spack.cmd.commands.update_completion_args: Dict[str, Dict[str, Any]]

standard arguments for updating completion scripts we iterate through these when called with --update-completion

spack.cmd.compiler module

spack.cmd.compiler.compiler(parser, args)

spack.cmd.compiler.compiler_find(args)

Search either $PATH or a list of paths OR MODULES for compilers and add them to Spack’s configuration.

spack.cmd.compiler.compiler_info(args)

Print info about all compilers matching a spec.

spack.cmd.compiler.compiler_list(args)

spack.cmd.compiler.compiler_remove(args)

spack.cmd.compiler.setup_parser(subparser: ArgumentParser) → None

spack.cmd.compilers module

spack.cmd.compilers.compilers(parser, args)

spack.cmd.compilers.setup_parser(subparser: ArgumentParser) → None

spack.cmd.concretize module

spack.cmd.concretize.concretize(parser, args)

spack.cmd.concretize.setup_parser(subparser: ArgumentParser) → None

spack.cmd.config module

spack.cmd.config.config(parser, args)

spack.cmd.config.config_add(args)

Add the given configuration to the specified config scope

This is a stateful operation that edits the config files.

spack.cmd.config.config_blame(args)

Print out line-by-line blame of merged YAML.

spack.cmd.config.config_change(args)

spack.cmd.config.config_edit(args)

Edit the configuration file for a specific scope and config section.

With no arguments and an active environment, edit the spack.yaml for the active environment.

spack.cmd.config.config_get(args)

Dump merged YAML configuration for a specific section.

With no arguments and an active environment, print the contents of the environment’s manifest file (spack.yaml).

spack.cmd.config.config_list(args)

List the possible configuration sections.

Used primarily for shell tab completion scripts.

spack.cmd.config.config_prefer_upstream(args)

Generate a packages config based on the configuration of all upstream installs.

spack.cmd.config.config_remove(args)

Remove the given configuration from the specified config scope

This is a stateful operation that edits the config files.

spack.cmd.config.config_revert(args)

spack.cmd.config.config_scopes(args)

List configured scopes in descending order of precedence.

spack.cmd.config.config_update(args)

spack.cmd.config.print_configuration(args, *, blame: bool) → None

spack.cmd.config.print_flattened_configuration(*, blame: bool, yaml: bool) → None

Prints to stdout a flattened version of the configuration.

Parameters:

blame – if True, shows file provenance for each entry in the configuration.

spack.cmd.config.setup_parser(subparser: ArgumentParser) → None

spack.cmd.containerize module

spack.cmd.containerize.containerize(parser, args)

spack.cmd.containerize.setup_parser(subparser: ArgumentParser) → None

spack.cmd.create module

class spack.cmd.create.AutoreconfPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Autotools-based packages that do not come with a configure script

base_class_name

body_def

dependencies

package_class_import

class spack.cmd.create.AutotoolsPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Autotools-based packages that do come with a configure script

base_class_name

body_def

package_class_import

class spack.cmd.create.BazelPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Bazel-based packages

body_def

dependencies

class spack.cmd.create.BuildSystemAndLanguageGuesser

Bases: object

An instance of BuildSystemAndLanguageGuesser provides a callable object to be used during spack create. By passing this object to spack checksum, we can take a peek at the fetched tarball and discern the build system it uses

property languages: List[str]

class spack.cmd.create.BundlePackageTemplate(name: str, versions, languages: List[str])

Bases: object

Provides the default values to be used for a bundle package file template.

base_class_name

body_def

dependencies

package_class_import

url_def

write(pkg_path)

Writes the new package file.

class spack.cmd.create.CMakePackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for CMake-based packages

base_class_name

body_def

package_class_import

spack.cmd.create.CXX_EXT

C++ file extensions

spack.cmd.create.C_EXT

C file extensions

class spack.cmd.create.CargoPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for cargo-based packages

base_class_name

body_def

package_class_import

spack.cmd.create.FORTRAN_EXT

Fortran file extensions

class spack.cmd.create.GoPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Go-module-based packages

base_class_name

body_def

package_class_import

class spack.cmd.create.IntelPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for licensed Intel software

base_class_name

body_def

package_class_import

class spack.cmd.create.LuaPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for LuaRocks-based packages

base_class_name

body_def

package_class_import

class spack.cmd.create.MakefilePackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Makefile packages

base_class_name

body_def

package_class_import

class spack.cmd.create.MavenPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Maven-based packages

base_class_name

body_def

package_class_import

class spack.cmd.create.MesonPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for meson-based packages

base_class_name

body_def

package_class_import

class spack.cmd.create.OctavePackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for octave packages

base_class_name

dependencies

package_class_import

class spack.cmd.create.PackageTemplate(name, url, versions, languages: List[str])

Bases: BundlePackageTemplate

Provides the default values to be used for the package file template

base_class_name

body_def

package_class_import

url_line

class spack.cmd.create.PerlbuildPackageTemplate(name, url, versions, languages: List[str])

Bases: PerlmakePackageTemplate

Provides appropriate overrides for Perl extensions that come with a Build.PL instead of a Makefile.PL

dependencies

class spack.cmd.create.PerlmakePackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Perl extensions that come with a Makefile.PL

base_class_name

body_def

dependencies

package_class_import

class spack.cmd.create.PythonPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for python extensions

base_class_name

body_def

dependencies

package_class_import

class spack.cmd.create.QMakePackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for QMake-based packages

base_class_name

body_def

package_class_import

class spack.cmd.create.RPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for R extensions

base_class_name

body_def

dependencies

package_class_import

class spack.cmd.create.RacketPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Racket extensions

base_class_name

body_def

dependencies

package_class_import

url_line

class spack.cmd.create.RubyPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for Ruby packages

base_class_name

body_def

dependencies

package_class_import

class spack.cmd.create.SIPPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for SIP packages.

base_class_name

body_def

package_class_import

class spack.cmd.create.SconsPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate overrides for SCons-based packages

base_class_name

body_def

package_class_import

class spack.cmd.create.WafPackageTemplate(name, url, versions, languages: List[str])

Bases: PackageTemplate

Provides appropriate override for Waf-based packages

base_class_name

body_def

package_class_import

spack.cmd.create.create(parser, args)

spack.cmd.create.get_build_system(template: str | None, url: str, guesser: BuildSystemAndLanguageGuesser) → str

Determine the build system template.

If a template is specified, always use that. Otherwise, if a URL is provided, download the tarball and peek inside to guess what build system it uses. Otherwise, use a generic template by default.

Parameters:

• template – --template argument given to spack create

• url – url argument given to spack create

• guesser – The first_stage_function given to spack checksum which records the build system it detects

Returns:

The name of the build system template to use

Return type:

str

spack.cmd.create.get_name(name, url)

Get the name of the package based on the supplied arguments.

If a name was provided, always use that. Otherwise, if a URL was provided, extract the name from that. Otherwise, use a default.

Parameters:

• name (str) – explicit --name argument given to spack create

• url (str) – url argument given to spack create

Returns:

The name of the package

Return type:

str

spack.cmd.create.get_repository(args: Namespace, name: str) → Repo

Returns a Repo object that will allow us to determine the path where the new package file should be created.

Parameters:

• args – The arguments given to spack create

• name – The name of the package to create

Returns:

A Repo object capable of determining the path to the package file

spack.cmd.create.get_url(url: str | None) → str

Get the URL to use.

Use a default URL if none is provided.

Parameters:

url – url argument to spack create

Returns: The URL of the package

spack.cmd.create.get_versions(args: Namespace, name: str) → Tuple[str, BuildSystemAndLanguageGuesser]

Returns a list of versions and hashes for a package.

Also returns a BuildSystemAndLanguageGuesser object.

Returns default values if no URL is provided.

Parameters:

• args – The arguments given to spack create

• name – The name of the package

Returns: Tuple of versions and hashes, and a BuildSystemAndLanguageGuesser object

spack.cmd.create.setup_parser(subparser: ArgumentParser) → None

spack.cmd.debug module

spack.cmd.debug.debug(parser, args)

spack.cmd.debug.report(args)

spack.cmd.debug.setup_parser(subparser: ArgumentParser) → None

spack.cmd.deconcretize module

spack.cmd.deconcretize.deconcretize(parser, args)

spack.cmd.deconcretize.deconcretize_specs(args, specs)

spack.cmd.deconcretize.get_deconcretize_list(args: Namespace, specs: List[Spec], env: Environment) → List[Spec]

Get list of environment roots to deconcretize

spack.cmd.deconcretize.setup_parser(subparser: ArgumentParser) → None

spack.cmd.dependencies module

spack.cmd.dependencies.dependencies(parser, args)

spack.cmd.dependencies.setup_parser(subparser: ArgumentParser) → None

spack.cmd.dependents module

spack.cmd.dependents.dependents(parser, args)

spack.cmd.dependents.get_dependents(pkg_name, ideps, transitive=False, dependents=None)

Get all dependents for a package.

Parameters:

• pkg_name (str) – name of the package whose dependents should be returned

• ideps (dict) – dictionary of dependents, from inverted_dependencies()

• transitive (bool or None) – return transitive dependents when True

spack.cmd.dependents.inverted_dependencies()

Iterate through all packages and return a dictionary mapping package names to possible dependencies.

Virtual packages are included as sources, so that you can query dependents of, e.g., mpi, but virtuals are not included as actual dependents.

spack.cmd.dependents.setup_parser(subparser: ArgumentParser) → None

spack.cmd.deprecate module

Deprecate one Spack install in favor of another

Spack packages of different configurations cannot be installed to the same location. However, in some circumstances (e.g. security patches) old installations should never be used again. In these cases, we will mark the old installation as deprecated, remove it, and link another installation into its place.

It is up to the user to ensure binary compatibility between the deprecated installation and its deprecator.

spack.cmd.deprecate.deprecate(parser, args)

Deprecate one spec in favor of another

spack.cmd.deprecate.setup_parser(sp: ArgumentParser) → None

spack.cmd.dev_build module

spack.cmd.dev_build.dev_build(self, args)

spack.cmd.dev_build.setup_parser(subparser: ArgumentParser) → None

spack.cmd.develop module

spack.cmd.develop.assure_concrete_spec(env: Environment, spec: Spec)

spack.cmd.develop.develop(parser, args)

spack.cmd.develop.setup_parser(subparser: ArgumentParser) → None

spack.cmd.develop.setup_src_code(spec: Spec, src_path: str, clone: bool = True, force: bool = False)

Handle checking, cloning or overwriting source code

spack.cmd.develop.update_env(env: Environment, spec: Spec, specified_path: str | None = None, build_dir: str | None = None, apply_changes: bool = True)

Update the spack.yaml file with additions or changes from a develop call

spack.cmd.diff module

spack.cmd.diff.compare_specs(a, b, to_string=False, color=None, ignore_packages=None)

Generate a comparison, including diffs (for each side) and an intersection.

We can either print the result to the console, or parse into a json object for the user to save. We return an object that shows the differences, intersection, and names for a pair of specs a and b.

Parameters:

• a (spack.spec.Spec) – the first spec to compare

• b (spack.spec.Spec) – the second spec to compare

• a_name (str) – the name of spec a

• b_name (str) – the name of spec b

• to_string (bool) – return an object that can be json dumped

• color (bool) – whether to format the names for the console

spack.cmd.diff.diff(parser, args)

spack.cmd.diff.flatten(functions)

Given a list of ASP functions, convert into a list of key: value tuples.

We are squashing whatever is after the first index into one string for easier parsing in the interface

spack.cmd.diff.print_difference(c, attributes='all', out=None)

Print the difference.

Given a diffset for A and a diffset for B, print red/green diffs to show the differences.

spack.cmd.diff.setup_parser(subparser: ArgumentParser) → None

spack.cmd.diff.shift(asp_function: AspFunction) → AspFunction

Transforms attr("foo", "bar") into foo("bar").

spack.cmd.docs module

spack.cmd.docs.docs(parser, args)

spack.cmd.edit module

spack.cmd.edit.edit(parser, args)

spack.cmd.edit.locate_build_system(name: str, repo: Repo | None) → str

spack.cmd.edit.locate_file(name: str, path: str) → str

spack.cmd.edit.locate_package(name: str, repo: Repo | None) → str

spack.cmd.edit.setup_parser(subparser: ArgumentParser) → None

spack.cmd.env module

class spack.cmd.env.ViewAction

Bases: object

static actions()

disable

enable

regenerate

spack.cmd.env.create_temp_env_directory()

Returns the path of a temporary directory in which to create an environment

spack.cmd.env.env(parser, args)

Look for a function called environment_<name> and call it.

spack.cmd.env.env_activate(args)

spack.cmd.env.env_activate_setup_parser(subparser)

set the active environment

spack.cmd.env.env_create(args)

spack.cmd.env.env_create_setup_parser(subparser)

create a new environment

create a new environment or, optionally, copy an existing environment

a manifest file results in a new abstract environment while a lock file creates a new concrete environment

spack.cmd.env.env_deactivate(args)

spack.cmd.env.env_deactivate_setup_parser(subparser)

deactivate the active environment

spack.cmd.env.env_depfile(args)

spack.cmd.env.env_depfile_setup_parser(subparser)

generate a depfile to exploit parallel builds across specs

requires the active environment to be concrete

spack.cmd.env.env_list(args)

spack.cmd.env.env_list_setup_parser(subparser)

list all managed environments

spack.cmd.env.env_loads(args)

spack.cmd.env.env_loads_setup_parser(subparser)

list modules for an installed environment ‘(see spack module loads)’

spack.cmd.env.env_remove(args)

remove existing environment(s)

spack.cmd.env.env_remove_setup_parser(subparser)

remove managed environment(s)

remove existing environment(s) managed by Spack

directory environments and manifests embedded in repositories must be removed manually

spack.cmd.env.env_rename(args)

rename or move an existing environment

spack.cmd.env.env_rename_setup_parser(subparser)

rename an existing environment

rename a managed environment or move an independent/directory environment

operation cannot be performed to or from an active environment

spack.cmd.env.env_revert(args)

restore the environment manifest to its previous format

spack.cmd.env.env_revert_setup_parser(subparser)

restore the environment manifest to its previous format

revert the environment’s manifest to the schema format from its last ‘spack env update’

the current manifest will be overwritten by the backup copy and the backup copy will be removed

spack.cmd.env.env_status(args)

spack.cmd.env.env_status_setup_parser(subparser)

print active environment status

spack.cmd.env.env_track(args)

spack.cmd.env.env_track_setup_parser(subparser)

track an environment from a directory in Spack

spack.cmd.env.env_untrack(args)

spack.cmd.env.env_untrack_setup_parser(subparser)

untrack an environment from a directory in Spack

spack.cmd.env.env_update(args)

update the manifest to the latest format

spack.cmd.env.env_update_setup_parser(subparser)

update the environment manifest to the latest schema format

update the environment to the latest schema format, which may not be readable by older versions of spack

a backup copy of the manifest is retained in case there is a need to revert this operation

spack.cmd.env.env_view(args)

spack.cmd.env.env_view_setup_parser(subparser)

manage the environment’s view

provide the path when enabling a view with a non-default path

spack.cmd.env.filter_managed_env_names(env_names: Set[str]) → Set[str]

spack.cmd.env.get_valid_envs(env_names: Set[str]) → Set[Environment]

spack.cmd.env.setup_parser(subparser: ArgumentParser) → None

spack.cmd.env.subcommand_functions

Dictionary mapping subcommand names and aliases to functions

spack.cmd.env.subcommands: List[Tuple[str, ...]]

List of subcommands of spack env

spack.cmd.extensions module

spack.cmd.extensions.extensions(parser, args)

spack.cmd.extensions.setup_parser(subparser: ArgumentParser) → None

spack.cmd.external module

exception spack.cmd.external.NoManifestFileError(message: str, long_message: str | None = None)

Bases: SpackError

spack.cmd.external.external(parser, args)

spack.cmd.external.external_find(args)

spack.cmd.external.external_list(args)

spack.cmd.external.external_read_cray_manifest(args)

spack.cmd.external.packages_to_search_for(*, names: List[str] | None, tags: List[str], exclude: List[str] | None)

spack.cmd.external.setup_parser(subparser: ArgumentParser) → None

spack.cmd.fetch module

spack.cmd.fetch.fetch(parser, args)

spack.cmd.fetch.setup_parser(subparser: ArgumentParser) → None

spack.cmd.find module

spack.cmd.find.display_env(env, args, decorator, results)

Display extra find output when running in an environment.

In an environment, spack find outputs a preliminary section showing the root specs of the environment (this is in addition to the section listing out specs matching the query parameters).

spack.cmd.find.find(parser, args)

spack.cmd.find.make_env_decorator(env)

Create a function for decorating specs when in an environment.

spack.cmd.find.query_arguments(args)

spack.cmd.find.setup_parser(subparser: ArgumentParser) → None

spack.cmd.gc module

spack.cmd.gc.gc(parser, args)

spack.cmd.gc.roots_from_environments(args, active_env)

spack.cmd.gc.setup_parser(subparser: ArgumentParser) → None

spack.cmd.gpg module

spack.cmd.gpg.gpg(parser, args)

spack.cmd.gpg.gpg_create(args)

create a new key

spack.cmd.gpg.gpg_export(args)

export a gpg key, optionally including secret key

spack.cmd.gpg.gpg_init(args)

add the default keys to the keyring

spack.cmd.gpg.gpg_list(args)

list keys available in the keyring

spack.cmd.gpg.gpg_publish(args)

publish public keys to a build cache

spack.cmd.gpg.gpg_sign(args)

sign a package

spack.cmd.gpg.gpg_trust(args)

add a key to the keyring

spack.cmd.gpg.gpg_untrust(args)

remove a key from the keyring

spack.cmd.gpg.gpg_verify(args)

verify a signed package

spack.cmd.gpg.setup_parser(subparser: ArgumentParser) → None

spack.cmd.graph module

spack.cmd.graph.graph(parser, args)

spack.cmd.graph.setup_parser(subparser: ArgumentParser) → None

spack.cmd.help module

spack.cmd.help.help(parser, args)

spack.cmd.help.setup_parser(subparser: ArgumentParser) → None

spack.cmd.info module

class spack.cmd.info.DependencyFormatter

Bases: Formatter

format_name(dep: Dependency) → str

format_values(dep: Dependency) → str

class spack.cmd.info.Formatter

Bases: object

Generic formatter for elements displayed by spack info.

Elements have four parts: name, values, when condition, and description. They can be formatted two ways (shown here for variants):

Grouped by when (default):

when +cuda
  cuda_arch [none]                            none, 10, 100, 100a, 101,
                                              101a, 11, 12, 120, 120a, 13
      CUDA architecture

Or, by name (each name has a when nested under it):

cuda_arch [none]                              none, 10, 100, 100a, 101,
                                              101a, 11, 12, 120, 120a, 13
  when +cuda
    CUDA architecture

The values and description will be wrapped if needed. the name (and any additional info) will not (so they should be kept short).

Subclasses are responsible for generating colorized text, but not wrapping, indentation, or other formatting, for the name, values, and description.

format_description(element: Any) → str

format_name(element: Any) → str

format_values(element: Any) → str

spack.cmd.info.MIN_VALUES_WIDTH

Allow at least this much room for values when formatting definitions Wrap after a long variant name/condition if we need to do so to preserve this width.

class spack.cmd.info.VariantFormatter

Bases: Formatter

format_description(variant: Variant) → str

format_name(variant: Variant) → str

format_values(variant: Variant) → str

spack.cmd.info.count_bool_variant_conditions(when_indexed_dictionary: Dict[Spec, Any]) → List[Tuple[int, Tuple[str, bool]]]

Counts boolean variants in whens in a dictionary.

Returns a list of the most used when conditions for boolean variants along with their value.

spack.cmd.info.format_deptype(depflag: int) → str

spack.cmd.info.info(parser: ArgumentParser, args: Namespace) → None

spack.cmd.info.max_name_length(when_indexed_dictionary: Dict, formatter: Formatter) → int

spack.cmd.info.padder(str_list: Iterable, extra: int = 0) → Callable

Return a function to pad elements of a list.

spack.cmd.info.print_by_name(pkg: PackageBase, header: str, when_indexed_dictionary: Dict, formatter: Formatter) → None

spack.cmd.info.print_definitions(pkg: PackageBase, header: str, when_indexed_dictionary: Dict, formatter: Formatter, by_name: bool) → None

spack.cmd.info.print_dependencies(pkg: PackageBase, args: Namespace) → None

output build, link, and run package dependencies

spack.cmd.info.print_dependency_suggestion(pkg: PackageBase) → None

spack.cmd.info.print_detectable(pkg: PackageBase, args: Namespace) → None

output information on external detection

spack.cmd.info.print_grouped_by_when(pkg: PackageBase, header: str, when_indexed_dictionary: Dict, formatter: Formatter) → None

Generic method to print metadata grouped by when conditions.

spack.cmd.info.print_header(header: str, when_indexed_dictionary: Dict, formatter: Formatter) → bool

spack.cmd.info.print_licenses(pkg: PackageBase, args: Namespace) → None

Output the licenses of the project.

spack.cmd.info.print_maintainers(pkg: PackageBase, args: Namespace) → None

output package maintainers

spack.cmd.info.print_namespace(pkg: PackageBase, args: Namespace) → None

output package namespace

spack.cmd.info.print_phases(pkg: PackageBase, args: Namespace) → None

output installation phases

spack.cmd.info.print_tags(pkg: PackageBase, args: Namespace) → None

output package tags

spack.cmd.info.print_tests(pkg: PackageBase, args: Namespace) → None

output relevant build-time and stand-alone tests

spack.cmd.info.print_variants(pkg: PackageBase, args: Namespace) → None

output variants

spack.cmd.info.print_versions(pkg: PackageBase, args: Namespace) → None

output versions

spack.cmd.info.print_virtuals(pkg: PackageBase, args: Namespace) → None

output virtual packages

spack.cmd.info.section_title(s: str) → str

spack.cmd.info.setup_parser(subparser: ArgumentParser) → None

spack.cmd.info.version(s: str) → str

spack.cmd.install module

spack.cmd.install.cache_opt(use_buildcache: str, default: Literal['auto', 'cache_only', 'source_only']) → Literal['auto', 'cache_only', 'source_only']

spack.cmd.install.compute_tests_install_kwargs(specs, cli_test_arg)

Translate the test cli argument into the proper install argument

spack.cmd.install.concrete_specs_from_cli(args, install_kwargs)

Return abstract and concrete spec parsed from the command line.

spack.cmd.install.default_log_file(spec)

Computes the default filename for the log file and creates the corresponding directory if not present

spack.cmd.install.install(parser, args)

spack.cmd.install.install_kwargs_from_args(args)

Translate command line arguments into a dictionary that will be passed to the package installer.

spack.cmd.install.install_with_active_env(env: Environment, args, install_kwargs, reporter)

spack.cmd.install.install_without_active_env(args, install_kwargs, reporter)

spack.cmd.install.report_filename(args: Namespace, specs: List[Spec]) → str

Return the filename to be used for reporting to JUnit or CDash format.

spack.cmd.install.require_user_confirmation_for_overwrite(concrete_specs, args)

spack.cmd.install.setup_parser(subparser: ArgumentParser) → None

spack.cmd.license module

class spack.cmd.license.ErrorType(*values)

Bases: Enum

GENERAL_MISMATCH

NOT_IN_FIRST_N_LINES

SPDX_MISMATCH

class spack.cmd.license.LicenseError

Bases: object

add_error(error)

error_counts: Dict[ErrorType, int]

error_messages()

has_errors()

spack.cmd.license.apache2_mit_spdx

Spack’s license identifier

spack.cmd.license.license(parser, args)

spack.cmd.license.license_line_regexes

regexes for valid license lines at tops of files

spack.cmd.license.license_lines

SPDX license id must appear in the first <license_lines> lines of a file

spack.cmd.license.licensed_files_patterns

regular expressions for licensed files.

spack.cmd.license.list_files(args)

list files in spack that should have license headers

spack.cmd.license.setup_parser(subparser: ArgumentParser) → None

spack.cmd.license.verify(args)

verify that files in spack have the right license header

spack.cmd.list module

spack.cmd.list.filter_by_name(pkgs, args)

Filters the sequence of packages according to user prescriptions

Parameters:

• pkgs – sequence of packages

• args – parsed command line arguments

Returns:

filtered and sorted list of packages

spack.cmd.list.formatter(func)

Decorator used to register formatters

spack.cmd.list.get_dependencies(pkg)

spack.cmd.list.github_url(pkg: Type[PackageBase]) → str | None

Link to a package file in spack package’s github or the path to the file.

Parameters:

pkg – package instance

Returns: URL to the package file on github or the local file path; otherwise, None.

spack.cmd.list.html(pkg_names, out)

Print out information on all packages in Sphinx HTML.

This is intended to be inlined directly into Sphinx documentation. We write HTML instead of RST for speed; generating RST from all packages causes the Sphinx build to take forever. Including this as raw HTML is much faster.

spack.cmd.list.list(parser, args)

spack.cmd.list.name_only(pkgs, out)

spack.cmd.list.rows_for_ncols(elts, ncols)

Print out rows in a table with ncols of elts laid out vertically.

spack.cmd.list.setup_parser(subparser: ArgumentParser) → None

spack.cmd.list.version_json(pkg_names, out)

Print all packages with their latest versions.

spack.cmd.load module

spack.cmd.load.load(parser, args)

spack.cmd.load.setup_parser(subparser: ArgumentParser) → None

Parser is only constructed so that this prints a nice help message with -h.

spack.cmd.location module

spack.cmd.location.location(parser, args)

spack.cmd.location.setup_parser(subparser: ArgumentParser) → None

spack.cmd.log_parse module

spack.cmd.log_parse.log_parse(parser, args)

spack.cmd.log_parse.setup_parser(subparser: ArgumentParser) → None

spack.cmd.logs module

spack.cmd.logs.logs(parser, args)

spack.cmd.logs.setup_parser(subparser: ArgumentParser) → None

spack.cmd.maintainers module

spack.cmd.maintainers.maintained_packages()

spack.cmd.maintainers.maintainers(parser, args)

spack.cmd.maintainers.maintainers_to_packages(users=None)

spack.cmd.maintainers.packages_to_maintainers(package_names=None)

spack.cmd.maintainers.setup_parser(subparser: ArgumentParser) → None

spack.cmd.maintainers.union_values(dictionary)

Given a dictionary with values that are Collections, return their union.

Parameters:

dictionary (dict) – dictionary whose values are all collections.

Returns:

the union of all collections in the dictionary’s values.

Return type:

(set)

spack.cmd.make_installer module

spack.cmd.make_installer.make_installer(parser, args)

Use CMake to generate WIX installer in newly created build directory

spack.cmd.make_installer.setup_parser(subparser: ArgumentParser) → None

spack.cmd.make_installer.txt_to_rtf(file_path)

spack.cmd.mark module

spack.cmd.mark.do_mark(specs, explicit)

Marks all the specs in a list.

Parameters:

• specs (list) – list of specs to be marked

• explicit (bool) – whether to mark specs as explicitly installed

spack.cmd.mark.find_matching_specs(specs: List[str | Spec], allow_multiple_matches: bool = False) → List[Spec]

Returns a list of specs matching the not necessarily concretized specs given from cli

Parameters:

• specs – list of specs to be matched against installed packages

• allow_multiple_matches – if True multiple matches are admitted

spack.cmd.mark.mark(parser, args)

spack.cmd.mark.mark_specs(args, specs)

spack.cmd.mark.setup_parser(subparser: ArgumentParser) → None

spack.cmd.mirror module

class spack.cmd.mirror.IncludeFilter(args)

Bases: object

spack.cmd.mirror.all_specs_with_all_versions()

spack.cmd.mirror.concrete_specs_from_cli_or_file(args)

spack.cmd.mirror.concrete_specs_from_environment()

spack.cmd.mirror.concrete_specs_from_user(args)

Return the list of concrete specs that the user wants to mirror. The list is passed either from command line or from a text file.

spack.cmd.mirror.create(path, specs, skip_unstable_versions=False)

Create a directory to be used as a spack mirror, and fill it with package archives.

Parameters:

• path – Path to create a mirror directory hierarchy in.

• specs – Any package versions matching these specs will be added to the mirror.

• skip_unstable_versions – if true, this skips adding resources when they do not have a stable archive checksum (as determined by fetch_strategy.stable_target)

Returns:

A tuple of lists, each containing specs

• present: Package specs that were already present.

• mirrored: Package specs that were successfully mirrored.

• error: Package specs that failed to mirror due to some error.

spack.cmd.mirror.create_mirror_for_all_specs(mirror_specs, path, skip_unstable_versions, workers)

spack.cmd.mirror.create_mirror_for_one_spec(candidate, mirror_cache)

spack.cmd.mirror.extend_with_additional_versions(specs, num_versions)

spack.cmd.mirror.extend_with_dependencies(specs)

Extend the input list by adding all the dependencies explicitly.

spack.cmd.mirror.filter_externals(specs)

spack.cmd.mirror.mirror(parser, args)

spack.cmd.mirror.mirror_add(args)

add a mirror to Spack

spack.cmd.mirror.mirror_create(args)

create a directory to be used as a spack mirror, and fill it with package archives

spack.cmd.mirror.mirror_destroy(args)

given a url, recursively delete everything under it

spack.cmd.mirror.mirror_list(args)

print out available mirrors to the console

spack.cmd.mirror.mirror_remove(args)

remove a mirror by name

spack.cmd.mirror.mirror_set(args)

configure the connection details of a mirror

spack.cmd.mirror.mirror_set_url(args)

change the URL of a mirror

spack.cmd.mirror.process_mirror_stats(present, mirrored, error)

spack.cmd.mirror.setup_parser(subparser: ArgumentParser) → None

spack.cmd.mirror.specs_from_text_file(filename, concretize=False)

Return a list of specs read from a text file.

The file should contain one spec per line.

Parameters:

• filename (str) – name of the file containing the abstract specs.

• concretize (bool) – if True concretize the specs before returning the list.

spack.cmd.mirror.versions_per_spec(args)

Return how many versions should be mirrored per spec.

spack.cmd.module module

spack.cmd.module.module(parser, args)

spack.cmd.module.setup_parser(subparser: ArgumentParser) → None

spack.cmd.patch module

spack.cmd.patch.patch(parser, args)

spack.cmd.patch.setup_parser(subparser: ArgumentParser) → None

spack.cmd.pkg module

spack.cmd.pkg.get_grep(required=False)

Get a grep command to use with spack pkg grep.

spack.cmd.pkg.pkg(parser, args, unknown_args)

spack.cmd.pkg.pkg_add(args)

add a package to the git stage with git add

spack.cmd.pkg.pkg_added(args)

show packages added since a commit

spack.cmd.pkg.pkg_changed(args)

show packages changed since a commit

spack.cmd.pkg.pkg_diff(args)

compare packages available in two different git revisions

spack.cmd.pkg.pkg_grep(args, unknown_args)

grep for strings in package.py files from all repositories

spack.cmd.pkg.pkg_hash(args)

dump canonical source code hash for a package spec

spack.cmd.pkg.pkg_list(args)

list packages associated with a particular spack git revision

spack.cmd.pkg.pkg_removed(args)

show packages removed since a commit

spack.cmd.pkg.pkg_source(args)

dump source code for a package

spack.cmd.pkg.setup_parser(subparser: ArgumentParser) → None

spack.cmd.providers module

spack.cmd.providers.providers(parser, args)

spack.cmd.providers.setup_parser(subparser: ArgumentParser) → None

spack.cmd.pydoc module

spack.cmd.pydoc.pydoc(parser, args)

spack.cmd.pydoc.setup_parser(subparser: ArgumentParser) → None

spack.cmd.python module

spack.cmd.python.ipython_interpreter(args)

An ipython interpreter is intended to be interactive, so it doesn’t support running a script or arguments

spack.cmd.python.propagate_exceptions_from(console)

Set sys.excepthook to let uncaught exceptions return 1 to the shell.

Parameters:

console (code.InteractiveConsole) – the console that needs a change in sys.excepthook

spack.cmd.python.python(parser, args, unknown_args)

spack.cmd.python.python_interpreter(args)

A python interpreter is the default interpreter

spack.cmd.python.setup_parser(subparser: ArgumentParser) → None

spack.cmd.reindex module

spack.cmd.reindex.reindex(parser, args)

spack.cmd.remove module

spack.cmd.remove.remove(parser, args)

spack.cmd.remove.setup_parser(subparser: ArgumentParser) → None

spack.cmd.repo module

spack.cmd.repo.repo(parser, args)

spack.cmd.repo.repo_add(args)

add package repositories to Spack’s configuration

spack.cmd.repo.repo_create(args)

create a new package repository

spack.cmd.repo.repo_list(args)

show registered repositories and their namespaces

List all package repositories known to Spack. Repositories can be local directories or remote git repositories.

spack.cmd.repo.repo_migrate(args: Any) → int

migrate a package repository to the latest Package API

spack.cmd.repo.repo_remove(args)

remove a repository from Spack’s configuration

spack.cmd.repo.repo_set(args)

modify an existing repository configuration

spack.cmd.repo.repo_show_version_updates(args)

show version specs that were added between two commits

spack.cmd.repo.repo_update(args)

update one or more package repositories

spack.cmd.repo.setup_parser(subparser: ArgumentParser)

spack.cmd.resource module

spack.cmd.resource.resource(parser, args)

spack.cmd.resource.resource_list(args)

list all resources known to spack (currently just patches)

spack.cmd.resource.resource_show(args)

show a resource, identified by its checksum

spack.cmd.resource.setup_parser(subparser: ArgumentParser) → None

spack.cmd.restage module

spack.cmd.restage.restage(parser, args)

spack.cmd.restage.setup_parser(subparser: ArgumentParser) → None

spack.cmd.solve module

spack.cmd.solve.setup_parser(subparser: ArgumentParser) → None

spack.cmd.solve.show_options

output options

spack.cmd.solve.solve(parser, args)

spack.cmd.spec module

spack.cmd.spec.setup_parser(subparser: ArgumentParser) → None

spack.cmd.spec.spec(parser, args)

spack.cmd.stage module

class spack.cmd.stage.StageFilter(exclusions, skip_installed)

Bases: object

Encapsulation of reasons to skip staging

spack.cmd.stage.setup_parser(subparser: ArgumentParser) → None

spack.cmd.stage.stage(parser, args)

spack.cmd.style module

spack.cmd.style.changed_files(base='develop', untracked=True, all_files=False, root=None) → List[Path]

Get list of changed files in the Spack repository.

Parameters:

• base (str) – name of base branch to evaluate differences with.

• untracked (bool) – include untracked files in the list.

• all_files (bool) – list all files in the repository.

• root (str) – use this directory instead of the Spack prefix.

spack.cmd.style.cwd_relative(path: Path, root: Path | str, initial_working_dir: Path) → Path

Translate prefix-relative path to current working directory-relative.

spack.cmd.style.exclude_paths

List of paths to exclude from checks – relative to spack root

spack.cmd.style.missing_tools(tools_to_run: List[str]) → List[str]

spack.cmd.style.mypy_ignores

warnings to ignore in mypy

spack.cmd.style.print_style_header(file_list: List[Path], args, tools_to_run)

spack.cmd.style.print_tool_result(tool, returncode)

spack.cmd.style.rewrite_and_print_output(output, root, working_dir, root_relative, re_obj=re.compile('^(.+):([0-9]+):'), replacement='{0}:{1}:')

rewrite output with <file>:<line>: format to respect path args

spack.cmd.style.ruff_check(file_list, args)

Run the ruff-check command. Handles config and non generic ruff argument logic

spack.cmd.style.ruff_format(file_list, args)

Run the ruff format command

spack.cmd.style.run_import_check(file_list, args)

spack.cmd.style.run_mypy(file_list, args)

spack.cmd.style.run_ruff(file_list: List[Path], cmd: str, args: List[str], root: Path, working_dir: Path, root_relative: bool)

Run the ruff tool

spack.cmd.style.setup_parser(subparser: ArgumentParser) → None

spack.cmd.style.style(parser, args)

class spack.cmd.style.tool(name: str, cmd: str | None = None, required: bool = False, external: bool = True)

Bases: object

property executable: Executable | None

property installed: bool

spack.cmd.style.tool_names

Order in which tools should be run. The list maps an executable name to a method to ensure the tool is bootstrapped or present in the environment.

spack.cmd.style.tools: Dict[str, tool]

tools we run in spack style

spack.cmd.style.validate_toolset(arg_value)

Validate --tool and --skip arguments (sets of optionally comma-separated tools).

spack.cmd.tags module

spack.cmd.tags.packages_with_tags(tags: Iterable[str], installed: bool, skip_empty: bool) → Dict[str, List[str]]

Returns a dict, indexed by tag, containing lists of names of packages containing the tag or, if no tags, for all available tags.

Parameters:

• tags – list of tags of interest or None for all

• installed – True if want names of packages that are installed; otherwise, False if want all packages with the tag

• skip_empty – True if exclude tags with no associated packages; otherwise, False if want entries for all tags even when no such tagged packages

spack.cmd.tags.report_tags(category, tags)

spack.cmd.tags.setup_parser(subparser: ArgumentParser) → None

spack.cmd.tags.tags(parser, args)

spack.cmd.test module

spack.cmd.test.report_filename(args, test_suite)

spack.cmd.test.setup_parser(subparser: ArgumentParser) → None

spack.cmd.test.test(parser, args)

spack.cmd.test.test_find(args)

find tests that are running or have available results

displays aliases for tests that have them, otherwise test suite content hashes

spack.cmd.test.test_list(args)

list installed packages with available tests

spack.cmd.test.test_remove(args)

remove results from Spack test suite(s) (default all)

if no test suite is listed, remove results for all suites.

removed tests can no longer be accessed for results or status, and will not appear in spack test list results

spack.cmd.test.test_results(args)

get the results from Spack test suite(s) (default all)

spack.cmd.test.test_run(args)

run tests for the specified installed packages

if no specs are listed, run tests for all packages in the current environment or all installed packages if there is no active environment

spack.cmd.test.test_status(args)

get the current status for the specified Spack test suite(s)

spack.cmd.test_env module

spack.cmd.test_env.test_env(parser, args)

spack.cmd.tutorial module

spack.cmd.tutorial.setup_parser(subparser: ArgumentParser) → None

spack.cmd.tutorial.tutorial(parser, args)

spack.cmd.undevelop module

spack.cmd.undevelop.setup_parser(subparser: ArgumentParser) → None

spack.cmd.undevelop.undevelop(parser, args)

spack.cmd.uninstall module

spack.cmd.uninstall.all_specs_in_env(env: Environment, specs: List[Spec]) → List[Spec]

Given a list of specs, return those that are in the env

spack.cmd.uninstall.dependent_environments(specs: List[Spec], current_env: Environment | None = None) → Dict[Environment, List[Spec]]

spack.cmd.uninstall.do_uninstall(specs: List[Spec], force: bool = False)

spack.cmd.uninstall.find_matching_specs(env: Environment | None, specs: List[Spec], allow_multiple_matches: bool = False, origin=None) → List[Spec]

Returns a list of specs matching the not necessarily concretized specs given from cli

Parameters:

• env – optional active environment

• specs – list of specs to be matched against installed packages

• allow_multiple_matches – if True multiple matches are admitted

• origin – origin of the spec

spack.cmd.uninstall.get_uninstall_list(args, specs: List[Spec], env: Environment | None)

Returns unordered uninstall_list and remove_list: these may overlap (some things may be both uninstalled and removed from the current environment).

It is assumed we are in an environment if --remove is specified (this method raises an exception otherwise).

spack.cmd.uninstall.installed_dependents(specs: List[Spec]) → List[Spec]

spack.cmd.uninstall.setup_parser(subparser: ArgumentParser) → None

spack.cmd.uninstall.uninstall(parser, args)

spack.cmd.uninstall.uninstall_specs(args, specs)

spack.cmd.unit_test module

spack.cmd.unit_test.add_back_pytest_args(args, unknown_args)

Add parsed pytest args, unknown args, and remainder together.

We add some basic pytest arguments to the Spack parser to ensure that they show up in the short help, so we have to reassemble things here.

spack.cmd.unit_test.do_list(args, extra_args)

Print a lists of tests than what pytest offers.

spack.cmd.unit_test.setup_parser(subparser: ArgumentParser) → None

spack.cmd.unit_test.unit_test(parser, args, unknown_args)

spack.cmd.unload module

spack.cmd.unload.setup_parser(subparser: ArgumentParser) → None

Parser is only constructed so that this prints a nice help message with -h.

spack.cmd.unload.unload(parser, args)

unload spack packages from the user environment

spack.cmd.url module

spack.cmd.url.name_parsed_correctly(pkg, name)

Determine if the name of a package was correctly parsed.

Parameters:

• pkg (spack.package_base.PackageBase) – The Spack package

• name (str) – The name that was extracted from the URL

Returns:

True if the name was correctly parsed, else False

Return type:

bool

spack.cmd.url.print_name_and_version(url)

Prints a URL. Underlines the detected name with dashes and the detected version with tildes.

Parameters:

url (str) – The url to parse

spack.cmd.url.remove_prefix(pkg_name)

Remove build system prefix ('py-', 'perl-', etc.) from a package name.

After determining a name, spack create determines a build system. Some build systems prepend a special string to the front of the name. Since this can’t be guessed from the URL, it would be unfair to say that these names are incorrectly parsed, so we remove them.

Parameters:

pkg_name (str) – the name of the package

Returns:

the name of the package with any build system prefix removed

Return type:

str

spack.cmd.url.remove_separators(version)

Remove separator characters (., _, and -) from a version.

A version like 1.2.3 may be displayed as 1_2_3 in the URL. Make sure 1.2.3, 1-2-3, 1_2_3, and 123 are considered equal. Unfortunately, this also means that 1.23 and 12.3 are equal.

Parameters:

version (str or spack.version.Version) – A version

Returns:

The version with all separator characters removed

Return type:

str

spack.cmd.url.setup_parser(subparser: ArgumentParser) → None

spack.cmd.url.url(parser, args)

spack.cmd.url.url_list(args)

spack.cmd.url.url_list_parsing(args, urls, url, pkg)

Helper function for url_list().

Parameters:

• args (argparse.Namespace) – The arguments given to spack url list

• urls (set) – List of URLs that have already been added

• url (str or None) – A URL to potentially add to urls depending on args

• pkg (spack.package_base.PackageBase) – The Spack package

Returns:

The updated set of urls

Return type:

set

spack.cmd.url.url_parse(args)

spack.cmd.url.url_stats(args)

spack.cmd.url.url_summary(args)

spack.cmd.url.version_parsed_correctly(pkg, version)

Determine if the version of a package was correctly parsed.

Parameters:

• pkg (spack.package_base.PackageBase) – The Spack package

• version (str) – The version that was extracted from the URL

Returns:

True if the name was correctly parsed, else False

Return type:

bool

spack.cmd.verify module

spack.cmd.verify.setup_parser(subparser: ArgumentParser)

spack.cmd.verify.verify(parser, args)

spack.cmd.verify.verify_libraries(args)

verify that shared libraries of install packages can be located in rpaths (Linux only)

spack.cmd.verify.verify_manifest(args)

verify that install directories have not been modified since installation

spack.cmd.verify.verify_versions(args)

Check that all versions of installed packages are known to Spack and non-deprecated.

Reports errors for any of the following:

1. Installed package not loadable from the repo

2. Installed package version not known by the package recipe

3. Installed package version deprecated in the package recipe

spack.cmd.versions module

spack.cmd.versions.setup_parser(subparser: ArgumentParser) → None

spack.cmd.versions.versions(parser, args)

spack.cmd.view module

Produce a “view” of a Spack DAG.

A “view” is file hierarchy representing the union of a number of Spack-installed package file hierarchies. The union is formed from:

• specs resolved from the package names given by the user (the seeds)

• all dependencies of the seeds unless user specifies --no-dependencies

• less any specs with names matching the regular expressions given by --exclude

The view can be built and tore down via a number of methods (the “actions”):

• symlink :: a file system view which is a directory hierarchy that is the union of the hierarchies of the installed packages in the DAG where installed files are referenced via symlinks.

• hardlink :: like the symlink view but hardlinks are used.

• statlink :: a view producing a status report of a symlink or hardlink view.

The file system view concept is inspired by Nix, implemented by Brett Viren ca 2016.

All operations on views are performed via proxy objects such as YamlFilesystemView.

spack.cmd.view.disambiguate_in_view(specs, view)

When dealing with querying actions (remove/status) we only need to disambiguate among specs in the view

spack.cmd.view.setup_parser(sp: ArgumentParser) → None

spack.cmd.view.view(parser, args)

Produce a view of a set of packages.